Java中final實現原理是什么

這篇文章將為大家詳細講解有關Java中final實現原理是什么，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

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

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

一、final變量

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

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

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

二、final方法

使用final方法的原因有兩個。

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

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

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

三、final類

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

final類中的成員變量可以根據需要設為final，但是要注意final類中的所有成員方法都會被隱式地指定為final方法。

在使用final修飾類的時候，要注意謹慎選擇，除非這個類真的在以后不會用來繼承或者出于安全的考慮，盡量不要將類設計為final類。

四、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指的是引用不能被更改，但是你可以向其中增加，刪除或者改變內容。

五、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實現原理是什么就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。