单例模式：最熟悉的陌生人

“你熟悉设计模式吗？”

“我最熟悉单例模式。”

你张开嘴巴，自信一吼，散发光彩🌈

知面不知心

即使没吃过猪肉，但也见过猪跑。问起设计模式，必不可缺少的就是单例模式。

单例模式：保证一个类只有一个实例， 并提供一个访问该实例的全局节点

翻译：创建一个唯一类对象，保证外部每次使用都是这个唯一对象。

随后你又写下实现代码，来证明自己 “很懂” 单例，毕竟它是如此简单！

• 创建单例类

public class SingleObject {
    private static SingleObject instance = new SingleObject();
    private SingleObject() {}
    public static SingleObject getInstance() {
        return instance;
    }
    public void showMessage() {
        System.out.println("Hello World!");
    }
}

1. static 修饰的变量会在类加载时进行创建（记着这一点，下文会提到），并在内存中只有一份副本，使用时所有该类的实例共享同一个 static 变量。即使我们通过 对象.静态变量名 进行访问，虽对象内存不同，但访问的静态变量都是同一份，所以推荐 类名.静态变量名 进行访问更方便。
2. 将 instance 设为 private 目的是保证外部无法直接使用，需要 Get 方法访问。

• 获取唯一对象并使用。

public class SingletonDemo {
    public static void main(String[] args) {
        SingleObject object = new SingleObject();//错误！ 因为构造私有，所以编译报错
        SingleObject object = SingleObject.getInstance();//正确
        object.showMessage();
    }
}

上述代码是我们传统实现，也是我们最为熟悉的部分，这种实现被称之为 “饿汉式🍔”，之所以叫饿汉式是因为SingleObject instance = new SingleObject(); 无论我们是否使用 instance 对象，每当 SingleObject 类加载时就会通过 new 关键字创建对象进行内存的开辟，就犹如饿怕了的人，即使吃饱了，也要把干粮屯好，防止再受饿。

看到这里是不是觉得十分新奇，最熟悉的单例竟然开始变得陌生了！毕竟熟悉一个人从内心开始，而熟悉设计模式，也要从它的 "内心"出发。

重拾温柔的 “她”

与饿汉式相比，在类加载时不进行内存开辟，只有使用时才实例创建对象，被称之为 “懒汉式”，犹如一个人懒的觉得饿了才去吃东西。

懒汉式💤

• 线程不安全

public class Singleton {
    private static Singleton instance;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (instance == null) {
            //线程问题
            instance = new Singleton();
        }
        return instance;
    }
}

传统懒汉式存在线程问题，假设有两个线程 T1 和 T2，同时执行上述代码，当 T1 走完 if (instance == null) 但没走到instance = new Singleton();，这个时候 T2 线程比它领先一步，执行了instance = new Singleton();将 instance 初始化。此时 T1 线程继续执行，将 instance 又重新初始化。因此会将 instance 初始化两次，从而违背了单例模式的意义。

• 线程安全

public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

通过 synchronized 保证了线程安全，但是由于每个线程执行到 getInstance 方法时都得等待锁的释放，因此会影响性能，所以就有了双重校验锁模式。

双重校验锁🔒

• 错误双重校验锁

public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    public static Singleton getInstance() {
        if (instance == null) {
        // Time1
            synchronized (Singleton.class) {
            //Time2
                if (instance == null) {
                    instance = new Singleton(); //指令重排
                }
            }
        }
        return singleton;
    }
}

第一个 if 对 instance 进行判断，如果初始化完成即 !=null 则直接返回。如果 ==null 继续执行，当多个线程执行到 Time1 时会等待锁的释放，当持有锁的线程释放后，其他线程会抢锁，然后某个线程重新拿到锁继续执行，并在 Time2 处重新判断 instance 是否为空，由于之前线程已经把 instance 初始化，所以直接返回，避免重复赋值。

但是这是理想状态，在系统中instance = new Singleton();被分为三步执行：

1. 分配内存空间
2. 初始化对象
3. 将对象指向刚分配的内存空间

但是系统为了将性能最大化，在不影响结果的情况下，会对上述步骤重新排序，有可能是这样：

1. 分配内存空间
2. 将对象指向刚分配的内存空间
3. 初始化对象

当 T2 线程执行到 Time2 时，此时 T1 线程执行了 “将对象指向刚分配的内存空间”，还并没有初始化对象，而未被初始化的内存空间有可能是被使用过的，是有值的（具体什么值不清楚），此时 T2 继续执行，访问到初始化未完成的 instance 对象并判断 instance 不为空，之后会将未初始化对象返回，这是错误的。❌

• 正确双重校验锁

public class Singleton {
    private volatile static Singleton instance;
    private Singleton (){}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

给予变量 volatile 关键字，而 volatile 作用就是禁止指令重排，因此很好的避免了上述情况。

上面太复杂？ 别急，接下来介绍用更简单的方法实现双重校验锁的功能👇。

静态内部类🌳

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton instacne = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
        return SingletonHolder.instacne;
    }
}

你是否还记得我上面让你记住的一句话：“static 修饰的变量会在类加载时进行创建”，而通过静态内部类，即使外面一层 Singleton 类被加载，但只要我们内部 SingletonHolder 类没有主动使用，那么 instance 就不被初始化。当调用 getInstance 方法如StaticSingleton staticSingleton = StaticSingleton.getInstance();才会加载 SingletonHolder 类，实例化 instance，避免内存浪费。

文中代码来自菜鸟教程，作者略作改动！

我是 Haoo，一个乐观的码农，撰写有趣的文章。
如果这篇文章帮助到你，请收藏⭐点赞👍加关注👀，跟踪不迷路(🌻◡‿◡)