单例模式详解

单例模式的概念

单例模式是指确保一个类仅有一个唯一的实例，并且提供一个全局的访问点。

单例模式的类图

实现单例模式的思路

1.为了防止客户程序利用构造方法创建多个对象，将构造方法声明为private类型。

2.该类必须提供一个可以获得实例的方法，通常称为getInstance()，值得注意，该方法必须是静态方法，否则客户程序将无法调用该方法。

3.而且应该确保无论客户程序调用该getInstance()方法多少次，得到始终是同一个对象，尤其是在多线程下。

4.确保单例类对象在反序列化时不会重新构建对象。

标单例模式7种用法

第一种(懒汉，线程不安全)

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

每次实例的时候都需要进行判断，致命的缺点是在多线程下无法工作。

第二种（懒汉，线程安全）

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

在getInstance()方法增加synchronized关键字。在多线程情况下保证对象的唯一。

第三种（饿汉）

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

instance在类装载时就创建对象实例，调用getInstance()方法直接返回。避开多线程问题以及每次调用getIntance()方法都要进行判断。

第四种（饿汉，变种）

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

与第三种相同的是，同样是在类加载的时候创建对象实例。不同的是执行顺序先后，static初始化块会比较先。

第五种（静态内部类）

public class Singleton {
    private  static class SingletonHolder {  //java不允许非静态内部类定义静态成员
    private  static final Singleton INSTANCE = new Singleton();  
        }  
    private Singleton(){
    }
    private static  Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

同样使用类加载机制来保证初始化类时，instance就被创建实例。不同于三四种：
1.第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化。

2.而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。

第六种（枚举类）

public enum Singleton{
    INSTANCE;
     public void whateverMethod() {  
        }  
}

1.5中才加入enum特性，使用enum创建枚举类。这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

第七种（双重校验锁）

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

这个是第二种方式的升级版，每次只有一个线程可以执行getInstance(),而这一种在创建一次后，就可以实现多线程同时调用。这个写法的特别之处在于对 instance 进行了两次判空：第一层主要是为了避免不必要的同步，第二层则是为了在 null 的情况下创建实例。
我们会发现上面代码有一个volatile关键字，因为在这里会有DCL失效问题。

DCL 失效问题：假设线程 A 执行到sInstance=new DCLSingleton()语句，这看上去像是一句代码，实际上它并不是一个原子操作，这句代码最终会被编译为多条汇编指令，它大致做了三件事：

1.给 sInstance 的实例分配内存；

2.调用 DCLSingleton 的构造函数，初始化成员字段；

3.将 sInstance 对象指向分配的内存空间（此时 sInstance 就不是 null了）。

但是由于 Java 编译器允许处理器乱序执行。因此执行顺序可能是 1-2-3 也可能是 1-3-2，如果是后者，并且在 3 执行完毕、2 未执行之前被切换到 B 线程上，这时的 sInstance 因为已经在线程 A 内执行过了第三点，sInstance 已经是非空了，所以线程 B 直接取走 sInstance，再使用就会出错，这就是 DCL 失效问题。

JDK 1.5 之后的版本具体化了 volatile 关键字，禁止该对象上的读写指令重排序，虽然会影响性能，这种方式第一次加载时会稍慢，在高并发环境会有缺陷，但是一般能够满足需求。
DCL失效问题具体可参考该链接：http://blog.itpub.net/28912557/viewspace-762047/

第八种（容器）

public class SingletonManager {  
    private  static Map<String,Object> objMap = new HashMap();
    private SingletonManager (){}  
    public static void registerService(String key, Object obj){
        if(!objMap.containsKey(key)){//判断是否存在，保证唯一
            objMap.put(key, obj);
        }
    }
    public static Object getService(String key){
        return objMap.get(key);
    }
} 

这种方式使得我们可以管理多种类型的单例。

类加载器不同与反序列化重建问题

1.如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。

private static Class getClass(String classname)throws ClassNotFoundException {     
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();     
        if(classLoader == null) {    
            classLoader = Singleton.class.getClassLoader(); 
        }
        return (classLoader.loadClass(classname));     
    }

2.如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。

public class Singleton implements java.io.Serializable {     
   public static Singleton INSTANCE = new Singleton();     

   protected Singleton() {     
   }     
   private Object readResolve() {     
            return INSTANCE;     
      }    
}