单例模式

定义：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

• 单例模式–饿汉模式

饿汉模式和懒汉模式的区别？
根据代码 private static Singleton instance = new Singleton()我们知道，instance属于静态类型，静态类型在app启动时就已经被加载到了内存中，所以饿汉模式中，instance在启动时就被实例化了。与懒汉模式对比，懒汉模式是在调用getInstance()方法时才被实例化的,所以说懒汉模式比较懒，只有用到时才实例化。

package com.myimooc.designpattern.c1singleton;/** * @describe 单例模式Singleton-饿汉模式：当类被加载时，就创建实例 * 作用：保证整个应用程序中某个实例有且只有一个 * 类型：饿汉模式 */public class Singleton {    // 1.将构造方法私有化，不允许外部直接创建对象    private Singleton(){    }    // 2.创建类的唯一实例，使用private static    private static Singleton instance = new Singleton();    // 3.提供一个用于获取实例的方法，使用public static    public static synchronized Singleton getInstance(){        return instance;    }}

• 单例模式–懒汉模式

package com.myimooc.designpattern.c1singleton;/** * @describe 单例模式Singleton-懒汉模式：当用户获取的时候，才创建实例 * 作用：保证整个应用程序中某个实例有且只有一个 * 类型：懒汉模式 */public class Singleton2 {    // 1.将构造方法私有化，不允许外部直接创建对象    private Singleton2(){    }    // 2.创建类的唯一实例，使用private static    private static Singleton2 instance;    // 3.提供一个用于获取实例的方法，使用public static    public static synchronized Singleton2 getInstance(){        if(instance == null){            instance = new Singleton2();        }        return instance;    }}

读者可能已经发现，getInstance()方法中添加了synchronized关键字，也就是getInstance是一个同步方法，这就是上面所说的在多线程情况下保证单例对象唯一性的手段。细想一下，大家可能发现一个问题，即使instance已经被实例化（第一次调用时就会被初始化instance），每次调用getInstance方法都会进行同步，这样会消耗不必要的资源，这也是懒汉单例模式存在的最大问题。
最后总计一下，懒汉单例模式的优点是单例只有在使用时才会被实例化，在一定程度上节约了资源；缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getInstance都进行同步，造成不必要的同步开销。这种模式一般不建议使用。

• 单例模式–DCL（双重检查锁模式）
  DCL方式实现单例模式的优点是既能够在需要时才初始化单例，又能够保证线程安全，且单例对象初始化后抵用getInstance不进行同步锁。代码如下所示：

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

本程序的亮点自然都在getInstance方法上，可以看到getInstance方法中对instance进行了两次判空，第一次判空主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。这是什么意思呢？是不是有点摸不着头脑，下面就一起来分析一下。
假设线程A执行到sInstance = new Singleton()语句，这里看起来是一句代码，但实际上它并不是一个 原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事情：
（1）给Singleton的实例分配内存；
（2）调用Singleton的构造函数，初始化成员字段；
（3）将sInstance对象指向分配的内存空间（此时sInstance就不是null了）。
但是由于Java编译器允许处理乱序执行，以及jdk1.5之前JMM(Java内存模型)中Cache，寄存器到主内存回写顺序的规定，上面的第二和第三的顺序是无法保证的。也就是说，执行顺序可能是1-2-3，也肯能是1-3-2。如果是后者，并且在3执行完毕，2未执行之前，被切换到线程B上，这时候sInstance因为已经在线程A内执行过了第三点，sInstance已经是非空了，所以，线程B直接取走sInstance，再使用时就会出错，这就是DCL失效问题，而且这种难以跟踪难以重现的错误很可能会隐藏很久。
在JDK1.5之后，SUN官方已经注意到这种问题，调整了JVM，具体化了volatile关键字，因此，如果在JDK是1.5或者之后的版本，只需要将sInstance的定义改成private volatile static Singleton sInstance = null就可以保证sInstance对象每次都是从主内存中读取，就可以使用DCL的写法来完成单例模式。当然，volatile或多或少也会影响到性能，但考虑到程序的正确性，牺牲这点性能还是值得的。
DCL的优点是：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。缺点：第一次加载时反应稍慢，也由于Java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。DCL模式是使用最多的单例模式，它能够在需要时才实例化单例对象，并且能够在绝大数场景下保证单例对象的唯一性，除非你的代码在并发场景比较复杂或者低于JDK6版本下使用，否则，这种方式一定能够满足需求。

• 单例模式–静态内部类单例模式
  DCL虽然在一定程度上解决资源消耗，多余的同步，线程安全等问题，但是，他还是在某些情况下出现失效的问题。这个问题被称为双重检查锁定（DCL）失效，在《Java并发编程实践》一书的最后谈到了这个问题，并指出这种“优化”是丑陋的，不赞成使用。而建议使用如下的代码替代：

 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方法时才会导致sInstance被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不尽能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式。