设计模式1---单例模式（Singleton pattern）

单例模式Singleton

面试的时候，问到许多年轻的Android开发他所会的设计模式是什么，基本上都会提到单例模式，但是对

单例模式也是一知半解，在Android开发中我们经常会运用单例模式，所以我们还是要更了解单例模式才对。

定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式结构图：

 

单例模式有多种写法各有利弊，现在

我们来看看各种模式写法。

1. 饿汉模式

public class Singleton {  
     private static final Singleton instance = new Singleton();       

　　　private Singleton (){
     }

     public static Singleton getInstance() {  
     　　return instance;  
     }  
 }

这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 这种方式基于类加载机制避免了多线程的同步问题，

但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。

2. 懒汉模式（线程不安全）

public class Singleton {  
      private static Singleton instance;  

      private Singleton (){
      }   

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

懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，

反映稍慢一些，而且在多线程不能正常工作。

3. 懒汉模式（线程安全）

public class Singleton {  
      private static Singleton instance;  

      private Singleton (){
      }

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

 }

这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，

而且大部分时候我们是用不到同步的，所以不建议用这种模式。

4. 双重检查模式 （DCL）

public class Singleton {  
      private volatile static Singleton singleton;  

      private Singleton(){
      }   

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


 }                               

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第

二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，不了解volatile关键

字的可以查看Java多线程（三）volatile域这篇文章，在这篇文章我也提到了双重

检查模式是正确使用volatile关键字的场景之一。
在这里使用volatile会或多或少的影响性能，但考虑

到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例

对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然

发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在

某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用**静态内部类单例模

式**来替代DCL。

5. 静态内部类单例模式

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，只有第一次调用getInstance方法时虚拟机加载

SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以

推荐使用静态内部类单例模式。

6. 枚举单例

public enum Singleton {  
     INSTANCE;  

     public void doSomeThing() {  
     }  

 }

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例，上述讲的几种单例模式实现中，有一种

情况下他们会重新创建对象，那就是反序列化，将一个单例实例对象写到磁盘再读回来，从而获得了一个

实例。反序列化操作提供了readResolve方法，这个方法可以让开发人员控制对象的反序列化。在上述的几

个方法示例中如果要杜绝单例对象被反序列化是重新生成对象，就必须加入如下方法：

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

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

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

public class SingletonManager { 
　　private static Map<String, Object> objMap = new HashMap<String,Object>();
　　
     private Singleton() { 
　　}

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

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

} 

用SingletonManager 将多种的单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式

使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使

用成本，也对用户隐藏了具体实现，降低了耦合度。

总结

到这里七中写法都介绍完了，至于选择用哪种形式的单例模式，取决于你的项目本身，是否

是有复杂的并发环境，还是需要控制单例对象的资源消耗。 

基于volatile的双重检查锁(double-checked locking)

public class Singleton {
    //private static Singleton instance = null;
    //防止DCL失效问题，保证instance对象每次都是从住内存中读取
    private static volatile Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {            
        if (instance == null) { //避免不必要的同步
            synchronized (Singleton.class) {
                //在instance = null下创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

缺点:

• JDK1.5以上版本才有volatile。

优点:

• 资源利用率高，第一次执行getInstance()时才会被实例化，效率高。

只是看起来很完美

这种看起来很完美的优化技巧就是double-checked locking，但遗憾地告诉你，根据JLS规范，上面的代码不可靠！线程有可能得到一个不为null，但是构造不完全的对象。

Why？

造成不可靠的原因是编译器为了提高执行效率的指令重排。只要认为在单线程下是没问题的，它就可以进行乱序写入！以保证不要让cpu指令流水线中断。

指令重排

为了提高代码的执行效率，JVM会将执行频率高的代码编译成机器码；而对于频率不高的代码则仍然采用解释执行。

常见的编译优化方式有：

方法内联：免去参数、返回值传递过程

去虚拟化：接口的方法只有一个实现类，进行方法内联

冗余消除：运行时去掉无用代码

还有一些编译优化根据“逃逸分析”技术

标量替换：User u=new User(“zhang3”,18)

String n=“zhang3” int age=18,节省内存

栈上分配：逃逸对象直接在栈上分配，快速，GC及时

同步削除：去掉不必要的同步

new Instance()到底发生了什么？

memory = allocate(); //1：分配对象的内存空间

ctorInstance(memory); //2：初始化对象

instance = memory; //3：设置instance指向刚分配的内存地址

上面的伪代码中2、3步可能重排

        


解决方案1

Java5以后的版本，可以利用volatile关键字。

Why？

在java5以前，volatile原语不怎么强大，只能保证对象的可见性

但在java5之后，volatile语义加强了，被volatile修饰的对象，将禁止该对象上的读写指令重排序

这样，就保证了线程B读对象时，已经初始化完全了

解决方案2

这也是官方比较推荐的一种方案（effective java 2nd）

点击(此处)折叠或打开

public class InstanceHolder{
    private Instance(){}

    //Lazy initialization holder class idiom for static fields
    private static class Inner{
         private static final Instance ins = new Instance()
    }

    public static Instance getInstance(){
        return Inner.ins;
     }    
}

原理：一个类只有在被使用时才会初始化，而类初始化过程是非并行的，这些都由JLS能保证。

 

静态内部类单例模式

在《Java 并发编程实践》中提及了DCL失效的问题(上面基于volatile的双重检查锁例子中注释的部分)，建议使用如下代码替换:

public class Singleton {
    private static final Singleton sInstance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonHolder.sInstance;

    }

    private static class SingletonHolder {
         sInstance = new Singleton();
    }

}

优点:

• 资源利用率高，第一次执行getInstance()时才会被实例化，效率高。
• 不仅保证线程安全，而且也保证了单例对象的唯一性，同时也延迟了单例的实例化，所以这才是推荐使用的单例模式实现方式。

枚举单例

public class SingletonEnum {
    INSTANCE;
    
    public void doSomething() {
        //do something;
    }

}

优点:

• 枚举在Java中于普通的类一样，可以有字段，方法。 默认枚举创建的实例是线程安全的。
• 使用enum实现的单例自带防序列化。

然而上述的几种单例模式实现中在反序列化时会重新创建对象。要杜绝单例对象重新生成对象，必须要加入如下方法:

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

参考资料

• [1]《Android源码设计模式解析和实战》
• [2]《Java 并发编程实践》