设计模式之单例模式

1. 什么是单例模式

单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。

其实，GoF对单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

应用场景：

在应用系统开发中，我们常常有以下需求：

在多个线程之间，比如servlet环境，共享同一个资源或者操作同一个对象
在整个程序空间使用全局变量，共享资源
大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。

因为Singleton模式可以保证为一个类只生成唯一的实例对象，所以这些情况，Singleton模式就派上用场了。

实现：

饿汉式。
懒汉式。
双重检查。

2. 具体实例

经典单例模式的类视图如下：

public class Singleton {
    private static Singleton uniqeInstance=null;

    private Singleton(){        //private类型的构造函数只能在类内部进行new，类外是不可获取的，就和private修饰的变量一样

    }

    public static Singleton getInstance(){
        if (uniqeInstance == null){
            uniqeInstance = new Singleton();
        }
        return uniqeInstance;
    }
}

通过上面的这种方式就实现了实例的new操作的控制，保证唯一性。只有uniqeInstance为null的时候才会new。这其实也就是懒汉式。

举一个应用的例子

public class ChocolateFactory {

    private boolean empty;
    private boolean boiled;
    public static ChocolateFactory uniqueInstance = null;

    private ChocolateFactory() {
        empty = true;
        boiled = false;
    }

    public static ChocolateFactory getInstance() {

        if (uniqueInstance == null) {
            uniqueInstance = new ChocolateFactory(); 
        }

        return uniqueInstance;

    }

    public void fill() {
        if (empty) {
            // 添加原料巧克力动作
            empty = false;
            boiled = false;
        }
    }

    public void drain() {
        if ((!empty) && boiled) {
            // 排出巧克力动作
            empty = true;
        }
    }

    public void boil() {
        if ((!empty) && (!boiled)) {
            // 煮沸
            boiled = true;
        }
    }

}

其实就是控制ChocolateFactory的实例对象只有一个。

上面的这种设计方式是存在问题的，当多线程同时访问的时候，会new出多个对象。这样的话其实就和单例模式的初衷相违背。怎么去解决呢？

使用synchronized同步锁，也就是在public synchronized static ChocolateFactory getInstance()加上锁，这样就保证每次只有一个线程访问该方法。

这种方式的缺点是消耗资源，也就是当你需要频繁的访问该方法的时候就会大量的使用同步锁，对于资源得消耗也很大。

“急切”创建实例（饿汉式），其实就是在类初始化的时候就把public static ChocolateFactory uniqueInstance = new ChocolateFactory ();

这样其实就是提前占用一定的空间呗。当你不需要的时候他也存在。

双重检查：首先使用volatilepublic volatile static ChocolateFactory uniqueInstance = null;，然后在构造方法出再加锁：

public synchronized static ChocolateFactory getInstance() {

    if (uniqueInstance == null) {
        synchronized (ChocolateFactory.class){
            if (uniqueInstance == null){
                uniqueInstance = new ChocolateFactory();
            }
        }

    }
    return uniqueInstance;
}

这样的话就保证了线程安全的。