设计模式 - 单例模式

一、定义

保证一个类有且只有一个实例对象，并提供一个访问它的全局访问点

二、什么时候使用

当你项目中，需要该类只能有一个实例时

三、简单使用

/**
 *  单例模式
 */
public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

    public static Singleton getSingleton() {
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

使用测试：

public static void main(String[] args) {
    Singleton singleton = Singleton.getSingleton();
    Singleton singleton2 = Singleton.getSingleton();
    if (singleton == singleton2){
        System.out.println("两对象是相同的实例");
    }
}

上述单例的创建方式，有一个隐患，就是是多线程下，实例可能会创建多个，这样就没法确实唯一性了。这时，我们可以进行优化，加入同步锁

/**
 *  单例模式  加个同步锁的方式
 *  双层判断
 *  一个判断是否为null，是为了创建后就不用再使用同步锁了
 *  第二个判断为null是同步锁等待中，如果创建成功了，就不要创建了
 *
 */
public class SingletonSynchronized {

    private volatile static SingletonSynchronized singleton;

    private SingletonSynchronized(){}

    public static SingletonSynchronized getSingleton() {
        if(singleton == null){
            synchronized (SingletonSynchronized.class){
                if (singleton == null){
                    singleton = new SingletonSynchronized();
                }
            }
        }
        return singleton;
    }
}

使用synchronized字段，加入同步锁，保证在多线程中能够顺序执行创建实例。

为什么要加上volatile字段？

一般情况下，初始化对象的步骤为 1. 分配内存控件 2. 初始化对象 3. 将对象指向刚分配的内存控件（这时判断对象就不为null了）

而有些编译器为了性能原因，在初始化对象时，步骤为 1. 分配内存控件 2. 讲对象指向刚分配的内存空间 3. 初始化对象

所以可能会出现对象还未初始化成功，就直接返回访问了。

具体步骤：

线程A中，1. 检测到singleton为null, 2.获取锁，3.再次检测singleton为null，4.为singleton分配内存空间，5.将singleton指向内存空间。

这时线程B中，6. 检测到singleton不为null，7.直接返回singleton，进行访问（但此时singleton对象还未完成初始化）

而之后线程A中，8. 初始化singleton

使用volatile关键词后，这种重排序被禁止，只能用一般情况下初始化对象，所有的写（write）操作都将发生在读（read）操作之前这时，就不会发生这种事了

参考：

https://www.cnblogs.com/xz816111/p/8470048.html