面向对象设计模式--单例模式
2016-07-24 19:43
330 查看
在前几篇博客中,给大家介绍了下面向对象的六大原则,那么今天就介绍下大家经常用到的单例模式。
实现单例模式主要有如下几个关键点:
构造函数不对外开放,一般为Private;
通过一个静态方法或者枚举返回单例类对象;
确保单例类的对象有且只有一个,尤其是在多线程环境下;
确保单例类对象在反序列化时不会重新构建对象
通过将单例类的构造函数私有化,使得客户端代码不能通过new的形式手动构造单例类的对象。单例类会暴露一个公用静态方法,客户端需要调用这个静态方法获取到单例类的唯一对象,在获取这个单例对象的过程中需要确保线程安全,即在多线程环境下构造单例类的对象也是有且只有一个,这也是单例模式实现中比较困难的地方。
测试输出结果:
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类通过一个静态方法返回一个静态对象。
懒汉模式是声明一个静态对象,并且在用户第一次调用getInstance时进行初始化,而上述的饿汉模式是在声明静态对象时就已经初始化。
懒汉单例模式实现如下:
大家可以发现getInstance()方法中添加了synchronized 关键字,也就是getInstance是一个同步方法,这就是上面所说的在多线程情况下保证单例对象唯一性的手段。其实这种这有一个问题,即使instance已经被初始化(第一次调用时就会被初始化instance),每次调用getInstance方法都会进行同步,这样会消耗不必要的资源,这也是懒汉单例模式存在的最大问题。
最后总结一下,懒汉单例模式的优点是单例只有在使用时才会被实例化,在一定程度上节约了资源;缺点是第一次加载时需要及时进行实例化,反应稍慢,最大的问题是每次调用getInstance都进行同步,造成不必要的同步开销。这种模式一般不建议使用。
2、Double Check Lock(DCL)实现单例
DCL方式实现单例模式的优点是既能够在需要时才初始化单例,又能够保证线程安全,且单例对象初始化后调用getInstance不进行同步锁。
代码如下:
大家可以看到getInstance方法中对instance进行了两次判空:第一层判断主要是为了避免不必要的同步,第二层的判断则是为了在null的情况下创建实例。
DCL的优点:资源利用率高,第一次执行getInstance时单例对象才会被实例化,效率高。
缺点:第一次加载时反应稍慢,也由于java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷,虽然发生概率很小。DCL模式是使用最多的单例实现方式,它能够在需要时才实例化单例对象,并且能够在绝大多数场景下保证单例对象的唯一性,除非你的代码在并发场景比较复杂或者低于JDK6版本下使用,否则,这种方式一般能够满足需求。
3、静态内部类单例模式
DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题,但是,它还是在某些情况下出现失效的问题。这个问题被称为双重检查锁定(DCL)失效,所以建议使用如下代码替换:
当第一次加载Singleton类时并不会初始化sInstance,只有在第一次调用Singleton的getInstance方法时才会导致sIntance被初始化。因此,第一次调用getInstance方法会导致虚拟机加载SingletonHolder类,这种方式不仅能够确保线程安全,也能够保证单例对象的唯一性,同时也延迟了单例的实例化,所以这是推荐使用的单例模式实现方式。
4、枚举单例
枚举单例最大的特点就是写法简单,枚举在java中与普通的类是一样的,不仅能够有字段,还能够有自己的方法。最重要的是默认枚举实例的创建是线程安全的,并且在任何情况下它都是一个单例。
在上述的几种单例模式实现中,在一个情况下它们会出现重新创建对象的情况,那就是反序列化。
通过反序列化可以将一个单例的实例对象写到磁盘,然后再读取回来,从而有效地获得一个实例。即使构造函数是私有的,反序列化时依然可以通过特殊的途径去创建类的一个新的实例,相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数,类中具有一个私有的、被实例化的方法readResolve(),这个方法可以让开发人员控制对象的反序列化。例如,上述几个示例中如果要杜绝单例对象在被反序列化时重新生成对象,那么必须加入如下方法:
也就是在readResolve方法中将sInstance对象返回,而不是默认的重新生成一个新的对象。而对于枚举,并不存在这个问题,因为即使反序列化它也不会重新生成新的实例。
5、使用容器实现单例模式
在程序的初始,将多种单例类型注入到一个统一的管理类中,在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例,并且在使用时可以通过统一的接口进行获取操作,降低了用户的使用成本,也对用户隐藏了具体实现,降低了耦合度。
上面所有的方式,核心原来都是将构造函数私有化,并且通过静态方法获取一个唯一的实例,在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。
大家有想了解更深的话,可以去看下LayoutInflater源码。
总结:
单例模式是运用频率很高的模式。但是,由于在客户端通常没有高并发的情况,因此,选择哪种实现方式并不会有太大影响。即便如此,出于效率考虑,推荐大家使用DCL单例实现方式。
单例模式的优缺点:
优点:
由于单例模式在内存中只有一个实例,减少了内存的开支,特别是一个对象需要频繁地创建、销毁时,而且创建或销毁时性能又无法优化,单例模式的优势就非常明显。
由于单例模式只生成一个实例,所以,减少了系统的性能开销,当一个对象的产生需要比较多的资源时,如读取配置、产生其他依赖对象时,则可以通过在应用启动时直接产生一个单例对象,然后用永久驻留内存的方式来
单例模式可以避免对资源的多重占用,例如一个写文件操作,由于只有一个实例存在内存中,避免对同一个资源文件的同时写操作。
单例模式可以在系统设置全局的访问点,优化和共享资源访问,例如,可以设计一个单例类,负责所有数据表的映射处理。
缺点:
单例模式一般没有接口,扩展很困难,若要扩展,除了修改代码基本上没有第二种途径可以实现。
单例对象如果持有Context,那么很容易引发内存泄漏,此时需要注意传递给单例对象的Context最好是Application Context。
今天单例模式就介绍到这里,有什么不足的希望大家多提意见。
单例模式的定义
确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。单例模式的使用场景
确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源,或者某种类型的对象只应该有且只有一个。例如,创建一个对象需要消耗的资源过多,如要访问IO和数据库等资源,这时就要考虑使用单例模式。实现单例模式主要有如下几个关键点:
构造函数不对外开放,一般为Private;
通过一个静态方法或者枚举返回单例类对象;
确保单例类的对象有且只有一个,尤其是在多线程环境下;
确保单例类对象在反序列化时不会重新构建对象
通过将单例类的构造函数私有化,使得客户端代码不能通过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单例实现方式。
单例模式的优缺点:
优点:
由于单例模式在内存中只有一个实例,减少了内存的开支,特别是一个对象需要频繁地创建、销毁时,而且创建或销毁时性能又无法优化,单例模式的优势就非常明显。
由于单例模式只生成一个实例,所以,减少了系统的性能开销,当一个对象的产生需要比较多的资源时,如读取配置、产生其他依赖对象时,则可以通过在应用启动时直接产生一个单例对象,然后用永久驻留内存的方式来
单例模式可以避免对资源的多重占用,例如一个写文件操作,由于只有一个实例存在内存中,避免对同一个资源文件的同时写操作。
单例模式可以在系统设置全局的访问点,优化和共享资源访问,例如,可以设计一个单例类,负责所有数据表的映射处理。
缺点:
单例模式一般没有接口,扩展很困难,若要扩展,除了修改代码基本上没有第二种途径可以实现。
单例对象如果持有Context,那么很容易引发内存泄漏,此时需要注意传递给单例对象的Context最好是Application Context。
今天单例模式就介绍到这里,有什么不足的希望大家多提意见。
相关文章推荐
- Python动态类型的学习---引用的理解
- PropertyChangeListener简单理解
- 什么是设计模式
- 设计模式之创建型模式 - 特别的变量问题
- 七、设计模式——装饰模式
- 设计模式总结
- 设计模式之创建型模式
- 浅谈设计模式的学习
- 土人系列AS入门教程 -- 对象篇
- 交换机升级排障实例
- Ruby设计模式编程之适配器模式实战攻略
- 实例讲解Ruby使用设计模式中的装饰器模式的方法
- 设计模式中的模板方法模式在Ruby中的应用实例两则
- Ruby设计模式编程中对外观模式的应用实例分析
- C#托管堆对象实例包含内容分析
- 实例解析Ruby设计模式编程中Strategy策略模式的使用
- Ruby中使用设计模式中的简单工厂模式和工厂方法模式
- Lua编程示例(二):面向对象、metatable对表进行扩展
- Ruby使用设计模式中的代理模式与装饰模式的代码实例
- C#中面向对象编程机制之多态学习笔记