单例模式的几种实现方式

public class Single {
	private static final Single INSTANCE = new Single();

	private Single() {}
	public static Single getInstance() {return INSTANCE;}

	public static void main(String[] args) {
		Single s1 = new Single().getInstance();
		Single s2 = new Single().getInstance();
		System.out.println(s1 == s2);

		for(int i = 0; i < 100; i++){
			new Thread(() ->     
               System.out.println(Singleton.getInstance().hashCode())
            ).start();
		}
	}
}

在这个例子中， INSTANCE 是一个静态常量，它在类加载时被初始化为 Single 类的实例。getInstance() 方法提供了对该实例的全局访问点。

优点：

写法比较简单，没有线程同步等复杂问题。
线程安全：实例在类装载的时候就完成实例化，避免了线程同步问题。
线程访问单例实例的速度比懒汉式单例模式更快。

缺点：

不是懒加载，如果从始至终从未使用过这个实例，会造成内存浪费。
如果类被不同的类加载器加载就会创建不同的实例。
如果单例类依赖于其他类，这些依赖的类在类加载时也会被创建。

二、懒汉式单例

原理：在懒汉式单例模式中，实例在第一次使用时才被创建。当实例没有被创建的时候，如果有多个线程都调用getInstance方法，就可能创建多个实例，就存在线程安全问题。但是实例一旦创建好，后面线程调用getInstance方法就不会出现线程安全问题。

私有化构造函数 ：防止外部通过new关键字直接创建类的实例。
声明私有静态变量：用于存储类的唯一实例。
提供公共静态方法：首先检查实例是否已经创建，如果没有则创建实例并返回；如果已经创建则直接返回。

具体来说，请看下面这个代码，

java 复制代码

public class Single {
	private static Single instance;

	//私有构造函数，防止外部实例化
	private Single() {}

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

	public static void main(String[] args) {
		Single s1 = new Single().getInstance();
		Single s2 = new Single().getInstance();
		System.out.println(s1 == s2);

		for(int i = 0; i < 100; i++){
			new Thread(() ->     
               System.out.println(Singleton.getInstance().hashCode())
            ).start();
		}
	}
}

在上面的实现中，instance 是静态变量，用于存储单例对象。在 getInstance 方法中，如果 instance 为 null，则创建一个新的 Singleton 对象，否则直接返回 instance。由于没有进行同步锁定，所以线程不安全，可能会导致并发创建多个实例的问题。

优点：

简单易懂，易于实现。
延迟加载：单例对象被使用的时候才初始化，避免了内存浪费。

缺点：线程不安全，只能在单线程中使用，当有多个线程同时进入getInstance() 方法中的if判断，若判断为 null 就会创建多个实例对象。

三、加锁的懒汉式单例

原理：我们对 getInstance() 方法使用synchronized关键字修饰，也就是每次调用该方法的时候都会竞争锁，但是创建实例只需要创建一次，即确保每次只有一个线程能够执行该方法。也就是创建实例后，再调用该方法还需要竞争锁释放锁。

具体来说，请看下面这个代码，

java 复制代码

public class Single {
	private static Single instance;

	//私有构造函数，防止外部实例化
	private Single() {}

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

	public static void main(String[] args) {
		Single s1 = new Single().getInstance();
		Single s2 = new Single().getInstance();
		System.out.println(s1 == s2);

		for(int i = 0; i < 100; i++){
			new Thread(() ->     
               System.out.println(Singleton.getInstance().hashCode())
            ).start();
		}
	}
}

优点：线程安全，只有在使用时才会实例化单例，一定程度上节约了资源。

缺点：效率低下，每次调用 getInstance() 获取实例时都需要加锁和释放锁。

适用：适用于那些实例创建开销较大，且不一定在程序启动时就需要使用的场景。例如，一些重量级的资源管理器、配置管理器等，可以在实际使用时才进行创建和初始化，以减少启动时间和内存占用。

四、双重校验锁单例模式 DCL

在上述代码的基础上进行改动：使用双重if判定来降低竞争锁频率，使用volatile修饰instance。

"双重检查锁"（Double-Checked Locking） 是懒汉式的一种优化，这种实现方式结合了懒汉式和饿汉式的优点，既能够延迟对象的创建时间，又能够保证线程安全。

原理：

利用 volatile 关键字防止指令重排，保证了可见性。保证在多线程环境中，当一个线程读取到 instance 为非 null 时，它确实指向了一个有效的实例。
利用双重检查机制 减少了同步带来的性能损耗。同步代码块确保了在多线程环境下，只有一个线程能够初始化 instance 变量。

具体来说，请看下面这个代码，

java 复制代码

public class Single {
	private static volatile Single instance;

	//私有构造函数，防止外部实例化
	private Single() {}

	public static synchronized Single getInstance() {
        //第一次判断,如果instance不为null,不进入抢锁阶段,直接返回实例
		if (instance == null){
			synchronized (Single.class){
                //抢到锁之后再次进行判断是否为null
				if (instance == null) instance = new Single();
			}
		}
		return instance;
	}

	public static void main(String[] args) {
		Single s1 = new Single().getInstance();
		Single s2 = new Single().getInstance();
		System.out.println(s1 == s2);

		for(int i = 0; i < 100; i++){
			new Thread(() ->     
               System.out.println(Singleton.getInstance().hashCode())
            ).start();
		}
	}

在这个例子中， instance 是一个 volatile 的静态变量，它在第一次使用时被创建。getInstance() 方法使用双重检查锁定来确保 INSTANCE 的唯一性。当多个线程同时访问 getInstance() 方法时，只有第一个线程会获得锁定并创建实例。其他线程会等待锁定被释放后再次检查 instance 是否为空，从而避免了多次创建实例的情况。

需要注意的是，使用 volatile 关键字可以确保 instance 变量的可见性和有序性，从而保证多线程环境下的正确性。

优点：

线程安全，适合高并发场景。
延迟加载，只有当需要用到实例时才会创建，节省了系统资源。
效率较高：避免对整个方法被锁，只对需要锁的代码部分加锁。

缺点：

实现复杂，容易出现问题。
由于 Java 内存模型的限制，可能会出现指令重排的问题，需要使用 volatile 关键字来解决。

为什么是要两次判断？

（1）第一次判断singleton是否为null

第一次判断是在Synchronized同步代码块外进行判断，由于单例模式只会创建一个实例，并通过getInstance方法返回singleton对象，所以，第一次判断，是为了在singleton对象已经创建的情况下，避免进入同步代码块，直接return返回，提升效率。

（2）第二次判断singleton是否为null

第二次判断是为了避免以下情况的发生。

假设线程A已经经过第一次判断，判断singleton=null，准备进入同步代码块。此时线程B获得时间片，由于线程A并没有创建实例，所以，判断 singleton仍然=null，所以线程B创建了实例singleton。此时，线程A再次获得时间片，由于刚刚经过第一次判断 singleton=null(不会重复判断)，进入同步代码块，这个时候，我们如果不加入第二次判断的话，那么线程A又会创造一个实例singleton，就不满足我们的单例模式的要求，所以第二次判断是很有必要的。

因此，内层的的if判断是为了在实例未被创建时，多个线程同时竞争锁，只有一个线程竞争成功并创建实例，其他竞争失败的线程就会阻塞等待，当第一线程释放锁后，这些竞争失败的线程就会继续竞争，但是实例已经创建好了，所以需要再次进行if判断。

为什么需要加volatile关键字？

Volatile禁止JVM对指令进行重排序。所以创建对象的过程仍然会按照指令1-2-3 的有序执行。

保证变量的可见性：当一个被volatile关键字修饰的变量被一个线程修改的时候，其他线程可以立刻得到修改之后的结果。

屏蔽指令重排序：指令重排序是编译器和处理器为了高效对程序进行优化的手段，它只能保证程序执行的结果时正确的，但是无法保证程序的操作顺序与代码顺序一致。这在单线程中不会构成问题，但是在多线程中就会出现问题。

在java内存模型中，volatile 关键字作用可以是保证可见性或者禁止指令重排。

这里是因为 singleton = new Singleton() ，它并非是一个原子操作，事实上，在 JVM 中上述语句至少做了以下这 3 件事：

第一步是给 singleton 分配内存空间；
第二步开始调用 Singleton 的构造函数等，来初始化 singleton；
第三步，将 singleton 对象指向分配的内存空间（执行完这步 singleton 就不是 null 了）。

这里需要留意一下 1-2-3 的顺序，因为存在指令重排序的优化，也就是说第 2 步和第 3 步的顺序是不能保证的，最终的执行顺序，可能是 1-2-3，也有可能是 1-3-2。

如果是 1-3-2，那么在第 3 步执行完以后，singleton 就不是 null 了，可是这时第 2 步并没有执行，singleton 对象未完成初始化，它的属性的值可能不是我们所预期的值。假设此时线程 2 进入 getInstance() 方法，由于 singleton 已经不是 null 了，所以会通过第一重检查并直接返回，但其实这时的 singleton 并没有完成初始化，所以使用这个实例的时候会报错。

五、静态内部类单例模式

由于饿汉式单例类不能实现延迟加载，不管将来用不用始终占据内存,懒汉式单例类线程安全控制烦琐，而且性能受影响。

静态内部类实现单例模式就可以克服以上两种单例模式的缺点，是一种优雅而简洁的实现方式。

原理：引入了静态内部类（只有在调用时才会加载），利用了 Java 类加载器机制，保证了实例的延迟初始化和唯一性，并避免了饿汉式单例模式的缺点。

具体来说，请看下面这个代码，

java 复制代码

public class Singleton {
	//私有构造函数，防止外部实例化
	private Singleton() {}

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

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

	public static void main(String[] args) {
		Singleton s1 = new Singleton().getInstance();
		Singleton s2 = new Singleton().getInstance();
		System.out.println(s1 == s2);

		for(int i = 0; i < 100; i++){
			new Thread(() ->     
               System.out.println(Singleton.getInstance().hashCode())
            ).start();
		}
	}
}

在这个例子中， Singleton 类的构造方法是私有的，只能在 Singleton 类的内部进行调用。 SingletonHolder 类是 Singleton 类的一个静态内部类，它在 Singleton 类被加载时并不会立即被加载，而是在第一次调用 Singleton.getInstance() 方法时才会被加载，从而实现了延迟加载。

由于静态内部类 SingletonHolder 只会被加载一次，因此 INSTANCE 实例也只会被创建一次，从而保证了实例的唯一性。总的来说，静态内部类单例模式是一种比较优秀的单例模式实现方式，它兼顾了线程安全、懒加载和高效等特点，是一种值得推荐的单例模式实现方式。

总结来说，由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例Singleton，第一次调用getInstance()时将加载内部类SingletonHolder，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

优点：

线程安全： 静态内部类只会被加载一次，因此可以保证单例对象的线程安全性；
延迟加载：第一次加载类时不会初始化实例，只有在第一次调用 getInstance()方法时，JVM 会加载静态内部类，同时初始化实例。
高效：静态内部类单例模式没有加锁，所以性能比懒汉式和饿汉式都要高；
简单： 静态内部类单例模式的实现比较简单，代码量较少。

缺点：

不易理解： 相比于饿汉式和懒汉式，静态内部类单例模式的实现方式可能不太容易理解；
无法传递参数： 静态内部类单例模式的构造函数是私有的，无法传递参数。如果需要传递参数，需要使用其他方式实现。
虽然保证了单例在多线程并发下的线程安全性，但是在遇到序列化对象时，默认的方式运行得到的结果就是多例的。

六、枚举单例模式

枚举单例模式是一种比较新的单例模式实现方式，它在 Java 5 中引入，是在JDK1.5以及以后版本中增加的一个"语法糖"，它主要用于维护一些实例对象固定的类。例如一年有四个季节，就可以将季节定义为一个枚举类型，然后在其中定义春、夏、秋、冬四个季节的枚举类型的实例对象。按照Java语言的命名规范，通常，枚举的实例对象全部采用大写字母定义，这一点与Java里面的常量是相同的。

原理：默认枚举实例的创建是线程安全的，即使反序列化也不会生成新的实例，任何情况下都是一个单例。它利用了 Java 中枚举类型的特性来实现单例模式，枚举类型的每个枚举常量都是单例的。

具体来说，请看下面这个代码，

java 复制代码

public class Singleton {
	//私有构造函数，防止外部实例化
	private Singleton() {}

	private enum EnumSingleton{
		INSTANCE;
		private Singleton instance;
		//枚举类的构造方法在类加载时被实例化
		private EnumSingleton(){instance = new Singleton();}
		public Singleton getInstance(){return instance;}
	}

	public static Singleton getInstance(){
		return EnumSingleton.INSTANCE.getInstance();
	}

	public static void main(String[] args) {
		Singleton s1 = new Singleton().getInstance();
		Singleton s2 = new Singleton().getInstance();
		System.out.println(s1 == s2);
	}
}

在这个例子中，

多线程测试的结果如下，

总之，单例模式是一种非常常用的设计模式，可以确保类只有一个实例，并提供全局访问点以访问该实例。在 Java 中，有多种方式可以实现单例模式，开发者可以根据实际需要选择适合自己的实现方式。

其他

volatile的原理

volatile保证了可见性，有序性，在Java层面看，volatile是无锁操作，多个线程对volatile修饰的变量进行读可以并发并行执行，和无锁执行效率差不多。

volatile修饰的变量中，CPU使用了缓存一致性协议来保证读取的都是最新的主存数据。

缓存一致性：如果有别的线程修改了volatile修饰的变量，就会把CPU缓存中的变量置为无效，要操作这个变量就要从主存中重新读取。

volatile的扩展问题

如果说volatile不保证有序性，双重校验锁的写法是否有问题？

关于new对象按顺序分为3条指令：分配对象的内存空间、实例化对象、赋值给变量。

正常的执行顺序为(1)(2)(3)，JVM可能会优化进行重排序后的顺序为(1)(3)(2)。这个重排序的结果可能导致分配内存空间后，对象还没有实例化完成，就完成了赋值。在这个错误的赋值后，instance==null不成立，线程就会拿着未完成实例化的instance，使用它的属性和方法就会出错。

使用volatile保证有序性后，线程在new对象时不管(1)(2)(3)是什么顺序，后续线程拿到的instance是已经实例化完成的CPU里边，基于volatile变量操作是有CPU级别的加锁机制，它保证(1)(2)(3)全部执行完，写回主存，再执行其他线程对该变量的操作。