兄弟，你的单例模式可能不是单例！！！

2020-04-29 16:08:29来源：博客园阅读 ()

兄弟，你的单例模式可能不是单例！！！

面试官：请你写个单例模式。你：(太简单了吧，我给他来个“饿汉式”，再来个“懒汉式”)，然后。。。。。。

面试官：请你写个单例模式

你：(太简单了吧，我给他来个“饿汉式”，再来个“懒汉式”)

（2分钟后，你的代码新鲜出炉了）

饿汉式单例模式代码

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

懒汉式单例模式代码

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        if (instance == null) { // 1
            instance = new LazySingleton(); // 2
        }
        return instance;
    }
}

(很棒~但是他们真的时单例吗)

代码分析

第一段代码

instance 是一个类变量，类变量再类初始化时创建，类初始化时相当于会加个锁，保证原子性。因此他确实能保证单例，除非时多次加载这个类。

第二段代码

单线程环境下没有问题，确实是单例。

多线程下则需要考虑下了.

假设线程A走到了2，同时线程B走到了1. 线程A走完了，实例化了LazySingleton，由于B在A还没有给instance赋值时走到了1，所以判断为instance==null, 所以他也会创建一个LazySingleton实例。

因此此段代码存在线程安全问题，也就是不能保证LazySingleton是单例的。

解决方案

方案一：直接给获取实例的方法加锁

我们可以通过将getInstance变为同步方法来保证同一时刻只能有一个线程进入到方法。

如下：

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

这种方式简单粗暴，但是当高并发去获取单例时，只有一个线程能竞争到锁，其他的线程都将阻塞，效率低下。

方案二：双重锁定

public class DoubleCheckLocking {
    private static DoubleCheckLocking instance;

    public DoubleCheckLocking() {
    }

    public DoubleCheckLocking getInstance() {
        if (instance == null) {  // 1
            synchronized (DoubleCheckLocking.class) {
                if (instance == null) {
                    instance = new DoubleCheckLocking(); // 问题根源
                }
            }
        }
        return instance;
    }
}

这段代码很巧妙，前一种方法直接将getInstance方法变为同步方法会带来效率低下问题，那么我们就只在创建对象的时候加锁，这样既能保证效率，也能保证单例。

然而，这种方式也有问题，方腾飞老师在《Java并发编程艺术》中无情地嘲讽了这种做法，原文如下：

因此，人们想出了一个“聪明”的技巧：双重检查锁定（Double-Checked Locking）

问题的根源就在于new DoubleCheckLocking()这句话，创建一个对象大体分为三步, 伪码表示如下：

memory=allocate()    1分配对象内存
ctorInstance(memory) 2初始化对象
instance=memory      3引用指向创建的对象

其中2和3是可能重排序的，因为他们不存在数据依赖性。也就是3可能在2之前执行。

假设A线程获取单例按1、3、2走到了3，那么此时instance不为null, 此时B线程走到1处，直接将instance返回了，所以调用方拿到了一个未被初始化的对象。

所以，这个方法严格来讲是不可取的。

方案二：改良双重锁定

方案很简单，直接在instance变量前加volatile关键字，如下

private static volatile DoubleCheckLocking instance;

加上volatile可以阻止上述2、3两条指令的重排序。

方案三：基于类初始化

public class MySingleInstance {
    private MySingleInstance() {
    }

    private static class InstanceHolder {
        public static MySingleInstance instance = new MySingleInstance();
    }

    public static MySingleInstance getInstance() {
        return InstanceHolder.instance;
    }
}

JVM在执行类的初始化期间会去获取一个锁, 这个锁可以同步多个线程对同一个类的初始化。