阿华代码，不是逆风，就是我疯，你们的点赞收藏是我前进最大的动力！！希望本文内容能够帮助到你！
目录
一：单例模式（singleton）
1：概念
单例模式就是，在java进程中，要求指定的类，只能有一个对象
我们通过一些特殊的技巧来确保，我们的实例（对象）只有一个------换句话说，就是如果我们尝试new多个实例，编译器就会报错。
二："饿汉模式"
1：前引
（1）知识科普
我们先认识俩个单词------singleton（单例模式）和getInstance（获取实例）
（2）每个类只能有一个类对象，比如Thread类，Thread.class（获取到Thread这个类的类对象）它是从.class文件加载到内存当中的
2：代码编译
java
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-24
* Time: 13:20
*/
class Singleton{
private static Singleton instance = new Singleton();
public static Singleton getInstance(){//返回值类型为Singleton
return instance;
}
private Singleton(){
//静态构造方法让你访问不到
}
}
public class ThreadDemon28 {
//"饿汉模式"
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);//判断s1和s2是否指向的是同一个对象
}
}
3：代码分析
最后我们在main方法中比较s1，s2获取到的地址是否相同（s1，s2所指向的对象）
4：解释为什么叫"饿汉模式"
因为我们在类加载的时候就创建了这个实例，（初始化静态成员变量），这个时机非常的早------相当于程序一启动，实例就创建好了。所以就用"饿汉"来形容创建实例非常的迫切非常早
三："懒汉"模式
1：前引
"懒汉"模式相对于"饿汉"模式不同的地方在于创建实例的时机更加晚一些，下面我们通过代码来进行展示
2：代码编译
java
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-24
* Time: 13:52
*/
class SingletonLazy{
private static SingletonLazy instance = null;
public static SingletonLazy getInstance(){
if (instance == null){ //如果instance为null，则进入if创建实例，创建实例的时机是第一次调用getInstance这个方法
instance = new SingletonLazy();
}
return instance;//第二次第三次调用getInstance()这个方法，就不会进入if语句中，而直接返回instance了
}
private SingletonLazy(){
}
}
public class ThreadDemon29 {
public static void main(String[] args) {
SingletonLazy s1 = SingletonLazy.getInstance();
SingletonLazy s2 = SingletonLazy.getInstance();
System.out.println(s1 == s2);
}
}
3：代码分析
很明显的不同是，初始，instance初始化为null，并没有实例化对象，只有第一次调用了getInstance方法后才会实例化SingletonLazy
4："懒汉"的优点
例如现在有一个非常大的文件（1个G）
"饿汉"模式会直接把一个G全部加载到内存中，在进行展示。
"懒汉"模式会先加载100kb的数据到内存中，随着用户的翻页，在逐步的加载到内存当中
5：比较"饿汉"和"懒汉"
（1）创建时机上"饿汉"更早
（2）"饿汉"创建实例依赖于程序驱动，"懒汉"创建实例依赖于调用方法
四："饿汉"模式线程安全问题
对于饿汉模式，无论有多少个线程在调用getInstance 方法，都会返回instance，对于return这一条代码来说，只有一个"读操作"，线程是非常安全的
五："懒汉"模式的线程安全问题
1：重复创建实例
①看下面这个例子，我们拆分if里面的代码，会发现实例被new了两次，这就不是单例模式了，就有bug了
②有人说：不就是多new了个对象嘛，问题不大~~~。但是对于单例模式来说，一个对象可能要管理10GB的内存，或者更大，多new一个对象，就多翻了一倍的内存啊！！
2：解决问题
想办法给if条件和创建实例进行打包------用关键字synchronized。
（1）解决思路的核心本质：
是让，if语句打包成一个整体，成为"原子性操作"
（2）缺点：
①效率降低：
以下加锁的思路有一个致命缺点，我们保证多线程下我们创建出来的实例就只有一个是通过"加锁"和"解锁"来解决的，但是这个过程很耗费资源
②不可预期：
一旦线程发生了阻塞，那么什么时候解除阻塞我们是不可控制和预期的
3：优化效率问题
（1）问题解释
（2）解决方法
六：指令重排序问题
前引：
指令重排序是编译器优化的一种方式，调整原有代码的执行顺序，保证逻辑不变的前提下，提高程序的效率
1：代码拆分三指令
上面这段代码可以分为三个指令来执行
①申请一段内存空间 （买房子）
②在这段内存上，调用构造方法，初始化实例 （给房子装修）
③把内存地址赋值给instance （拿到房子的钥匙）
java
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-24
* Time: 13:52
*/
class SingletonLazy{
private static Object locker1 = new Object();
private static SingletonLazy instance = null;
public static SingletonLazy getInstance(){
if (instance == null){
synchronized(locker1){
if (instance == null){ //如果instance为null，则进入if创建实例，创建实例的时机是第一次调用getInstance这个方法
instance = new SingletonLazy();
}
}
}
return instance;//第二次第三次调用getInstance()这个方法，就不会进入if语句中，而直接返回instance了
}
private SingletonLazy(){
}
}
public class ThreadDemon29 {
public static void main(String[] args) {
SingletonLazy s1 = SingletonLazy.getInstance();
SingletonLazy s2 = SingletonLazy.getInstance();
System.out.println(s1 == s2);
}
}2：分析
我们延用上面的代码
上述三个指令的执行顺序可以为①②③，也可以为①③②
问题出现在如果执行顺序为①③②上
3：代码解释
线程t1经过代码优化后，先执行③赋值地址，此时instance只是接收了一个地址，它所指向的是一个尚未被初始化的对象，这个对象啥也不是，可以理解成"全为0"
恰巧此时线程t2插入，进入if条件判断，判断instance ！= null，线程t2以为实例已经创建完毕，直接return instance，假设t2紧接着调用instance里面的方法或者属性，就会出现大问题。
4：解锁思路
加入关键字volatile
（1）复习volatile两个功能
①保证内存可见性（即每次访问变量都要重新读取内存，而不会优化到寄存器或者缓存当中）
②禁止指令重排序
此时针对变量的读写操作，就不会出现重排序的问题了