多线程并发下的单例模式

定义：

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。

下面通过代码分析下java中，各种单例模式写法的优缺点。

1、饿汉模式

示例1.1

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

在类生命周期的【初始化】阶段进行生成单例对象（类的初始化阶段会对静态变量赋值），当执行类初始化的阶段是需要先获得锁才能进行初始化操作，而且一个class类只进行初始化一次。类初始化阶段是线程安全的，JVM保证类初始化只执行一次。这样可以确保只生成一个对象。

类声明周期分为：加载(Loading)、验证(Verification)、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)、卸御(Unloading)。
类的生命周期不明白的请查看：JVM 类加载机制深入浅出

类加载后不一定马上执行初始化阶段。当遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。

1. new 创建对象操作
2. getstatic 访问类的静态变量操作
3. putstatic 给类的静态变量赋值操作
4. invokestatic 调用静态方法操作

这个饿汉模式中，不会出现new、invokestatic和putstatic指令，外面的类只能调用 getInstance()静态方法，由此推断，此单例模式也是延迟加载对象的，只有第一次调用getInstance()静态方法，才会触发他的初始化阶段，才会创建单例对象。

其实这个例子应该是懒汉模式，只有在第一次使用的时候才加载

下面这个【示例1.2】不是延迟加载单例对象

示例1.2

public class Singleton {
    private Singleton() {}
    private static  int count=0;
    private static Object INSTANCE = new Object();
    public static Object getInstance() {
        return INSTANCE;
    }
}

当程序先调用Singleton1中的count属性时（getstatic 或putstatic 指令），就会执行类的【初始化】阶段，会生成单例对象，而不是调用getInstance()静态方法才生成单例对象。

示例1.3 （静态内部类实现方式）

public class Singleton {
    private Singleton() {}
    private static  int count=0;
    private static class SingletonHolder{
        private static final Object INSTANCE = new Object();
    }
    public static Object getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

使用内部类SingletonHolder来防止【示例1.2】出现的问题，防止其它的变量的干扰，导致提前触发类声明周期中的【初始化】阶段来创建INSTANCE 实例。
Effective Java中推荐的单例写法

2、懒汉模式

示例2.1

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

每次创建INSTANCE 的时候先判断是否null，如果为null则new一个，否则就直接返回INSTANCE 。当多线程工作的时候，如果有多个线程同时运行到if (INSTANCE == null)，都判断为null，那么两个线程就各自会创建一个实例。这样就会创建多一个实例，这样就不是单例了。

下面的【示例2.2】加上synchronized 改进多线程并发引起的问题

示例2.2 （synchronized 实现方式）

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

虽然synchronized 能解决多线程同时并发引起的问题，但是每次访问该方法都需要获得锁，性能大大降低。其实只要创建INSTANCE 实例后就不需要加锁的，直接获取该对象就ok。

示例2.3 （双重检查实现方式）

public class Singleton {
    private Singleton() {   }
    private static Object INSTANCE = null;
    public static Object getInstance() {
        if(INSTANCE == null){
            synchronized(Singleton3.class){
                if(INSTANCE == null){
                    INSTANCE = new Object();
                }
            }
        }
        return INSTANCE;
    }
}

这个版本的代码看起来有点复杂，注意其中有两次if (instance == null)的判断，这个叫做『双重检查 Double-Check』。

第一个if (instance == null)，其实是为了解决【示例2.2】中的效率问题，只有instance为null的时候，才进入synchronized的代码段——这样在对象创建后就不会在进入同步代码块了。
第二个if (instance == null)，则是跟【示例2.2】一样，是为了防止可能出现多个实例的情况。

从代码层面看似完美，效率问题也解决了。但实际还是有问题，在并发环境下可能会出现instance为null的情况。下面我们来分析下为什么会出现此问题。

原子操作

INSTANCE = new Object();不是原子操作。
在JVM中会拆分成3个步骤
1、分配对象的内存空间
2、初始化对象
3、设置INSTANCE 指向刚分配的内存地址

指令重排

指令重排序是JVM为了优化指令，提高程序运行效率，在不影响单线程程序执行结果的前提下，尽可能地提高并行度。
可以参考：java内存模型

【2、初始化对象和 3、设置INSTANCE 指向刚分配的内存地址】这两个操作可能发生重排序。
如下图：

指令重排序

从图中可以看出A2和A3的重排序，将导致线程
B在B1处判断出instance不为空，线程B接下来将访问instance引用的对象。此时，线程B将会访
问到一个还未初始化的对象。

示例2.4 （基于volatile的解决方案）

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

声明对象的引用为volatile后，【2、初始化对象和 3、设置INSTANCE 指向刚分配的内存地址】之间的重排序，在多线程环境中将会被禁止。

volatile的重排序规则

从图表中可以看出volatile可以确保，volatile变量读写顺序，可以保证一个线程写volatile变量完成后（创建完对象后），其它线程才能读取该volatile变量，相当于给这个创建实例的构造上了一把锁。这样，在它的赋值完成之前，就不用会调用读操作。

示例2.5 （枚举实现方式）

public enum Singleton6 {
    INSTANCE;
    public String getInfo(String s){
        s = "hello " + s;
        System.out.println(s);
        return s;
    }
    public static void main(String[] args) {
        String s = INSTANCE.getInfo("aa");
        System.out.println(s);
    }
}

这种写法在功能上与共有域方法相近，但是它更简洁，无偿地提供了序列化机制，绝对防止对此实例化，即使是在面对复杂的序列化或者反射攻击的时候。虽然这中方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。

---

想了解更多精彩内容请关注我的公众号