设计模式------单例模式

单例模式主要分为

(一)、懒汉式单例 

(二)、饿汉式单例  
(三)、双重检查锁定 
(四)、静态(类级)内部类
(五)、单例和枚举 

通常情况下，我们写单例模式的时候无非就是三个步骤：构造器私有化，声明私有静态变量，提供静态获取实例的方法

   那么一个完美的单例需要做到哪些事呢？

1. 单例
2. 延迟加载
3. 线程安全
4. 没有性能问题
5. 防止序列化产生新对象
6. 防止反射攻击

1. （一）懒汉式-------懒到第一次调用才去实例化
2. public class Singleton {  
3.     private static Singleton INSTANCE;  
4.     private Singleton (){}  
5.   
6.     public static Singleton getInstance() {  
7.      if (INSTANCE == null) {  
8.          INSTANCE = new Singleton();  
9.      }  
10.      return INSTANCE;  
11.     }  
12. }  

1. （二）饿汉式 ----------类加载即实例化
2. public class Singleton {  
3.     private static final Singleton INSTANCE = new Singleton();  
4.     // 私有化构造函数  
5.     private Singleton(){}  
6.   
7.     public static Singleton getInstance(){  
8.         return INSTANCE;  
9.     }  
10. } 

       三、四都是懒汉式的改进

1. （三）双重检查锁定 
2. public static Singleton getSingleton() {  
3.     if (INSTANCE == null) {               // 第一次检查  
4.         synchronized (Singleton.class) {  
5.             if (INSTANCE == null) {      // 第二次检查  
6.                 INSTANCE = new Singleton();  
7.             }  
8.         }  
9.     }  
10.     return INSTANCE ;  
11. }

12. 可不看：

    这段代码看起来很完美，但仍旧存在问题，以下内容引用自黑桃夹克大神的如何正确地写出单例模式

    这段代码看起来很完美，很可惜，它是有问题。主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

    1. 给 instance 分配内存
    2. 调用 Singleton 的构造函数来初始化成员变量
    3. 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

    但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

    我们只需要将 instance 变量声明成 volatile 就可以了。

[java] view plain copy

1. 加了关键字

2. public class Singleton {  
3.     private volatile static Singleton INSTANCE; //声明成 volatile  
4.     private Singleton (){}  
5.   
6.     public static Singleton getSingleton() {  
7.         if (INSTANCE == null) {                           
8.             synchronized (Singleton.class) {  
9.                 if (INSTANCE == null) {         
10.                     INSTANCE = new Singleton();  
11.                 }  
12.             }  
13.         }  
14.         return INSTANCE;  
15.     }  
16.   
17. }  

使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。

1. public class Singleton {   
2.     /**  
3.      * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，  
4.      * 而且只有被调用到才会装载，从而实现了延迟加载  
5.      */   
6.     private static class SingletonHolder{   
7.         /**  
8.          * 静态初始化器，由JVM来保证线程安全  
9.          */   
10.         private static final Singleton instance = new Singleton();   
11.     }   
12.     /**  
13.      * 私有化构造方法  
14.      */   
15.     private Singleton(){   
16.     }   
17.   
18.     public static  Singleton getInstance(){   
19.         return SingletonHolder.instance;   
20.     }   
21. }  

使用内部类来维护单例的实例，当Singleton被加载时，其内部类并不会被初始化，故可以确保当 Singleton类被载入JVM时，不会初始化单例类。只有  getInstance()  方法调用时，才会初始化 instance。同时，由于实例的建立是时在类加载时完成，故天生对多线程友好， getInstance()  方法也无需使用同步关键字。

单例之枚举

[java] view plain copy

1. public enum Singleton{  
2.     INSTANCE;  
3. }  

这种方式的好处是：

1. 利用的枚举的特性实现单例
2. 由JVM保证线程安全
3. 序列化和反射攻击已经被枚举解决

调用方式为Singleton.INSTANCE, 出自《Effective Java》第二版第三条: 用私有构造器或枚举类型强化Singleton属性。

关于单例最佳实践的讨论可以看Stackoverflow：what-is-an-efficient-way-to-implement-a-singleton-pattern-in-java

下面将会介绍更为常见的单例模式，但是均未处理反射攻击，如果想了解更多可以看这篇文章：如何防止单例模式被JAVA反射攻击

上述一到四都无法抵抗反射攻击，而序列化攻击（对象序列化反序列化会出现对象不相同的情况）的话可以通过

用饿汉式做例子

1. public class Singleton implements Serializable {  
2.     private static final Singleton INSTANCE = new Singleton();  
3.     // 私有化构造函数  
4.     private Singleton(){}  
5.   
6.     public static Singleton getInstance(){  
7.         return INSTANCE;  
8.     }  
9.   
10.     /** 
11.      * 如果实现了Serializable, 必须重写这个方法 
12.      */  
13.     private Object readResolve() throws ObjectStreamException {  
14.         return INSTANCE;  
15.     }  
16. } 

重写readResolve即可！！