Java併發（十九）：final實現原理

final在Java中是一個保留的關鍵字，能夠聲明成員變量、方法、類以及本地變量。

一旦你將引用聲明做final，你將不能改變這個引用了，編譯器會檢查代碼，若是你試圖將變量再次初始化的話，編譯器會報編譯錯誤。

1、final變量

　　final成員變量表示常量，只能被賦值一次，賦值後值再也不改變（final要求地址值不能改變）

　　當final修飾一個基本數據類型時，表示該基本數據類型的值一旦在初始化後便不能發生變化；若是final修飾一個引用類型時，則在對其初始化以後便不能再讓其指向其餘對象了，但該引用所指向的對象的內容是能夠發生變化的。本質上是一回事，由於引用的值是一個地址，final要求值，即地址的值不發生變化。

　　final修飾一個成員變量（屬性），必需要顯示初始化。這裏有兩種初始化方式，一種是在變量聲明的時候初始化；第二種方法是在聲明變量的時候不賦初值，可是要在這個變量所在的類的全部的構造函數中對這個變量賦初值。

2、final方法

使用final方法的緣由有兩個。

第一個緣由是把方法鎖定，以防任何繼承類修改它的含義，不能被重寫；

第二個緣由是效率，final方法比非final方法要快，由於在編譯的時候已經靜態綁定了，不須要在運行時再動態綁定。

（注：類的private方法會隱式地被指定爲final方法）

3、final類

當用final修飾一個類時，代表這個類不能被繼承。

final類中的成員變量能夠根據須要設爲final，可是要注意final類中的全部成員方法都會被隱式地指定爲final方法。

在使用final修飾類的時候，要注意謹慎選擇，除非這個類真的在之後不會用來繼承或者出於安全的考慮，儘可能不要將類設計爲final類。

4、final使用總結

final關鍵字的好處：

（1）final關鍵字提升了性能。JVM和Java應用都會緩存final變量。

（2）final變量能夠安全的在多線程環境下進行共享，而不須要額外的同步開銷。

（3）使用final關鍵字，JVM會對方法、變量及類進行優化。

關於final的重要知識點

1. final關鍵字能夠用於成員變量、本地變量、方法以及類。
2. final成員變量必須在聲明的時候初始化或者在構造器中初始化，不然就會報編譯錯誤。
3. 你不可以對final變量再次賦值。
4. 本地變量必須在聲明時賦值。
5. 在匿名類中全部變量都必須是final變量。
6. final方法不能被重寫。
7. final類不能被繼承。
8. final關鍵字不一樣於finally關鍵字，後者用於異常處理。
9. final關鍵字容易與finalize()方法搞混，後者是在Object類中定義的方法，是在垃圾回收以前被JVM調用的方法。
10. 接口中聲明的全部變量自己是final的。
11. final和abstract這兩個關鍵字是反相關的，final類就不多是abstract的。
12. final方法在編譯階段綁定，稱爲靜態綁定(static binding)。
13. 沒有在聲明時初始化final變量的稱爲空白final變量(blank final variable)，它們必須在構造器中初始化，或者調用this()初始化。不這麼作的話，編譯器會報錯「final變量(變量名)須要進行初始化」。
14. 將類、方法、變量聲明爲final可以提升性能，這樣JVM就有機會進行估計，而後優化。
15. 按照Java代碼慣例，final變量就是常量，並且一般常量名要大寫。
16. 對於集合對象聲明爲final指的是引用不能被更改，可是你能夠向其中增長，刪除或者改變內容。

5、final原理

最好先理解java內存模型 Java併發（二）：Java內存模型

對於final域，編譯器和處理器要遵照兩個重排序規則：

1.在構造函數內對一個final域的寫入，與隨後把這個被構造對象的引用賦值給一個引用變量，這兩個操做之間不能重排序。

　　（先寫入final變量，後調用該對象引用）

　　緣由：編譯器會在final域的寫以後，插入一個StoreStore屏障

2.初次讀一個包含final域的對象的引用，與隨後初次讀這個final域，這兩個操做之間不能重排序。

　　（先讀對象的引用，後讀final變量）

　　編譯器會在讀final域操做的前面插入一個LoadLoad屏障 

示例1：

public class FinalExample {
    int i; // 普通變量
    final int j; // final 變量
    static FinalExample obj;

    public void FinalExample() { // 構造函數
        i = 1; // 寫普通域
        j = 2; // 寫 final 域
    }

    public static void writer() { // 寫線程 A 執行
        obj = new FinalExample();
    }

    public static void reader() { // 讀線程 B 執行
        FinalExample object = obj; // 讀對象引用
        int a = object.i; // 讀普通域         a=1或者a=0或者直接報錯i沒有初始化
        int b = object.j; // 讀 final域      b=2
    }
}

 

第一種狀況：寫普通域的操做被編譯器重排序到了構造函數以外

而寫 final 域的操做，被寫 final 域的重排序規則「限定」在了構造函數以內，讀線程 B 正確的讀取了 final 變量初始化以後的值。

寫 final 域的重排序規則能夠確保：在對象引用爲任意線程可見以前，對象的 final 域已經被正確初始化過了，而普通域不具備這個保障。

第二種狀況：讀對象的普通域的操做被處理器重排序到讀對象引用以前

而讀 final 域的重排序規則會把讀對象 final 域的操做「限定」在讀對象引用以後，此時該 final 域已經被 A 線程初始化過了，這是一個正確的讀取操做。

讀 final 域的重排序規則能夠確保：在讀一個對象的 final 域以前，必定會先讀包含這個 final 域的對象的引用。

 

 

示例2：若是 final 域是引用類型

對於引用類型，寫 final 域的重排序規則對編譯器和處理器增長了以下約束：

在構造函數內對一個 final 引用的對象的成員域的寫入，與隨後在構造函數外把這個被構造對象的引用賦值給一個引用變量，這兩個操做之間不能重排序。

public class FinalReferenceExample {
    final int[] intArray; // final 是引用類型
    static FinalReferenceExample obj;

    public FinalReferenceExample() { // 構造函數
        intArray = new int[1]; // 1
        intArray[0] = 1; // 2
    }

    public static void writerOne() { // 寫線程 A 執行
        obj = new FinalReferenceExample(); // 3
    }

    public static void writerTwo() { // 寫線程 B 執行
        obj.intArray[0] = 2; // 4
    }

    public static void reader() { // 讀線程 C 執行
        if (obj != null) { // 5
            int temp1 = obj.intArray[0]; // 6  temp1=1或者temp1=2，不可能等於0
        }
    }
}

 假設首先線程 A 執行 writerOne() 方法，執行完後線程 B 執行 writerTwo() 方法，執行完後線程 C 執行 reader () 方法。

 

在上圖中，1 是對 final 域的寫入，2 是對這個 final 域引用的對象的成員域的寫入，3 是把被構造的對象的引用賦值給某個引用變量。這裏除了前面提到的 1 不能和 3 重排序外，2 和 3 也不能重排序。

JMM 能夠確保讀線程 C 至少能看到寫線程 A 在構造函數中對 final 引用對象的成員域的寫入。即 C 至少能看到數組下標 0 的值爲 1。而寫線程 B 對數組元素的寫入，讀線程 C 可能看的到，也可能看不到。JMM 不保證線程 B 的寫入對讀線程 C 可見，由於寫線程 B 和讀線程 C 之間存在數據競爭，此時的執行結果不可預知。

 

 

參考資料 / 相關推薦

深刻理解 Java 內存模型（六）——final

深刻理解Java中的final關鍵字

淺談Java中的final關鍵字

Java併發（二）：Java內存模型