目录
一、什么是单例模式
单例模式是Java中的设计模式之一，能够保证某个类在程序中只存在唯一一份实例，而不会创建出多个实例
单例模式有很多实现方式，最常见的是饿汉和懒汉两种模式
二、饿汉模式
饿汉模式在类加载时就创建实例
如何实现饿汉式单例模式？
1. 在类中完成实例的初始化，在创建的类中创建唯一实例
2. 对外提供获取该唯一实例的方法，提供访问该实例的全局静态方法getInstance()，来获取该类的唯一实例
3. 构造方法私有化，保证类外部不能实例化，只有在类中创建的唯一实例
//饿汉式单例模式
public class HungrySingLeton {
//在类中创建唯一实例
private static final HungrySingLeton instance = new HungrySingLeton();
//构造方法私有化，保证类外部不能进行实例化
private HungrySingLeton(){}
//对外提供获取该唯一实例的方法
public static HungrySingLeton getInstance(){
return instance;
}
}饿汉式单例模式线程安全吗？
饿汉式单例模式在类加载时就进行初始化，创建唯一实例。它在线程还没出现之前就实例化了，外部只能通过getInstance()方法来获取唯一实例，相当于“读操作”，因此是线程安全的
饿汉式单例模式的缺点
在类加载时就创建实例，并一直在内存中，若不使用该实例，该实例仍然存在，此时存在内存浪费问题
三、懒汉模式
类加载时不创建实例，直到第一次使用的时候才创建实例
如何实现懒汉模式？
懒汉模式的实现与饿汉模式类似，唯一的区别是懒汉模式直到第一次使用的时候才会创建实例
1. 在类中创建唯一实例，并将该实例的初始值设为null
2. 对外提供获取该唯一实例的方法，若是第一次使用该方法，则创建实例
3. 构造方法私有化，保证类外部不能实例化，只有在类中创建的唯一实例
public class LazySingleton {
//在类中创建唯一实例,并将其置为null
private static LazySingleton instance = null;
//构造方法私有化，保证类外部不能进行实例化
private LazySingleton(){}
//对外提供获取该唯一实例的方法
public static LazySingleton getInstance(){
//若是第一次使用该方法，则初始化instance
if (instance == null){
instance = new LazySingleton();
}
return instance;
}
}
懒汉模式线程安全吗？
在多线程情况下，可能会出现创建多个实例的情况
如何解决线程安全问题？
通过加锁，来解决线程安全问题
将判断instance是否为空，和创建实例两个操作加上锁，或是直接在方法上加上synchronized，从而保证在上图的情况下，也只创建一个实例
public static LazySingleton getInstance(){
synchronized (LazySingleton.class){
//若是第一次使用该方法，则初始化instance
if (instance == null){
instance = new LazySingleton();
}
}
return instance;
}或
public synchronized static LazySingleton getInstance(){
//若是第一次使用该方法，则初始化instance
if (instance == null){
instance = new LazySingleton();
}
return instance;
}此时
由于加锁和解锁开销较高，而懒汉式单例模式仅在第一次调用时，才会存在可能创建多个实例的问题，在后面调用getInstance()方法时，判断instance不为空，直接返回instance，而在加锁后，无论是否已经存在实例，在多线程情况下都会发生阻塞，此时存在执行效率低的问题
因此，在加锁前，判断是否已经创建实例，若已经创建实例，则直接返回instance，若未创建实例，则进行加锁操作
public static LazySingleton getInstance(){
//判断是否已经创建实例，若已经创建实例，则不加锁，直接返回instance
if(instance == null){
//若实例未创建，则向下执行来竞争锁
//竞争成功的锁，进行创建实例操作
synchronized (LazySingleton.class){
//在竞争成功的锁创建实例并释放锁后
//其他竞争到锁的线程被内层if挡住，不会创建多个实例
if (instance == null){
instance = new LazySingleton();
}
}
}
return instance;
}通过两个if条件判断，降低了锁竞争的频率，既保证了线程安全，又提高了执行效率
此时线程安全了吗？
此时，指令重排序，也可能引起线程安全问题
指令重排序，是编译器优化的一种方式，通过调整原有代码的执行顺序，在保证逻辑不变的前提下，提高程序的效率
在创建实例时，可将其分为三个步骤
1. 申请一段内存空间
2. 在该内存空间上调用构造方法，创建出实例
3. 将该内存地址赋值给instance引用变量
正常情况下，创建实例是按照1 2 3的顺序来执行的，而编译器也可能会将其优化为1 3 2的顺序来执行
而当按照1 3 2 的方式来创建实例时，就可能会出现问题
如何解决指令重排序带来的线程安全问题？
使用volatile
volatile能够禁止指令重排序，从而保证创建实例时，按照1 2 3的顺序来创建出实例，保证创建出初始化的实例
public class LazySingleton {
//在类中创建唯一实例,并将其置为null
//volatile:禁止指令重排序
private volatile static LazySingleton instance = null;
//构造方法私有化，保证类外部不能进行实例化
private LazySingleton() {
}
//对外提供获取该唯一实例的方法
public static LazySingleton getInstance() {
//判断是否已经创建实例，若已经创建实例，则不加锁，直接返回instance
if (instance == null) {
//若实例未创建，则向下执行来竞争锁
//竞争成功的锁，进行创建实例操作
synchronized (LazySingleton.class) {
//在竞争成功的锁创建实例并释放锁后
//其他竞争到锁的线程被内层if挡住，不会创建多个实例
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
}
懒汉模式在类加载时，并没有进行实例化，而是在第一次调用getInstance()方法的时候，才进行实例化。若一直没有调用getInstance()方法，则不创建该唯一实例，此时节省了实例化的开销