23种设计模式之《单例模式》

2018-04-19 本文已影响0人长孙雨聪七星上将

什么是单例模式

单例模式是23种设计模式中最简单和易用的模式。在某些情境下，如在一个上市公司中，有很多不同级别的员工，但是公司的CEO或者CTO都是只有一个的，CEO或者CTO在公司里就要求是一个单例。单例模式，就是某个类因实际情况的需要，要求在全局的范围内只能有唯一的实例对象，这个对象是常驻内存的，可以重复使用，降低重复创建对象的开销。

单例模式的特点

类的构造函数是私有的
在类内部实例化对象，并通过静态方法向外提供实例化的对象

下面主要讲解实现单例模式的方法以及它们的优缺点

单例模式的实现

单例模式的目的，就是要确保在全局范围内某个类的对象是唯一的。所以实现单例模式时，我们至少要考虑两个影响对象创建的因素。

在并发的环境下的线程安全
反序列化

饿汉实现

在类第一次加载时，就进行对象的实例化。

public class SingletonDemo {

    private final static SingletonDemo mSingletonDemo = new SingletonDemo();

    private SingletonDemo() {}

    public static SingletonDemo getInstance() {
        return mSingletonDemo;
    }

}

懒汉实现

在类加载时不进行对象的实例化，只在对象被第一次访问时，才进行对象的实例化。

public class SingletonDemo {

    private static SingletonDemo mSingletonDemo;

    private SingletonDemo() {}

    public static SingletonDemo getInstance() {
        if(mSingletonDemo == null) {
            mSingletonDemo = new SingletonDemo();
        }
        return mSingletonDemo;
    }

}

明显，在多线程的环境下，上面两种实现方式都不是线程安全的。为了实现线程安全，我们首先可以想到使用synchronized关键字。

线程安全的懒汉模式

public class SingletonDemo {

    private static SingletonDemo mSingletonDemo;

    private SingletonDemo() {}

    public static synchronized SingletonDemo getInstance() {

        if(mSingletonDemo == null) {
            mSingletonDemo = new SingletonDemo();
        }
        return mSingletonDemo;
    }

}

关于synchronized关键字说明一下，synchronized声明的静态方法，同时只能被一个执行线程访问，但是其他线程可以访问这个对象的非静态方法。即：两个线程可以同时访问一个对象的两个不同的synchronized方法，其中一个是静态方法，一个是非静态方法。

所以，当有多个线程同时访问getInstance静态方法时，多个其他的线程只能等待，这时只有一个线程能够访问getInstance方法，等这个线程释放后其他线程才能访问。这样就会影响速度和效率。

为了提高懒汉模式的速度和效率，可以减小锁的粒度和次数。

双重校验锁法

public class SingletonDemo {

    private static SingletonDemo mSingletonDemo;

    private SingletonDemo() {}

    public static synchronized SingletonDemo getInstance() {
        if(mSingletonDemo == null) {
            synchronized (SingletonDemo.class) {
                if(mSingletonDemo == null) {
                    mSingletonDemo = new SingletonDemo();
                }
            }
        }
        return mSingletonDemo;
    }

}

从上面可以看到，只有在第一次访问时才会锁定和创建类的对象，之后的访问都是直接使用已经创建好的对象，这样减少锁定的次数和范围，以达到提高单例模式的效率。

但是，对象的实例化，并不是一个原子性操作。即第11行代码处，它可以分成下面三个步骤：
1、new SingletonDemo()，为SingletonDemo实例分配内存
2、调用SingletonDemo的构造器，完成初始化工作
3、将mSingletonDemo指向分配的内存空间

由于java处理器可以乱序执行，即无法保证2和3的执行顺序。这对双重校验锁法实现的单例模式有什么影响呢？
当第一个线程访问getInstance方法时，会锁定临界区（第9行到第13行代码），它实例化对象的顺序是1=>3=>2，而在这时如果有第二个线程来访问getInstance方法，由于第一个线程在处理器中执行完了3未执行2，第二个线程会马上得到实例对象，因为第一个线程的3已经执行完即mSingletonDemo已经不为空。当第二个线程使用没有初始化的对象时就会出现问题。

所以，双重校验锁法也不是完美的，在并发环境下依然可能出现问题。

静态内部类实现

public class SingletonDemo {

    private static SingletonDemo mSingletonDemo;

    private SingletonDemo() {}

    private static class SingletonHolder {
        private static final SingletonDemo INSTANCE = new SingletonDemo();
    }

    public static SingletonDemo getInstance() {
        return SingletonHolder.INSTANCE;
    }

}

第一次加载SingletonDemo类时并不会实例化INSTANCE，只有在第一次调用getInstance方法时，才会加载SingletonHolder内部类，创建SingletonDemo实例。这种方式不仅确保了线程安全，也保证单例对象的唯一性，同时也实现了单例对象的懒加载。

枚举实现

上面几种实现方式，可能会因为反序列化而创建新的实例，所以必须重写readResolve方法，在readResolve方法中返回已经创建的单例。

使用枚举可以很简单的实现单例模式，这也是Effective Java中提倡的方式。因为枚举本身就是类型安全的，并且枚举实例在任何情况下都是单例。

public enum SingletonEnumDemo {
    INSTANCE;
    public void justDoYourThing() {
        
    }
}

枚举单例使用

SingletonEnumDemo.INSTANCE.justDoYourThing();

容器实现

public class SingletonDemo {

    private static Map<String, Object> singletonMap = new HashMap<String, Object>();

    private SingletonDemo() {}

    public static void registerService(String key, Object instance)     {
        if (!singletonMap.containsKey(key)) {
            singletonMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return singletonMap.get(key);
    }

}