Java 列舉實作單例模式，執行緒安全又優雅！-有解無憂

來源：https://liuchenyang0515.blog.csdn.net/article/details/121049426

1. 雙重校驗鎖單例（DCL）

public class Singleton {

    private static volatile Singleton singleton;

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

這種DCL寫法的優點：不僅執行緒安全，而且延遲加載，

1.1 為什么要double check？去掉第二次check行不行？

當然不行，當2個執行緒同時執行getInstance方法時，都會執行第一個if判斷，由于鎖機制的存在，會有一個執行緒先進入同步陳述句，而另一個執行緒等待，當第一個執行緒執行了new Singleton()之后，就會退出synchronized的保護區域，這時如果沒有第二重if判斷，那么第二個執行緒也會創建一個實體，這就破壞了單例，

1.2 singleton為什么要加上volatile關鍵字?

主要原因就是 singleton = new Singleton();不是一個原子操作，

在JVM中，這句陳述句至少做了3件事

給Singleton的實體分配記憶體空間；
呼叫Singleton()的建構式，初始化成員欄位；
將singleton指向分配的記憶體空間(此時singleton就不是null了)

因為存在著指令重排序的優化，第2、3步的順序是不能保證的，最后的執行順序可能是1-2-3，也可能是1-3-2，假如執行順序是1-3-2，我們看看會出現什么問題

雖然singleton不是null，但是指向的空間并沒有初始化，還是會報錯，這就是DCL失效的問題，這種問題難以跟蹤難以重現可能會隱藏很久，

JDK1.5之前JMM(Java Memory Model，即Java記憶體模型)中的Cache、暫存器到主存的回寫規定，上面第二第三的順序無法保證，JDK1.5之后，SUN官方調整了JVM，具體化了volatile關鍵字，private static volatile Singleton singleton;只要加上volatile，就可以保證每次從主存中讀取（這涉及到CPU快取一致性問題，不在本文探討范圍內，有興趣自行搜索），也可以防止指令重排序的發生，避免拿到未完成初始化的物件，

簡單講，volatile主要就是限制JIT編譯器優化，編譯器優化常用的方法有：

將記憶體變數快取到暫存器；
調整指令順序充分利用CPU指令流水線，常見的是重新排序讀寫指令，

如果沒有volatile關鍵字，則編譯器可能優化讀取，使用暫存器中的快取值，如果這個變數由別的執行緒更新了的話，將出現實際值和讀取的值不一致，使用了volatile后，編譯器讀取的時候跳過快取，直接在記憶體中的實際位置讀變數，寫的時候通知其他快取更新，這就是所謂的保證記憶體可見性，并且使用volatile還能禁止指令重排序，

public volatile int a = 11;
......
int c = 6;
c = a;// 執行這一句的時候，在高并發情況下，a如果被修改為22，那么c會被賦值為22而不是11
//如果a不被volatile修飾，c有小概率被賦值為11，因為c取暫存器的快取副本11還沒來得及更新

2. 靜態內部類單例

public class Singleton{
 private Singleton(){}
 
 private static class SingletonInstance {
     private static Singleton singleton = new Singleton();
 }
 
 public static Singleton getInstance(){
   return SingletonInstance.singleton;
 }
}

與餓漢式的區別就在于，類加載的時候，這里并不會實體化物件，只有呼叫getInstance方法才會實體化物件，

和DCL優點一樣，延遲加載，效率高，

雖然DCL和靜態單例都不錯，但是它們并不能防止反序列化和反射生成多個實體，更好的寫法當然是列舉單例了！

3. 列舉單例 (推薦！！)

其他所有的實作單例的方式其實是有問題的，那就是可能被反序列化和反射破壞，

我們來看看JDK1.5中添加的列舉類來實作單例

public enum Singleton {
 INSTANCE,

 public void testMethod() {
  
 }
}

列舉的寫法的優點：

不用考慮懶加載和執行緒安全的問題，代碼寫法簡潔優雅
執行緒安全

反編譯任何一個列舉類會發現，列舉類里的各個列舉項是是通過static代碼塊來定義和初始化的(可以見后面3.2節反編譯分析單例列舉有分析到這個)，它們會在類被加載時完成初始化，而java類的加載由JVM保證執行緒安全，所以，創建一個Enum型別的列舉是執行緒安全的

防止破壞單例

我們知道，序列化可以將一個單例的實體物件寫到磁盤，然后再反序列化讀回來，從而獲得一個新的實體，即使建構式是私有的，反序列化時依然可以通過特殊的途徑去創建類的一個新的實體，相當于呼叫該類的建構式，

Java對列舉的序列化作了規定，在序列化時，僅將列舉物件的name屬性輸出到結果中，在反序列化時，就是通過java.lang.Enum的valueOf來根據名字查找物件，而不是新建一個新的物件，列舉在序列化和反序列化時，并不會呼叫構造方法，這就防止了反序列化導致的單例破壞的問題，

對于反射破壞單例的而言，列舉類有同樣的防御措施，反射在通過newInstance創建物件時，會檢查這個類是否是列舉類，如果是，會拋出例外java.lang.IllegalArgumentException: Cannot reflectively create enum objects，表示反射創建物件失敗，

綜上，列舉可以防止反序列化和反射破壞單例，

3.1 列舉單例模式的使用

// Singleton.java
public enum Singleton {
    INSTANCE;

    public void testMethod() {
        System.out.println("執行了單例類的方法");
    }
}

// Test.java
public class Test {
 public static void main(String[] args) {
        //演示如何使用列舉寫法的單例類
        Singleton.INSTANCE.testMethod();
        System.out.println(Singleton.INSTANCE);
    }
}

推薦 Spring Boot 基礎免費教程：

https://github.com/javastacks/spring-boot-best-practice

運行結果如下：

3.2 反編譯分析單例列舉類

為了讓大家進一步了解列舉類，我們將上面列舉單例類進行反編譯javap -p Singleton.class，其中-p的意思是反編譯的時候要包含私有方法，

// 這是反編譯后的內容
public final class Singleton extends java.lang.Enum<Singleton> {
  public static final Singleton INSTANCE;
  private static final Singleton[] $VALUES;
  public static Singleton[] values();
  public static Singleton valueOf(java.lang.String);
  private Singleton();
  public void testMethod();
  static {};
}

我們可以看到，

INSTANCE是Singleton類的實體
Singleton繼承了java.lang.Enum類
這里還有一個私有的Singleton的無參構造方法，列舉類的列舉項都會使用這個構造方法來實體化，也就是說，這里的INSTANCE會使用這個構造方法來實體化，
實體化的程序發生在最后空的static代碼塊中，可以通過javap的其他引數進一步分析static里面的位元組碼內容，static里面其實包含了很多位元組碼指令，這些指令在做列舉項INSTANCE的初始化作業，而static代碼塊是在類加載的時候執行的，也就是說Singleton類被加載的時候，INSTANCE就被初始化了，static代碼塊里面除了初始化INSTANCE，Singleton[] $VALUES這個定義的私有的陣列也是在static里面創建和初始化的，然后把所有列舉項按照定義的順序放入這個$VALUES陣列中，最后我們可以通過values方法來訪問這個陣列

為了分析每個方法中的操作，我們使用javap -p -c -v Singleton.class來看看更詳細的，-c來看每個方法中的位元組碼，-v把常量池資訊也列印出來，這里了解即可，看不懂就看我上面的結論吧，重點只需要看static代碼塊部分的位元組碼，下面是為結論做一個驗證，

/**
 * @author: 磚業洋__
 * @description: 我重點只分析最后的static部分
 */
public final class Singleton extends java.lang.Enum<Singleton>
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_ENUM
Constant pool:     // 需要注意常量池的部分，后面分析每條指令的時候可以回到這里查閱
   #1 = Fieldref           #4.#37         // Singleton.$VALUES:[LSingleton;
   #2 = Methodref          #38.#39        // "[LSingleton;".clone:()Ljava/lang/Object;
   #3 = Class              #17            // "[LSingleton;"
   #4 = Class              #40            // Singleton
   #5 = Methodref          #13.#41        // java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
   #6 = Methodref          #13.#42        // java/lang/Enum."<init>":(Ljava/lang/String;I)V
   #7 = Fieldref           #43.#44        // java/lang/System.out:Ljava/io/PrintStream;
   #8 = String             #45            // 執行了單例類的方法
   #9 = Methodref          #46.#47        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #10 = String             #14            // INSTANCE
  #11 = Methodref          #4.#42         // Singleton."<init>":(Ljava/lang/String;I)V
  #12 = Fieldref           #4.#48         // Singleton.INSTANCE:LSingleton;
  #13 = Class              #49            // java/lang/Enum
  #14 = Utf8               INSTANCE
  #15 = Utf8               LSingleton;
  #16 = Utf8               $VALUES
  #17 = Utf8               [LSingleton;
  #18 = Utf8               values
  #19 = Utf8               ()[LSingleton;
  #20 = Utf8               Code
  #21 = Utf8               LineNumberTable
  #22 = Utf8               valueOf
  #23 = Utf8               (Ljava/lang/String;)LSingleton;
  #24 = Utf8               LocalVariableTable
  #25 = Utf8               name
  #26 = Utf8               Ljava/lang/String;
  #27 = Utf8               <init>
  #28 = Utf8               (Ljava/lang/String;I)V
  #29 = Utf8               this
  #30 = Utf8               Signature
  #31 = Utf8               ()V
  #32 = Utf8               testMethod
  #33 = Utf8               <clinit>
  #34 = Utf8               Ljava/lang/Enum<LSingleton;>;
  #35 = Utf8               SourceFile
  #36 = Utf8               Singleton.java
  #37 = NameAndType        #16:#17        // $VALUES:[LSingleton;
  #38 = Class              #17            // "[LSingleton;"
  #39 = NameAndType        #50:#51        // clone:()Ljava/lang/Object;
  #40 = Utf8               Singleton
  #41 = NameAndType        #22:#52        // valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
  #42 = NameAndType        #27:#28        // "<init>":(Ljava/lang/String;I)V
  #43 = Class              #53            // java/lang/System
  #44 = NameAndType        #54:#55        // out:Ljava/io/PrintStream;
  #45 = Utf8               執行了單例類的方法
  #46 = Class              #56            // java/io/PrintStream
  #47 = NameAndType        #57:#58        // println:(Ljava/lang/String;)V
  #48 = NameAndType        #14:#15        // INSTANCE:LSingleton;
  #49 = Utf8               java/lang/Enum
  #50 = Utf8               clone
  #51 = Utf8               ()Ljava/lang/Object;
  #52 = Utf8               (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
  #53 = Utf8               java/lang/System
  #54 = Utf8               out
  #55 = Utf8               Ljava/io/PrintStream;
  #56 = Utf8               java/io/PrintStream
  #57 = Utf8               println
  #58 = Utf8               (Ljava/lang/String;)V
{
  public static final Singleton INSTANCE; // 定義列舉項
    descriptor: LSingleton;
    flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM

  private static final Singleton[] $VALUES; // 定義物件陣列，并沒有初始化，只是空參考
    descriptor: [LSingleton;
    flags: ACC_PRIVATE, ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC

  public static Singleton[] values();
    descriptor: ()[LSingleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: getstatic     #1                  // Field $VALUES:[LSingleton;
         3: invokevirtual #2                  // Method "[LSingleton;".clone:()Ljava/lang/Object;
         6: checkcast     #3                  // class "[LSingleton;"
         9: areturn
      LineNumberTable:
        line 1: 0

  public static Singleton valueOf(java.lang.String);
    descriptor: (Ljava/lang/String;)LSingleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: ldc           #4                  // class Singleton
         2: aload_0
         3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
         6: checkcast     #4                  // class Singleton
         9: areturn
      LineNumberTable:
        line 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  name   Ljava/lang/String;

  private Singleton();
    descriptor: (Ljava/lang/String;I)V
    flags: ACC_PRIVATE
    Code:
      stack=3, locals=3, args_size=3
         0: aload_0       // 堆疊操作指令，把區域方法表里的第0個位置的變數load加載到堆疊上來，a前綴表示它是一個參考型別，
       // 提醒: 當JVM執行一段代碼的時候，首先會把用到的所有的變數存在一個本地變數表里————區域變數表，
       // 在堆疊上做計算的時候，需要使用區域方法表的值，就會通過load指令把它們加載到堆疊上來
       // 在堆疊上運算完之后，需要把值存回到區域方法表，所以也會有對應的store指令，load和store是對應的，
         1: aload_1
         2: iload_2
         3: invokespecial #6                  // Method java/lang/Enum."<init>":(Ljava/lang/String;I)V
         6: return
      LineNumberTable:
        line 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       7     0  this   LSingleton;
    Signature: #31                          // ()V

  public void testMethod();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #8                  // String 執行了單例類的方法
         5: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   LSingleton;

  static {};
    descriptor: ()V.        // 就是代表回傳void型別
    flags: ACC_STATIC
    Code:
      stack=4, locals=0, args_size=0
         0: new           #4                  // class Singleton
         // new #4表示從常量池里拿到標號4這個型別的名字，往上看Constant pool部分的定義可知就是Singleton這個類，然后new出來變成物件
         3: dup          // 然后dup壓堆疊
         4: ldc           #10                 // String INSTANCE,將常量池中標號10的String型別的值INSTANCE推送到堆疊頂
         6: iconst_0        // 定義一個int型別的變數值為0，我也不知道這里定義個常量有什么卵用
         7: invokespecial #11                 // Method "<init>":(Ljava/lang/String;I)V，呼叫構造器初始化，回傳型別為void
        10: putstatic     #12                 // Field INSTANCE:LSingleton;給INSTANCE這個靜態變數賦值，和name一樣
        13: iconst_1        // 定義一個int型別的變數值為1，然并卵
        14: anewarray     #4                  // class Singleton，實體化一個裝Singleton列舉型別的陣列，這里就是$VALUES陣列
        17: dup
        18: iconst_0
        19: getstatic     #12                 // Field INSTANCE:LSingleton;取出欄位INSTANCE的name值
        22: aastore         
        23: putstatic     #1                  // Field $VALUES:[LSingleton;將區域變數表中的列舉項的name值都依次放入$VALUES陣列中
        26: return
      LineNumberTable:
        line 2: 0
        line 1: 13
}

實編譯完的位元組碼是給JVM看的，JVM只需要無腦順序往下執行即可，多的方面就涉及JVM很多內容了，和本文主題無關，這里大家主要看static代碼塊中有哪些指令，明白列舉為什么會執行緒安全即可，

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2022最新版)

2.勁爆！Java 協程要來了，，，

3.Spring Boot 2.x 教程，太全了！

4.別再寫滿屏的爆爆爆炸類了，試試裝飾器模式，這才是優雅的方式！！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/547175.html

標籤：Java

上一篇：聊聊「訂單」業務的設計與實作

下一篇：windows 系統下 workerman 在同一個運行視窗中開啟多個 websocket 服務