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