[Java] [Singleton] [DCL][happens-before]

Singleton

• 只能有一个实例；必须本身建立本身的实例；必须给其余全部对象提供这一实例

实现方法

饿汉式singleton

• 预先加载法

• class Single {
    private Single() {
      System.out.println("ok");
    }
    
    private static Single instance = new Single();
    
    public static Single getInstance() {
      return instance;
    }
  }

• 优势：
  • thread safe
  • 调用时速度快(在类加载时已经建立好一个static对象)
• 缺点：
  • 资源利用率不高(可能系统不须要)
  • 在一些场景下没法使用。好比在single实例的建立依赖参数或配置文件时。

懒汉式singleton

• 延迟加载法

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

• 适用于单线程环境，not trhead-safe，getInstance()方法可能返回两个不一样实例。
• 能够改为thread-safe版本，以下：
  

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

• 优势：不执行getInstance对不会被实例化
• 缺点：第一次加载时反应不快。每次调用getInstance的同步开销大。(大量没必要要的同步)

DCL singleton

• Double Check Lock
• 避免每次调用getInstance方法时都同步

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

• 第一层判断，避免没必要要的同步。第二层判断则是在线程安全的状况下建立实例。
• 优势：资源利用率高，多线程下效率高。
• 缺点：第一次加载时反应不快，因为java内存模型一些缘由偶尔会失败，在高并发下有必定的缺陷。
• 上述代码依然存在不安全性：
  instance = new LazySingleton()这条语句实际上不是一个原子操做，它大概包括三件事：
  1. 给LazySingleton的实例分配内存；
  2. 初始化LazySingleton()的构造器；
  3. 将instance对象指向分配的内存空间(在这一步的时候instance变成非null)。

　　可是因为Java编译器容许处理器乱序执行(指令重排序)，上述二、3点的顺序是没法保证的。(意思是可能instance != null时有可能还未真正初始化构造器)。　
　　解决方法是经过将instance定义为volatile的。(volatile有两个语义：1. 保证变量的可见性；2. 禁止对该变量的指令重排序)

• 参考<<Java并发编程>> P286 ~ P287。在JMM后续版本(>= Java5.0)中，能够经过结合volatile的方式来启动DCL，而且该方式对性能的影响很小。然而，DCL的这种使用方式已经被普遍地抛弃了。
• (由于volatile屏蔽指令重排序的语义在JDK1.5中才被彻底修复，此前的JDK中即便将变量声明为volatile，也仍然不能彻底避免重排序所致使的问题，这主要是由于volatile变量先后的代码仍然存在重排序问题。)
• （Java5中多了一条happens-before的规则：对volatile字段的写操做happens-before后续对同一个字段的读操做）

static内部类singleton

• class Single {
    private Single() {}
    
    private static class InstanceHolder {
      private static final Single instance = new Single();
    }
    
    public static Single getInstance() {
      return InstanceHolder.instance();
    }
  }

• 优势：线程安全，资源利用率高。
• 缺点：第一次加载时反应不快。
• 原理：类级内部类(static修饰的成员内部类)只有在第一次使用时才会被加载。

Summary

• 考虑到效率、安全性等问题，通常经常使用饿汉式singleton or static内部类singleton。其中后者是经常使用的singleton实现方法。

Happens-before

• 是否能够经过几个基本的happens-before规则从理论上分析Java多线程程序的正确性，而不须要设计到硬件和编译器的知识呢？

Happens-before规则

• 通俗来讲，A happens-before B意味着操做A对内存施加的影响都能被B观测到。
• 关于happens-before：
  • happens-before relation on memory operations such reads and writes of shared varaiables.
  • In particular:
    • Each action in a thread happens-before every action in that thread that comes later in the program's order. （单线程规则）
    • An unlock (synchronized block or method exit) of a monitor happens-before every subsequent lock (synchronized block or method entry) of that same monitor. And because the happens-before relation is transitive, all actions of a thread prior to unlocking happen-before all actions subsequent to any thread locking that monitor. （线程安全性主要依赖这条规则）
    • A write to a volatile field happens-before every subsequent read of that same field. Writes and reads of volatile fields have similar memory consistency effects as entering and exiting monitors, but do not entail mutual exclusion locking.
    • A call to start on a thread happens-before any action in the started thread.
    • All actions in a thread happen-before any other thread successfully returns from a join on that thread.
    • happens-before关系具备传递性。 hb(A, B) + hb(B, C) => hb(A, C)
• 要知道，“A在时间上先于B”和“A happens-before B”二者并不等价。
• 两个操做之间必然存在某种时序关系(前后or同时)，但两个操做之间却不必定存在happens-before关系。但两个存在happens-before关系的操做不可能同时发生，这实际上也是同步的语义之一(独占访问)。
• 以及，上述一直提到的操做并不等同于语句。操做应该是单个虚拟机指令，单条语句可能由多个指令组成。

Happens-before & DCL

• DCL(without volatile)的主要问题在于尽管获得了LazySingleton的引用，但却有可能访问到其成员变量的不正确值。
• 从新分析上述DCL例子：
  

  public class LazySingleton {  
      private int someField;  
        
      private static LazySingleton instance;  
        
      private LazySingleton() {  
          this.someField = new Random().nextInt(200)+1;         // (1)  
      }  
        
      public static LazySingleton getInstance() {  
          if (instance == null) {                               // (2)  
              synchronized(LazySingleton.class) {               // (3)  
                  if (instance == null) {                       // (4)  
                      instance = new LazySingleton();           // (5)  
                  }  
              }  
          }  
          return instance;                                      // (6)  
      }  
        
      public int getSomeField() {  
          return this.someField;                                // (7)  
      }  
  } 

• DCL产生安全问题的主要缘由就在于：(1) & (7) 之间不存在happens-before关系。
• 这个例子中LazySingleton是一个不变类，它只有get而没有set方法。但上述例子让咱们知道，即便一个对象是不变的，在不一样的线程中也可能返回不一样值。这是由于LazySingleton没有被安全地发布。