单例模式简单复杂，线程不安全到安全

0x01 ：简介

说到单例模式，可以说单例模式是最常见，也是最常用的设计模式了。Spring的bean默认就是单例的。虽然单例模式是最简单的设计模式，但是在实现上有多种方式，分别是饿汉式、懒汉式、双重校验锁；在线程安全方面有线程不安全的，也有线程相对安全的。总的来说实现单例模式有以下一些特点：

• 1、私有的构造方法

• 2、内部创建一个私有成员变量

• 3、提供一个公开、静态的获取成员的方法

类图

0x02：饿汉模式

首先介绍一下最简单的单例模式（饿汉模式），这种方式在单例类被加载的时候实例化。

public class Singleton {
      //内部创建一个私有成员变量
      private static Singleton instance = new Singleton();;

      private Singleton() {
           //私有的构造方法
      }

     public static Singleton getInstance() {
         //提供一个公开、静态的获取成员的方法
         return instance;
     }
 }

或者

public class Singleton {
      
      //内部创建一个私有成员变量
      private static Singleton instance;

      static {
          instance = new Singleton();
      }

      private Singleton() {
           //私有的构造方法
      }

     public static Singleton getInstance() {
         //提供一个公开、静态的获取成员的方法
         return instance;
     }
 }

饿汉模式的缺点在于，如果单例对象的创建过程比较耗时，那么将会导致应用程序的启动比较慢。

0x03：懒汉式

为了克服饿汉模式的缺点，将单例对象的创建过程延后到第一次使用单例对象时，这种实现方式被称为懒汉模式。

public class Singleton {

     private static Singleton instance;

      private Singleton() {
      }

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

需要注意的是懒汉式是线程不安全的。假设在单例类被实例化之前，有两个线程同时在获取单例对象，线程A在执行完if (instance == null) 后，线程调度机制将 CPU 资源分配给线程B，此时线程B在执行 if (instance == null)时也发现单例类还没有被实例化，这样就会导致单例类被实例化两次。为了防止这种情况发生，需要对 getInstance() 方法同步处理。改进后的懒汉模式：

public class Singleton {
      private static Singleton instance;

      private Singleton() {
      }

      // 线程安全的懒汉模式
      public synchronized static Singleton getInstance() {
          if (instance == null) {
             instance = new Singleton();
         }

         return instance;
     }
 }

可以使用ReentrantLock对象进行同步处理。改进后的懒汉模式实现方式，每次获取单例对象时都会加锁，在多线程情况下会造成性能损耗。

0x04：双重校验锁（double check）

双重校验锁实现本质也是一种懒汉式，相比懒汉式第2种实现方式将会有较大的性能提升。

public class Singleton {  
    
    private static Singleton instance;  

    private final static Object lock = new Object();  

    private Singleton() {  

    }  

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

synchronized同步块括号中的锁定对象是采用的一个无关的Object类实例，而不是采用this，因为getInstance是一个静态方法，在它内部不能使用未静态的或者未实例的类对象，因此也可以这样实现

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;
     }
 }

就算在单例类被实例化时有多个线程，同时执行了if (instance == null)的判断，但同一时间点只有一个线程可以获得锁后进入临界区。通过if (instance == null)判断的每个线程会依次获得锁进入临界区，所以进入临界区后还要再判断一次单例类是否已被其它线程实例化，以避免多次实例化。由于双重加锁实现仅在实例化单例类时需要加锁，所以相较于懒汉式第2种实现方式会带来性能上的提升。另外需要注意的是双重加锁要对 instance 域加上 volatile关键字修饰符。由于 synchronized 并不是对 instance 实例进行加锁（因为现在还并没有实例），所以线程在执行完 instance = new Singleton();修改 instance 的值后，应该将修改后的 instance 立即写入主存（main memory），而不是暂时存在寄存器或者高速缓冲区（caches）中，以保证新的值对其它线程可见。