一文看懂java单例模式

2023-12-22 17:42 由 a小萝卜a 发表于 #软件工程

Java单例模式是一种常用的创建型设计模式，用于确保一个类只有一个实例，并提供一个全局访问点来访问该实例。在Java中，有多种方式可以实现单例模式，下面详细介绍其中的几种常见实现方式。

1什么是创建型设计模式？

处理对象创建的模式，简答的理解就是如何创建对象？很多人都会想到new关键字，一般的项目你到处new是不会有问题的，但是稍微复杂一点的项目，可能需要考虑到对象的单一性、复用性和可扩展性。

为什么要有单例模式？

单例模式可以提供一种简单而有效的方式来管理和访问全局资源，同时也可以提高系统的性能和可维护性

举一个案例，如果你需要一个全局的缓存（现在好多大数量级的都采用redis），那么这个缓存就只能存在一个实例对象中，理解下。当然总结下来：

节省资源：由于单例模式只创建一个实例，可以节省系统资源，特别是在需要频繁创建和销毁对象的情况下。

全局访问点：单例模式提供了一个全局访问点，可以方便地访问实例，避免了在不同的地方重复创建实例的问题。

数据共享：由于单例模式只有一个实例，可以方便地在不同的对象之间共享数据。

线程安全：单例模式可以确保在多线程环境下只有一个实例被创建，避免了多线程竞争的问题。

2.常见的单例模式

2.1 饿汉式（Eager Initialization）

在这种方式下，单例实例在类加载时就被创建，因此在多线程环境下也能保证只有一个实例。这种方式的缺点是，如果该实例一直没有被使用，会造成内存浪费。

如果看不懂下面代码，就复习下static和final关键字的作用，下面的get方法可有可无，有是因为满足java的封装性，实例变量都是私有静态的，对外提供public的get访问方法。

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    //下面相当于是一个get方法，符合封装性
    public static Singleton getInstance() {
        return instance;
    }
}

我们复习下static和final关键字：

static关键字用于修饰类的成员（字段、方法、代码块和内部类），表示它们属于类本身，而不是类的实例。所以static不可以用在类方法论里面。下面四条要记住：

静态字段（static fields）：静态字段是属于类的字段，而不是属于类的实例。它们在类加载时被初始化，并且在整个程序运行期间保持不变。可以通过类名直接访问静态字段，而不需要创建类的实例。

静态方法（static methods）：静态方法是属于类的方法，而不是属于类的实例。它们可以直接通过类名调用，而不需要创建类的实例。静态方法不能访问非静态的成员变量和方法，只能访问静态的成员变量和方法（这个可以这么理解：静态方法不需要创建对象就可以访问，属于类，非静态方法属于类的实例对象，所以静态方法不能直接访问非静态的，因为对象是类的具体化，静态是类的固有属性）。

静态代码块（static blocks）：静态代码块是在类加载时执行的一段代码。它们用于初始化静态字段或执行其他静态操作。静态代码块只会执行一次，并且在类加载时按照它们在代码中的顺序执行。

静态内部类（static inner classes）：静态内部类是定义在类内部的类，但是它是静态的，不依赖于外部类的实例。静态内部类可以直接通过外部类名访问，而不需要创建外部类的实例。

使用static关键字的一些常见用途包括：

创建工具类：将一些通用的方法和字段定义为静态的，可以直接通过类名调用，而不需要创建实例。

计数器：使用静态字段来记录某个类的实例数量。

常量定义：将一些常量定义为静态字段，可以在整个程序中共享使用。

单例模式：使用静态方法和静态字段来实现单例模式，确保只有一个实例被创建。

需要注意的是，静态成员属于类本身，而不是类的实例。因此，它们在内存中只有一份拷贝，并且可以被所有实例共享。同时，静态成员的生命周期与类的生命周期相同，即在类加载时初始化，在程序结束时销毁。

关键字final用于修饰类、方法和变量，具有不同的含义和用法。

final修饰类：当一个类被声明为final时，表示该类不能被继承。这意味着其他类不能扩展或继承该final类。

final修饰方法：当一个方法被声明为final时，表示该方法不能被子类重写或覆盖。final方法在父类中已经实现了最终的功能，子类不能对其进行修改。

final修饰变量：当一个变量被声明为final时，表示该变量的值不能被修改。final变量必须在声明时进行初始化，并且一旦初始化后，其值就不能再被修改。

final变量可以是基本数据类型，也可以是引用类型。对于基本数据类型的final变量，其值不能被修改。对于引用类型的final变量，其引用不能被修改，但是引用所指向的对象的内容可以被修改。

在Java中，final关键字用于声明一个常量，它可以应用于基本数据类型和引用类型。

对于引用类型的final变量，它的引用不能被修改，意味着一旦引用被赋值后，就不能再指向其他对象。这是因为final变量的引用在内存中是不可变的。

然而，虽然引用不能被修改，但是引用所指向的对象的内容可以被修改。这意味着通过final变量的引用，我们可以修改对象的属性或调用对象的方法，只要这些属性或方法不是被声明为final的。

例如，考虑以下代码片段：

final StringBuilder sb = new StringBuilder("Hello");

sb.append(" World");

sb是一个final变量，它的引用不能被修改。但是，我们可以通过sb引用来修改StringBuilder对象的内容，将" World"追加到字符串中。

总结起来，对于引用类型的final变量，它的引用不能被修改，但是引用所指向的对象的内容可以被修改。这样的设计可以保护引用不被误修改，同时允许对对象的内容进行修改。
public static void main(String[] args) {
		final StringBuilder s = new StringBuilder();
		StringBuilder b = new StringBuilder();
		StringBuilder c = new StringBuilder();
		b = c;
		s = b;
		/**
		 * The final local variable s cannot be assigned. It must be blank 
         *  and not using a compound assignment
		 */

	}
final变量在多线程环境下具有线程安全的特性，因为它的值不会被修改。

总结：

final修饰类：表示该类不能被继承。

final修饰方法：表示该方法不能被重写。

final修饰变量：表示该变量的值不能被修改。

2.2懒汉式（Lazy Initialization）

在这种方式下，单例实例在第一次使用时才被创建，以实现延迟加载。这种方式的缺点是，在多线程环境下可能会创建多个实例，需要通过加锁来解决。

下面有的同学就有看不懂了，我来复习下：

java声明一个对象变量（private static Singleton instance;）只是为该变量分配了内存空间，但没有实际创建对象。要创建对象实例，需要使用"new"关键字来调用类的构造方法。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

synchronized

synchronized关键字用于修饰方法或代码块，其作用是实现线程的同步，保证多个线程在访问共享资源时的互斥性和可见性。

当一个方法被synchronized修饰时，同一时刻只能有一个线程执行该方法，其他线程需要等待。这样可以避免多个线程同时访问共享资源导致的数据不一致或错误的问题。

具体来说，synchronized修饰方法的作用有以下几点：

互斥性：当一个线程进入synchronized修饰的方法时，其他线程需要等待，直到该线程执行完毕释放锁。这样可以保证同一时刻只有一个线程执行该方法，避免了多个线程同时修改共享资源导致的数据不一致问题。

可见性：synchronized修饰的方法会将修改共享资源的操作立即刷新到主内存中，其他线程可以立即看到最新的值。这样可以保证多个线程之间对共享资源的操作是可见的，避免了数据的脏读、写入和丢失等问题。

需要注意的是，synchronized修饰方法时，锁的粒度是整个方法，即一个线程获取了该方法的锁，其他线程需要等待该线程执行完整个方法才能获取锁。如果方法中只有一小部分代码需要同步，可以考虑使用synchronized代码块来实现更细粒度的锁定。

2.3 双重检查锁（Double-Checked Locking）

这种方式结合了饿汉式和懒汉式的优点，既实现了延迟加载，又保证了线程安全。在第一次创建实例时使用同步锁，以避免多线程环境下创建多个实例。

这种方式其实有点偏底层了，我们知道怎么写就可以。

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

volatile

volatile关键字用于修饰变量，用来保证变量的可见性和禁止指令重排序。

可见性：当一个变量被volatile修饰时，任何对该变量的修改都会立即被其他线程可见，即保证了线程之间的通信。这是因为volatile修饰的变量会被存储在主内存中，每次使用前都会从主内存中读取最新的值。

禁止指令重排序：在多线程环境下，为了提高性能，编译器和处理器可能会对指令进行重排序。然而，有些指令重排序可能会导致多线程程序出现问题。使用volatile关键字修饰的变量，可以禁止指令重排序，保证了程序的正确性。

需要注意的是，volatile关键字只能保证可见性和禁止指令重排序，并不能保证原子性。如果需要保证原子性，可以使用synchronized关键字或者使用原子类（如AtomicInteger）。

总结起来，volatile关键字在多线程编程中起到了重要的作用，可以保证变量的可见性和禁止指令重排序，从而保证了线程之间的正确通信。

2.4 静态内部类（Static Inner Class）

这种方式利用了Java类加载机制的特性，当第一次访问内部类时才会加载并初始化单例实例。这种方式既实现了延迟加载，又保证了线程安全。其实不建议写内部类，看似很装逼，实际很繁琐。

这种模式比较常见。

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

3.应用场景

单例模式适用于以下场景：

当一个类只需要一个实例时，可以使用单例模式。例如，数据库连接池、线程池等资源管理类只需要一个实例来管理资源。
当需要控制某个资源的访问权限时，可以使用单例模式。例如，配置文件读取类只需要一个实例来读取配置文件，并且避免多个实例同时修改配置文件。
当需要节省系统资源时，可以使用单例模式。例如，某个类的创建和销毁需要消耗大量资源，使用单例模式可以避免频繁创建和销毁实例，提高系统性能。
当需要全局访问某个对象时，可以使用单例模式。例如，日志记录类、缓存管理类等需要在整个系统中被访问的对象可以使用单例模式。

需要注意的是，单例模式可能会引起全局状态的共享和修改，因此在使用时需要谨慎考虑其对系统的影响。

【低代码】低代码平台协同&敏捷场景下的并行开发解决方案探索

低代码开发平台的研发团队往往把更多的经历投入到应用程度搭建过程的完善和丰富上（例如，丰富可通过搭建实现的功能，优化拖拽搭建的交互体验等），而忽略了项目交付过程的能力和体验。 ...阅读全文

逻辑多租场景下，故障爆炸半径的控制实践

本文对多租架构的典型故障场景进行分析，面对单租户 APP 异常导致的故障，提出应对的分级隔离方案，将单租户的运行资源消耗控制在确定的边界内，用确定性的故障隔离机制应对不确定的故障场景，以控制故障爆炸半径，减少平台级故障的发生。 ...阅读全文

同事突然问我：异步网络请求编码的方法

本文分享自华为云社区《异步网络请求编码》，作者：张俭。本文介绍常见的异步网络请求编码手法。尽管像golang这些的语言，支持协程，可以使得Programmer以同步的方式编写代码，大大降低编码者的心智负担。但网络编程中，批量又非常常见，这就导致即使在Golang中，也不得不进行协程的切换来满足批 ...阅读全文

现代 CPU 技术发展

这篇文章主要是介绍CPU技术的发展，包括最近几十年CPU性能提升和半导体工艺发展，当前技术发展方向。希望可以帮助软件开发者理解CPU指令集和组成运行原理、CPU性能提升的现状和瓶颈、CPU技术发展方向会如何影响软件开发/设计的框架和编程思想。 ...阅读全文

夜莺项目发布 v6.5.0 版本，暗黑菜单来了

大家好，夜莺项目发布 v6.5.0 版本，启用新 logo，菜单支持换肤，支持了暗黑版本的菜单，下一步会支持全站暗黑主题，敬请期待，下面是新 logo。暗黑菜单页面右上角点击用户名，在下拉框里会有主题设置，可以选择暗黑主题菜单，效果如下：监控大盘详情页面右上角也多了一个主题设置，可以选择 da ...阅读全文

详解ZooKeeper在微服务注册中心的应用

本文分享自华为云社区《SpringCloud ZooKeeper 详解，以及与Go、Rust等非Java服务的集成》，作者：张俭。 ZooKeeper，是一个开源的分布式协调服务，不仅支持分布式选举、任务分配，还可以用于微服务的注册中心和配置中心。本文，我们将深入探讨ZooKeeper用做微服务注 ...阅读全文

玩转Sermant开发，开发者能力机制解析

本文分享自华为云社区《开发者能力机制解析，玩转Sermant开发》，作者：华为云开源。前言：在《Sermant框架下的服务治理插件快速开发及使用指南》中带大家一起体验了Sermant插件的开发，快速的了解了Sermant插件开发的全过程，本着从入门到精通的思路，本文对在开发中所常用的能力，从机 ...阅读全文

利用夜莺开源版对H3C无线设备监控

编者荐语：真正搞监控的人肯定知道 SNMP 水有多深，有时我甚至腹黑猜测，这些厂商是故意的吧，，，指标不标准，格式各异，只能靠一款灵活的采集器了，本文是夜莺社区用户写的文章，转给大家参考。 author:网络小斐关于夜莺SNMP插件前文说明了利用夜莺开源版如何监控H3C交换机的，算是抛砖引玉；秉 ...阅读全文

读程序员的README笔记15_敏捷计划

1. 行为准则 2. 敏捷开发 2.1. 软件开发应该有计划和与之相应的跟踪 2.1.1. 你的队友想知道你在做什么，这样他们就能与你有效地配合 2.2. 敏捷开发是一种软件开发模型，被广泛采用于快速交付优质软件的场景 2.3. 要理解敏捷开发实践，你必须要首先理解敏捷哲学 2.4. 敏捷开发诞生于 ...阅读全文

面试官问我：线程锁导致的kafka客户端超时，如何解决？

本文分享自华为云社区《线程锁导致的kafka客户端超时问题》，作者：张俭。问题背景有一个环境的kafka client发送数据有部分超时，拓扑图也非常简单定位历程我们先对客户端的环境及JVM情况进行了排查，从JVM所在的虚拟机到kafka server的网络正常，垃圾回收（GC）时间也在 ...阅读全文