前言
什么是单例模式？
其实用通俗的话就是程序猿约定俗成的一些东西，就比如如果你继承了一个抽象类，你就要重写里面的抽象方法，如果你实现了一个接口，你就要重写里面的方法。如果不进行重写，那么编译器就会报错。这其实就是一个规范。
而单例模式能保证某个类在程序中只存在唯一的一个实例，而不会创建出多个实例
那么，单例模式又分成“饿汉”和“懒汉”两种、
一.饿汉模式
顾名思义，饿汉模式就是在类加载的时候，创建实例。
package thread; //期待这个类能有唯一实例 public class hungryDemo { private static hungryDemo instance = new hungryDemo(); public static hungryDemo getInstance() { return instance; } //把构造方法设置为私有,这样在类外就无法 new 出这个对象的实例了 private hungryDemo() { } }代码解读：
1. 首先创建了一个 hungryDemo 类，里面有一个类方法和一个类变量
2. 我们将构造方法设置为了private，那么在类外就无法再针对 hungryDemo 再实例化类了
我们现在在类外，通过 hungryDemo提供的 public static hungryDemo getInstance 方法来进行调用，可以发现如下结果：
class Demo1 { public static void main(String[] args) { hungryDemo h1 = hungryDemo.getInstance(); hungryDemo h2 = hungryDemo.getInstance(); System.out.println(h1 == h2); } }运行结果：
可以发现，两者获取到的类对象引用是一致的，那么单例模式的饿汉版本就创建好了。
二.懒汉模式
🎈单线程版本
我们的预期结果是不变的，那就是要实现单例模式，也就是这个类 只能被实例化一次！！！
那么懒汉模式顾名思义，也就是类加载的时候不创建实例，第一次使用的时候才创建实例。
那么我们可以写出以下代码：
package thread; public class lazyDemo { private static lazyDemo instance = null; public static lazyDemo getInstance() { /** * 只有调用该方法的时候，才创建对象 */ if (instance == null) { instance = new lazyDemo(); } return instance; } private lazyDemo() { } }代码解读：
🍺首先，设置类成员变量 instance 为 null，当第一次使用getInstance()的时候才进行创建对 象。
🍺其次，跟饿汉模式一样，将类的构造方法设置为 private ，类外无法再次创建对象。
🍺最后，在getInstance方法中判断 instance 是否为空，为空那就创建对象。为空说明已经 被调用一次了，那么就直接返回 instance 引用。
🎈🎈多线程版本 1
在以上的单线程版本中，我们不难发现以下问题：
假设现在有两个线程，他们是按照如下的顺序来执行的：
那么此时的代码就会出现问题： t1 线程首先判断了 instance 是否为空，此时 t2 线程来运行了，也判断 instance 是否为空，紧接着 instance不为空，然后就创建了对象！ 然后再回到 t1 线程中，又要进行创建对象。 此时问题已经很明显了，那就是 由于if代码块在多线程中的执行顺序问题导致的
更精简一下：
就是 instance = new lazyDemo() 是写操作， instance == null 是读操作，在多线程中，如果一段代码即涉及读操作，又设计写操作，那么就很容易出现问题！！！
🍭解决办法：
当一段代码是因为读写操作出BUG，我们首先想到的就是加锁。也就是在我写的时候，你不要 读。我读的时候，你不要写。
synchronized 是一种内置的 Java 关键字，它用于实现线程的同步。当一个线程进入synchronized块或方法时，它获得了锁，这会阻止其他线程同时进入相同的synchronized块或方法，从而确保了共享资源的互斥访问。
修改代码如下：
package thread; public class lazyDemo { private static lazyDemo instance = null; public static lazyDemo getInstance() { /** * 只有调用该方法的时候，才创建对象 */ synchronized (lazyDemo.class) { //1. 加锁解决的是线程安全问题(确保是单例模式,只new一次) if (instance == null) { instance = new lazyDemo(); } } return instance; } private lazyDemo() { } }对于对象lazyDemo.class，实际上就是lazyDemo这个类，也就是对类进行加锁。
此时加锁之后，当t1线程进行读写操作的时候，t2线程再次进行访问就只能进行阻塞。
此时t1就可以放心创建出一个对象出来，此时t2再进行调用方法的时候，instance 不为空，就直接返回 t1 创建好的对象引用。 这时候就确保了只创建出一个实例。
🎈🎈🎈 多线程版本2
其实，多线程版本1 还是有问题的，我们发现：如果t1 线程加锁后创建好了对象，其他线程（t2，t3，t4.........）在进行访问的时候，首先就要进行加锁操作。 也就是每次访问都要进行加锁，这是一个资源开销非常大的操作。
深入探究一下，我们发现其他线程（t2，t3，t4.........）在进行访问的时候，只需要判断当前的对象是否被创建好了即可。如果被创建好了，那么就直接返回对象引用。如果没有被创建好，再进行加锁创建对象。
修改代码如下：
public class lazyDemo { private static lazyDemo instance = null; public static lazyDemo getInstance() { /** * 只有调用该方法的时候，才创建对象 */ if(instance == null) { //2. if判断解决的是多次加锁,加锁频率太高的问题 synchronized (lazyDemo.class) { //1. 加锁解决的是线程安全问题(确保是单例模式,只new一次) if (instance == null) { instance = new lazyDemo(); } } } return instance; } private lazyDemo() { } }在多线程中，这两个 if 的作用大不相同！！！
修改后，我们发现如果 t1 线程创建好了对象， 此时其他线程（t2，t3，t4.........）在进行调用的时候，首先判断了instance 是否为空，不为空就说明已经创建好了对象~
🎈🎈🎈🎈多线程版本3
其实到现在，这个懒汉模式的单例代码还是有问题！！！
在多线程下，要考虑到编译器的优化问题，当编译器没有按照我们的逻辑进行操作的时候，那么就会出现问题。
在此代码中，new 操作可以分为以下三步：
1.申请内存空间（一定先执行），获取到内存地址
2.在内存空间上构造对象（构造方法）
3.把内存的地址，赋值给 instance 引用
在单线程环境下，执行那种顺序都无所谓，但是如果在多线程环境下，就可能出现问题：
假设是按照 1 3 2 的顺序来执行，当 1 和 3 操作执行完的时候，instance 已经非空了，只是内存空间上还没有构造对象 / 方法，此时instance 指向的是一个还没初始化的非法对象。 此时此刻 t2 进行访问，判断 instanc 是不为空的，然后就返回了一个还没初始化的非法对象，进一步 t2 线程就有可能访问 instance 里面的属性和方法。此时就出现了问题了。
这个问题就是指令重排序问题，解决办法就是让 instance 加入上volatile 关键字，此时就避免了指令重排序问题。
//3.加 volatile是为了解决new 操作的指令重排序问题
private volatile static lazyDemo instance = null;
此时的代码就会严格按照 1 2 3 的顺序执行。
总结：单例模式是一个约定俗成的规范，保证一个类只能实例化一个对象。饿汉模式在多线程和单线程都没有问题，因为一开始它就创建好了对象。 而懒汉模式的多线程版本会出现以下三个问题：1. 线程安全问题（ 确保只new 一次）2. 多次重复加锁的问题 3. 指令重排序问题。
希望以上的解决办法对你有所帮助！！！
