设计模式之单例模式

　　单例模式是一个很简单的模式，应用场景不是很多，一般在帮助类需要构建单个实例，连接数据库或者打开一些IO通道等的情况会用到，但是写这个单例模式却可以考察很多同学对于代码的理解，因此面试的时候面试官很喜欢问几个单例的问题。这篇文章写了一些我对于单例的理解和看法。

　　在看到单例模式几个字的时候，脑子里直接就冒出这么一段代码：

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

　　有些书把这种模式的单例叫做饿汉模式，这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，会有那么一丢丢影响加载的速度。与之对应的是懒汉模式，予取予求，最简单的写法这样：

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

这么写有个明显的问题就是多线程的时候有可能创造出多个实例，于是改成同步获取：

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

这样写的话，就能线程安全了，但是大多数时候，我们都并不需要这个同步，所以，难怪我一下想到的就是饿汉模式。。。为了解决饿汉模式加载类的时候就要实例化instance的问题，就有了静态内部类的写法：

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

对于懒汉式也有强化版，双重校验锁版：

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}  

这种写法还是有点门道的，volatile关键字保证了可见性，禁止了指令的重排序，从而保证多线程的时候如果有instance就一定能被取到，双重check外面那层保证如果在有一个实例的情况下，代码不被同步代码块卡住，内层的就不用说了。

感觉各种写法的单例就像茴香豆的四种写法，虽然都有不同，但是并没有高下之分，在各自适合的场景下各有各的优点。后来还看见有这种写法：

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}  

哇，这种我倒是没见过，不过枚举的这种形式不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，是《effective java》作者推荐的写法。哈哈哈，奇妙奇妙，我还是太菜了。