面向对象设计模式--单例模式

在前几篇博客中，给大家介绍了下面向对象的六大原则，那么今天就介绍下大家经常用到的单例模式。

单例模式的定义

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式的使用场景

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源，这时就要考虑使用单例模式。
实现单例模式主要有如下几个关键点：

1. 构造函数不对外开放，一般为Private；
2. 通过一个静态方法或者枚举返回单例类对象；
3. 确保单例类的对象有且只有一个，尤其是在多线程环境下；
4. 确保单例类对象在反序列化时不会重新构建对象

---

通过将单例类的构造函数私有化，使得客户端代码不能通过new的形式手动构造单例类的对象。单例类会暴露一个公用静态方法，客户端需要调用这个静态方法获取到单例类的唯一对象，在获取这个单例对象的过程中需要确保线程安全，即在多线程环境下构造单例类的对象也是有且只有一个，这也是单例模式实现中比较困难的地方。

单例模式的简单示例

一个公司可以有几个VP、无数个员工，但是CEO只有一个

//普通员工public class Staff {    public void work(){        //做事    }}

//副总裁public class VP extends Staff{    @Override    public void work() {        //管理下面的经理    }}

//CEO，饿汉单例模式public class CEO extends Staff {    private static final CEO mCEO = new CEO();    //构造函数私有    private CEO() {    }    //公用的静态函数，对外暴露获取单例对象的接口    public static CEO getCeo(){        return mCEO;    }    @Override    public void work() {        //管理VP    }}

//公司类public class Company {    private List<Staff> allStaffs = new ArrayList<Staff>();    public void addStaff(Staff per){        allStaffs.add(per);    }    public void showAllStaffs(){        for (Staff per:             allStaffs) {            System.out.println("Obj :" + per.toString());        }    }}

public class MyClass {    public static void main(String[] args){        Company cp = new Company();        //CEO对象只能通过getCeo函数获取        Staff ceo1 = CEO.getCeo();        Staff ceo2 = CEO.getCeo();        cp.addStaff(ceo1);        cp.addStaff(ceo2);        //通过new创建VP对象        Staff vp1 = new VP();        Staff vp2 = new VP();        //通过new创建Staff对象        Staff staff1 = new Staff();        Staff staff2 = new Staff();        Staff staff3 = new Staff();        cp.addStaff(vp1);        cp.addStaff(vp2);        cp.addStaff(staff1);        cp.addStaff(staff2);        cp.addStaff(staff3);        cp.showAllStaffs();    }}

测试输出结果：
Obj :com.example.CEO@1540e19d
Obj :com.example.CEO@1540e19d
Obj :com.example.VP@677327b6
Obj :com.example.VP@14ae5a5
Obj :com.example.Staff@7f31245a
Obj :com.example.Staff@6d6f6e28
Obj :com.example.Staff@135fbaa4

从上面可以看到，CEO类不能通过new的形式构造对象，只能通过CEO.getCeo()函数来获取，而这个CEO对象是静态对象，并且在声明的时候已经初始化，这就保证了CEO对象的唯一性。从输出结果可以发现，CEO两次输出的CEO对象都是一样的，而VP、Staff等类型的对象都是不同的。这个实现的核心在于将CEO类的构造方法私有化，使得外部程序不能通过构造函数来构造CEO对象，而CEO类通过一个静态方法返回一个静态对象。

单例模式的其他实现方式

1.懒汉模式
懒汉模式是声明一个静态对象，并且在用户第一次调用getInstance时进行初始化，而上述的饿汉模式是在声明静态对象时就已经初始化。
懒汉单例模式实现如下:

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

大家可以发现getInstance（）方法中添加了synchronized 关键字，也就是getInstance是一个同步方法，这就是上面所说的在多线程情况下保证单例对象唯一性的手段。其实这种这有一个问题，即使instance已经被初始化（第一次调用时就会被初始化instance），每次调用getInstance方法都会进行同步，这样会消耗不必要的资源，这也是懒汉单例模式存在的最大问题。
最后总结一下，懒汉单例模式的优点是单例只有在使用时才会被实例化，在一定程度上节约了资源；缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getInstance都进行同步，造成不必要的同步开销。这种模式一般不建议使用。
2、Double Check Lock（DCL）实现单例
DCL方式实现单例模式的优点是既能够在需要时才初始化单例，又能够保证线程安全，且单例对象初始化后调用getInstance不进行同步锁。
代码如下：

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

大家可以看到getInstance方法中对instance进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。
DCL的优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。
缺点：第一次加载时反应稍慢，也由于java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。DCL模式是使用最多的单例实现方式，它能够在需要时才实例化单例对象，并且能够在绝大多数场景下保证单例对象的唯一性，除非你的代码在并发场景比较复杂或者低于JDK6版本下使用，否则，这种方式一般能够满足需求。
3、静态内部类单例模式
DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题，但是，它还是在某些情况下出现失效的问题。这个问题被称为双重检查锁定（DCL）失效，所以建议使用如下代码替换：

public class Singleton {    private Singleton (){    }    public static Singleton getInstance(){        return SingletonHolder.sInstance;    }    /**     * 静态内部类     */    private static class SingletonHolder {        private static final Singleton sInstance = new Singleton();    }}

当第一次加载Singleton类时并不会初始化sInstance，只有在第一次调用Singleton的getInstance方法时才会导致sIntance被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式。
4、枚举单例

public enum SingletonEnum {    INSTANCE;    public void doSomething(){        System.out.println("do sth.");    }}

枚举单例最大的特点就是写法简单，枚举在java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法。最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。
在上述的几种单例模式实现中，在一个情况下它们会出现重新创建对象的情况，那就是反序列化。
通过反序列化可以将一个单例的实例对象写到磁盘，然后再读取回来，从而有效地获得一个实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新的实例，相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数，类中具有一个私有的、被实例化的方法readResolve()，这个方法可以让开发人员控制对象的反序列化。例如，上述几个示例中如果要杜绝单例对象在被反序列化时重新生成对象，那么必须加入如下方法：

private Object readResolve() throws ObjectStreamException{        return sInstance;    }

也就是在readResolve方法中将sInstance对象返回，而不是默认的重新生成一个新的对象。而对于枚举，并不存在这个问题，因为即使反序列化它也不会重新生成新的实例。
5、使用容器实现单例模式

public class SingletonManager {    private static Map<String,Object> objectMap = new HashMap<String, Object>();    private SingletonManager(){    }    public static void registerService(String key, Object instance){        if(!objectMap.containsKey(key)){            objectMap.put(key,instance);        }    }    public static Object getService(String key){        return objectMap.get(key);    }}

在程序的初始，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
上面所有的方式，核心原来都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。
大家有想了解更深的话，可以去看下LayoutInflater源码。

总结：
单例模式是运用频率很高的模式。但是，由于在客户端通常没有高并发的情况，因此，选择哪种实现方式并不会有太大影响。即便如此，出于效率考虑，推荐大家使用DCL单例实现方式。
单例模式的优缺点：
优点：

1. 由于单例模式在内存中只有一个实例，减少了内存的开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
2. 由于单例模式只生成一个实例，所以，减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来
3. 单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
4. 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有数据表的映射处理。

---

缺点：

1. 单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。
2. 单例对象如果持有Context，那么很容易引发内存泄漏，此时需要注意传递给单例对象的Context最好是Application Context。

---

今天单例模式就介绍到这里，有什么不足的希望大家多提意见。