我就是我，不一样的烟火——单例设计模式

“噫...这个人怎么好意思开一篇文章写单例...”
“虽然说设计模式我懂得不太多，但是单例还是能用脚写出来的。”
“我要是把你这篇文章看完，那说明我浪费生命的技能又升了一级。”
...
说的都没错，但！是！还有两个好玩的地方，说不定......吼吼

言归正传。

饿汉式

public class Singleton {
    
    private Singleton(){}   // 私有构造
    private static final Singleton singleton = new Singleton(); // 最直率的方式--先创建一个再说
    
    public static Singleton getInstance() {

        return singleton;   // 返回单例对象
        
    }
}

我猜北方程序员会喜欢。

懒汉式 v1.0

class Singleton {
    private Singleton(){}   // 私有构造
    private static Singleton singleton; // 创建一个引用,不着急实例化
    
    public static Singleton getInstance() {

        if (null == singleton) {    // 非空检查
            singleton = new Singleton();    // 创建实例
        }
        return singleton;   
    }
}

这个单例实现方式如何?在单线程环境下的却称得上简单优雅，只是在多线程环境下，一旦线程突破了非空检查但尚未执行new Singleton()语句时，CPU的执行权被其他线程获取。另一条线程执行if判断时， singleton还是为空，于是开始创建实例。当原来线程重新获得执行权后，虽然singleton对象已经不为空，但已经通过了非空检查，再次创建实例。线程安全问题开始进入视野。

懒汉式 v1.1

class Singleton {
    private Singleton(){}   // 私有构造
    private static Singleton singleton; // 创建一个引用,不着急实例化
    
    public static synchronized Singleton getInstance() {    // 方法上加同步锁

        if (null == singleton) {    // 非空检查
            singleton = new Singleton();    // 创建实例
        }
        return singleton;   
    }
}

方法上加了同步锁这下其他线程拿我有什么办法？！
线程安全是解决了，但是你效率也忒低了啊，本来两条腿跑步的，现在一条腿蹦？
哦...我改还不行吗...

懒汉式 v1.2

/**
 * DCL:double checked locking
 */
class Singleton {
    private Singleton(){}   
    private static Singleton singleton;
    
    public static Singleton getInstance() {
        if (null == singleton) {    // 第一次非空检查
            synchronized(Singleton.class) { // 加同步锁
                if (null == singleton) {    // 第二次非空检查
                    singleton = new Singleton();    
                }
            }
        }
        return singleton;
    }
}

锁代码块，检查两次，再有问题我吃饭自杀！
别说还真有点小问题，这个问题出在singleton = new Singleton();这行代码，它执行了如下两个操作：
①在堆内存（Heap）创建一个 Singleton 对象
②将对象地址值赋值给引用 singleton。
但是JIT（即时编译器）存在指令重排序的优化，也就是说以上操作可能是按照 1 > 2 的顺序，也可能是 2 > 1 的顺序。当先执行②时， singleton 对象就不为 null 了（也不是 Singleton 对象），返回后进行使用就会报错了。

懒汉式 v1.3

针对v1.2的解决方法就是在声明 Singleton 引用的字段加上volatile关键字。它有两个作用：1. 将当前线程在工作内存修改后的值即时更新（flush）到共享内存，使其他线程能发现值的修改，即保证线程之间的可见性。2.提供内存屏障，其中包括：当第二个操作是volatile写操作，则第一个操作不会被重排序。

/**
 * DCL:double checked locking
 */
class Singleton {
    private Singleton(){}   
    private volatile static Singleton singleton;  // 解决指令重排序
    //（====好不好玩【1】====）
    public static Singleton getInstance() {
        if (null == singleton) {    // 第一次非空检查
            synchronized(Singleton.class) { // 加同步锁
                if (null == singleton) {    // 第二次非空检查
                    singleton = new Singleton();    
                }
            }
        }
        return singleton;
    }
}

静态内部类

在单例类的成员位置创建一个静态内部类，用于获取外部类实例。此方法不同于饿汉式之处在于该方法不会直接加载单例对象，属于懒加载。

public class Singleton {  
    private static class SingletonHolder {  // 内部类
        private static final Singleton INSTANCE = new Singleton();  // 被final修饰，不可变
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE; // 在使用到内部类的属性时加载单例
    }  
}

枚举

public enum EnumSingleton{
    INSTANCE;
    // （====好不好玩【2】====）
}

呃...是不是一时间还没看出来？
接着请看：

public enum EnumSingleton {
    
    INSTANCE("老王",30);  // 需要的实例
    
    private String name;// 成员变量
    private int age;
    
    private EnumSingleton(){}// 空参构造
    private EnumSingleton(String name, int age) {// 带参构造
        this.name = name;
        this.age = age;
    }
    public String getName() {//getters & setters
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public static void main(String[] args) {// 测试
        System.out.println("姓名："+EnumSingleton.INSTANCE.name);// 在本类中可以直接访问私有成员变量
    }
    
}

Summary小洁

创建单例的方式有饿汉，懒汉（双检锁+volatile），静态内部类和枚举等方法。在没有特定要求情况下，使用饿汉式非常方便。若有懒加载需求，可以使用静态内部类和懒汉，在效率上，懒汉差一些（因为同步）。使用枚举创建的单例自动支持序列化机制，是一种很棒的实现方式，但是没有被广泛使用。

全文完。

参考

http://www.infoq.com/cn/articles/java-memory-model-4
http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/