[关闭]
@coder-pig 2017-01-24T11:01:01.000000Z 字数 3115 阅读 973

如何让孩子爱上设计模式 —— 2.单例模式(Singleton Pattern)

设计模式初涉


描述性文字

23种不同的设计模式,分为三大类:

23种设计模式思维导图

本节描述的是最简单烂大街的单例模式。


1.应用场景:

当需要保证类在内存中的对象唯一性,可以使用单例模式,
不想创建多个实例浪费资源,或者避免多个实例由于多次调用
而出现错误。一般写工具类,线程池,缓存,数据库等可以用到。


2.设计思想:(保证对象的唯一性的三个步骤)

想法 实现
不允许其他程序用new对象 私有化该类的构造函数
在该类中创建对象 通过new在本类中创建一个本类对象
对外提供一个可以让其他程序获取该对象的方法 定义一个公有的方法,将在该类中所创建的对象返回

3.各种各样的单例写法


1.饿汉模式

  1. public class Singleton () {
  2. private static Singleton instance = new Singleton()
  3. private Singleton(){ }
  4. public static Singleton getInstance() {
  5. return instance;
  6. }
  7. }

获取单例对象:Singleton instace = Singleton.getInstance();
优点:类加载的时候就完成实例化,避免线程同步问题
缺点:由于在类加载的时候就进行了实例化,所以没有达到Lazy Loading(懒加载)
的效果,即使我们没用到这个实例,但是他还是会加载,从而造成内存浪费(可以忽略,
最常用的一种)。


2.懒汉模式(线程不安全,不可用)

  1. public class Singleton {
  2. private static Singleton instance = null;
  3. private Singleton() { }
  4. private static Singleton getInstance() {
  5. if(instance == null) {
  6. instance = new Singleton();
  7. }
  8. return instance;
  9. }
  10. }

尽管达到了懒加载,但是却存在线程安全问题,比如有两个线程,刚好都
执行完if(instance == null),接着准备执行instance = new Singleton()
语句,这样的结果会导致我们实例化了两个Singleton对象,这就是懒汉单例
模式可能会引发的线程安全问题,解决这个方法,我们可以对getInstance方法加锁。


3.懒汉模式(线程安全,但效率低,不推荐使用)

  1. public class Singleton {
  2. private Singleton instance = null;
  3. private Singleton() { }
  4. public static synchronized Singleton getInstance() {
  5. if(instance == null) {
  6. instance = new Singleton();
  7. }
  8. return instance;
  9. }
  10. }

尽管保证了线程安全,但是每个线程在想要获得实例时,执行getInstance()
方法都需要进行同步,而实例化代码只需执行一次就够了,后面获取该实例,
直接return即可,方法进行同步效率太低,需要改进。还有一种写法是:
synchronized (Singleton.class) { instance = new Singleton(); }
这样一样是线程不安全的,如果你想使用懒汉模式的话,推荐使用下面的:
DCL单例(双重检查锁定)。


4.懒汉模式双重校验锁

  1. public class Singleton {
  2. private static volatile Singleton instance = null;
  3. private Singleton() { }
  4. public static Singleton getInstance() {
  5. if(instance == null) {
  6. synchronized(Singleton.class) {
  7. if(instance == null) {
  8. instance = new Singleton();
  9. }
  10. }
  11. }
  12. return instance;
  13. }
  14. }

代码中进行了两次if检查,这样就可以保证线程安全,初始化一次后,
后面再次访问时,if检查,直接return 实例化对象。volatile是1.5后
引入的,volatile关键字会屏蔽Java虚拟机所做的一些代码优化,会导
致系统运行效率降低,而更好的写法是使用静态内部类来实现单例!


5.静态内部类实现单例模式

  1. public class Singleton {
  2. private Singleton() { }
  3. public static final Singleton getInstance() {
  4. return SingletonHolder.INSTANCE;
  5. }
  6. private static class SingletonHolder {
  7. private static final Singleton INSTANCE = new Singleton();
  8. }
  9. }

和饿汉式类似,两者都是通过类装载机制来保证初始化实例
的时候只有一个线程,从而避免线程安全问题,饿汉式的
Singleton类被加载,就会实例化,而静态内部类这种,
当Singleton类被加载时,不会立即实例化,调用getInstance方法,
才会装载SingletonHolder类,从而完成Singleton的实例化。


6.枚举实现单例模式

  1. public enum SingletonEnum {
  2. INSTANCE;
  3. private Singleton instance;
  4. SingletonEnum() {
  5. instance = new Singleton()
  6. }
  7. public Singleton getInstance() {
  8. return instance;
  9. }
  10. }

访问方式:SingletonEnum.INSTANCE.method();
INSTANCE即为SingletonEnum类型的引用,得到它就可以调用
枚举中的方法。既避免了线程安全问题,还能防止反序列化
重新创建新的对象,但是失去了类的一些特性,没有延时加载,
推荐使用。


7.使用容器实现单例模式

  1. public class SingletonManager {
  2. private static Map<String,Object> objMap = new HashMap<String,Object>();
  3. private Singleton() { }
  4. public static void registerService(String key,Object instance) {
  5. if(!objMap.containsKey(key)) {
  6. objMap.put(key,instance);
  7. }
  8. }
  9. public static Object getService(String key) {
  10. return objMap.get(key);
  11. }
  12. }

将多种单例类型注入到一个统一的管理类中,在使用时根据key获取对象
对应类型的对象。这种方式使得我们可以管理多种类型的单例,并且在使
用时可以通过统一的接口进行获取操作,降低了用户的使用成本,也对用
户隐藏了具体实现,降低了耦合度。


优缺点

优点:保持类对象唯一性,对于频繁创建和销毁的对象可以提高性能。
缺点:扩展困难,单例的方法无法生成子类对象,要扩展的话基本要重写这个类。

注意事项:

在Android中如果单例对象持有Context,那么很容易引发内存泄露。
此时需要注意传递给单例对象的Context最好是Application Context!!!


本文代码

https://github.com/coder-pig/DesignPatternsExample/tree/master/1.Singleton%20Pattern

修改日志

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注