设计模式系列-单例模式

一般Java实现单例模式有不少种方式，大体可分为懒汉模式和饿汉模式，其主要区别是实例延迟加载的问题，固然单例模式每每也关注其余问题，如：线程安全等。下面试图来总结单例模式的这些注意点。

代码地址：GitHub
本文首发于：lishuo.me

饿汉模式

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

    public static Singleton getInstance() {
        return instance;
    }
}复制代码

饿汉模式在类加载时候就实例化对象，使用时直接调用getInstance()方法。这个模式下，是线程安全的，在多线程并发模式下不会重复实例化对象。
缺点：对象过早的实例化，浪费系统资源。

懒汉模式

public class Singleton {
    private Singleton(){}
    private static Singleton instance = null;

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}复制代码

这种模式下在类加载时候并无实例化对象，而是在调用getInstance()方法。之因此使用懒汉模式，是为了不多早的实例化对象，从而浪费系统资源。
缺点：仅适用于单线程，线程不安全。

改进1 - 引入synchronized

public class Singleton {
    private Singleton(){}
    private static Singleton instance = null;

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}复制代码

之因此引入synchronized修饰getInstance()方法，是为了解决线程不安全的问题。利用多线程同步机制，让原先的线程不安全回归到线程安全。但引入synchronized会由于线程阻塞、切换会带一些没必要要的开销，从而下降系统性能。

改进2 - 双重检查锁定

public class Singleton {
    private Singleton(){}
    private static volatile Singleton instance = null;

    public static Singleton getInstance() {
        if (instance == null) {              // A
            synchronized (Singleton.class) {
                if (instance == null) {      // B
                    instance = new Singleton(); // C
                }
            }
        }
        return instance;
    }
}复制代码

对比改进1中，能够看到synchronized再也不修饰一个方法，而是缩减到修改代码块，由于加锁同步的话，范围越小，性能影响最小。

这里能够注意到修饰变量instance的关键字增长了volatile。这里volatile主要做用是提供内存屏障，禁止指令重排序。

现有t一、t2两个线程同时访问getInstance(),假设t一、t2都执行到A处。因为有同步锁，只能有个1个线程得到锁，假如t1拥有该同步锁，t1执行到C处instace = new Singleton()。将会作以下3步骤：
1.分配内存空间
2.初始化
3.将instance指向分配内存空间
正常的执行顺序应为：1->2->3。执行第3步时，这时候的instance就再也不是null了。但因为指令重排序的存在，执行顺序有可能变化为：1->3->2。当执行3的时候，instance就再也不是null，但初始化工做有可能尚未作完。这时候若是t2获取锁执行的话，就会直接获取有可能尚未初始化完成的instance。这样使用instance会引发程序报错。固然这也是极端状况下，我尝试几回没法捕捉重现，但并不意味着问题不存在。volatile固然仍是要加的。

A处if判断做用主要是防止过可能是线程执行同步代码块；若是是单例模式的话，这里同步代码块只会被执行一次。B处if判断做用主要是防止多线程做用下重复实例化，保证线程安全。这也被称为：双重检查锁定。

双重检查锁定属于一种兼顾线程安全和性能的实现。

改进3 - 静态内部类

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

    public static Singleton getInstance() {
        return Holder.instance; // 执行Holder的初始化工做
    }
}复制代码

使用静态内部类也是懒汉模式的一种实现，当调用ggetInstance()才会触发加载静态内部类，从而初始化获取instance实例。利用静态内部类的加载机制来保证线程安全。

枚举方式

public enum Singleton {
    INSTANCE;
    Singleton(){}

    public Singleton getInstance() {
        return INSTANCE;
    }

}复制代码

用枚举方式实现单例模式，是目前比较推荐的。枚举方式的好处是：一、线程安全；二、防止反射出现多个实例；三、防止反序列化出现多个实例。

以上是关于java单例模式的一些总结，若有纰漏，还请指出。

代码地址：GitHub
本文首发于：lishuo.me