Java 16新特性

2021年3月16日，甲骨文正式發布了Java 16!想當年JDK1.6新出的場景和歷歷在目，一瞬間，版本已經變成了16，真正體會了一把什么叫做光陰似箭，滄海桑田。雖然目前大部分的場合，Java8還占著主導地位，但我猜想各位Javaer應該對Java16的新特性也大有興趣吧!

看完之后我覺得這次更新還是很有意思的，我就精選幾個Java16的新特性，供大家一飽眼福!(大家可以自己建個項目用起來試試)

支持模式匹配的instanceof

想想你是怎么用instanceof的吧，一個例子：

if (obj instanceof String) { 
    String s = (String) obj;    // grr... 
    ... 
} 

這代碼是不是讓人蛋疼，我都知道是個String了，還讓我強轉一下，該改進一下啦~

if (obj instanceof String s) { 
    //這里s隨你用了 從類型判斷，到變量定義，類型轉換，一氣呵成，爽不爽？ 
} 

進一步的，還可以這么用，模式變量s在判斷條件里直接使用

if (obj instanceof String s && s.length() > 5) { 
    flag = s.contains("jdk"); 
} 

不過要小心，下面的用法是錯誤的(原因就不多解釋啦)：

if (obj instanceof String s || s.length() > 5) {    // Error! 
    ... 
} 

Records類型

我們對Java最大的意見是啥?當然是太繁瑣了，一個簡單的功能，繁重的語法要整出好幾十行，不急，改進這就來了，看看新的Recodes類型吧!

假設你現在有這么一個類:

這是一個典型的不可變的數據對象，equals ()方法， hashCode()方法，toString()方法其實都是比較通用的。但是我們不得不為它多寫那么幾行代碼。雖然有IDE的鼎力協助，但是看上去還是不怎么爽(如果沒有IDE，更要哭了)。不過沒事Records來了!用Records來表示上面的類，你只需要:

record Point(int x, int y) { } 

是不是特別簡單，感覺心里特別爽?record類和普通的class不太一樣，它會幫你隱式生成一些字段和構造函數。比如上面的record就會編譯成這樣：

record Point(int x, int y) { 
    // 隱式生成字段 
    private final int x; 
    private final int y; 
    // 隱式生成構造函數，并帶上所有的參數 
    Point(int x, int y) { 
        this.x = x; 
        this.y = y; 
    } 
} 

ZGC并發線程處理

ZGC是The Z Garbage Collector，是JDK 11中推出的一款低延遲垃圾回收器，它嘗試解決GC之痛，也就是停頓。

同時，它也將面向以TB為單位的超大規模的內存。在Java 16中，ZGC的線程棧處理的眾多操作，從檢查點移動到了并發階段，這樣意味著停頓更小了。(后面準備出個zgc相關的文章，順便測一波這次的停頓優化時長)

彈性元空間

在Java虛擬機中，元空間用來保存一些類的元信息，并且，元空間中的數據是可以被垃圾回收的。但不幸的是，空閑的未被使用的元空間并不會歸還給操作系統，這就導致了內存浪費。

這個新特性就是為了解決這個問題，它使得虛擬機可以從元空間中歸還未使用的內存，從而更加有效得利用物理內存。同時有一個新的虛擬機參數可以用來控制這種回收的執行強度：-XX:MetaspaceReclaimPolicy=(balanced|aggressive|none)

Unix Domain套接字

Unix Domain套接字本身提供給了一套兼容于網絡編程，但是更加可靠、高效、安全的進程間通信方式，它不需要經過網絡協議棧，不需要打包拆包、計算校驗和、維護序號和應答等，只是將應用層數據從一個進程拷貝到另一個進程。

在Java 16中，已經可以直接使用這種套接字(Unix-domain (AF_UNIX)，雖然叫做UNIX套接字，windows 10和Windows Server 2019也是可以使用的)了。為了支持Unix Domain套接字，新增了專門的java.net.UnixDomainSocketAddress類，下面看一下它的使用：

新的打包工具

提供了一個新的打包工具jpackage，用來打包獨立的Java應用程序。這個工具可以生成windows上的exe和msi，MacOS上的pkg和dmg，以及linux上的deb和rpm。它很好的給用戶提供了一鍵式安裝Java程序的好方法。

比如，對于非模塊化的應用，可以這么打包：

jpackage --name myapp --input lib --main-jar main.jar 
或者 直接指定main class 
jpackage --name myapp --input lib --main-jar main.jar --main-class myapp.Main 

對于模塊化的應用：

jpackage --name myapp --module-path lib -m myapp 
或者直接指定main class 
jpackage --name myapp --module-path lib -m myapp/myapp.Main 

值對象錯誤使用的警告

值對象，比如java.lang.Integer, java.lang.Double之類的不變對象，在廢棄構造函數的基礎上，進一步標記為forRemoval(不要再使用它們的構造函數了哦!)。

同時，如果在值對象上進行同步，將會被警告，比如：

Double d = 20.0; 
synchronized (d) { ... } // javac和hotsopt都會警告 
Object o = d; 
synchronized (o) { ... } // HotSpot 會警告 

在虛擬機層面，還提供了參數可以在虛擬機層面控制報錯行為：

• -XX:DiagnoseSyncOnValueBasedClasses=1 將這種同步行為視為致命錯誤
• -XX:DiagnoseSyncOnValueBasedClasses=2 打開日志，在控制臺和飛行記錄儀中記錄這種同步行為

默認限制使用JDK內部API

對于一些JDK內部的API，作出了更嚴格的限制。比如 com.sun.*, jdk.*, and org.*這些包里的API，從Java 16開始，默認已經禁止使用了。因此，鼓勵大家使用標準API，而不是內部API(點擊這里查看可以替換的內部API)。比如說下面這句代碼，在Java 16中將報錯：

System.out.println(sun.security.util.SecurityConstants.ALL_PERMISSION); 

錯誤示例：

Exception in thread "main" java.lang.IllegalAccessError: class Test 
  (in unnamed module @0x5e481248) cannot access class 
  sun.security.util.SecurityConstants (in module java.base) because 
  module java.base does not export sun.security.util to unnamed 
  module @0x5e481248 

同時，JDK還提供--illegal-access參數用來控制對內部API的使用：

• --illegal-access=permit 允許使用內部API
• --illegal-access=warn 允許使用內部API，不過每次使用會得到一個警告
• --illegal-access=debug 允許使用內部API，會更詳細的打印每一個錯誤的調用堆棧，用它你就可以找到你在哪里有不正確的調用，就可以修復那些不合適的使用
• --illegal-access=deny 禁止使用內部API

孵化項目：向量API

我們知道，像Go這樣的后起之秀，已經在內部使用了AVX指令，性能飆升。Java在這方面也不甘示弱，在Java 16中，向量API作為一個孵化項目，允許我們直接使用SIMD指令來提高性能(如果有效使用，這波就帶你起飛了)。

讓我們先一睹為快吧!

下面是一個簡單的標量計算：

void scalarComputation(float[] a, float[] b, float[] c) { 
   for (int i = 0; i < a.length; i++) { 
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f; 
   } 
} 

重點來了，使用AVX2帶你起飛：

//256位的向量浮點運算 
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_256; 
 
void vectorComputation(float[] a, float[] b, float[] c) { 
    int i = 0; 
    int upperBound = SPECIES.loopBound(a.length); 
    for (; i < upperBound; i += SPECIES.length()) { 
        // FloatVector va, vb, vc; 
        var va = FloatVector.fromArray(SPECIES, a, i); 
        var vb = FloatVector.fromArray(SPECIES, b, i); 
        var vc = va.mul(va). 
                    add(vb.mul(vb)). 
                    neg(); 
        vc.intoArray(c, i); 
    } 
 
    for (; i < a.length; i++) { 
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f; 
    } 
} 

孵化項目：外部鏈接API

你是不是有抱怨過JNI太難用了?沒關系，JNI的進化版來了，這就是外部鏈接器!它提供了一個靜態的，純Java的訪問本地native 代碼的方法，它將極大簡化我們調用本地代碼的過程。

新的API：

• LibraryLookup::ofDefault：返回被JVM加載的庫，可以看到所有這些庫的符號
• LibraryLookup::ofPath：加載指定路徑
• LibraryLookup::ofLibrary ：根據庫名，加載庫

下面代碼展示了，使用Java調用clang庫中的clang_getClangVersion()方法：

LibraryLookup libclang = LibraryLookup.ofLibrary("clang"); 
LibraryLookup.Symbol clangVersion = libclang.lookup("clang_getClangVersion"); 

另外一個重要的類是C鏈接器：

interface CLinker { 
    MethodHandle downcallHandle(LibraryLookup.Symbol func, 
                                MethodType type, 
                                FunctionDescriptor function); 
    MemorySegment upcallStub(MethodHandle target, 
                             FunctionDescriptor function); 
} 

downcallHandle()表示在Java中調用本地方法;upcallStub()方法在native方法中調用java代碼。

下面的代碼展示了如何在Java代碼中，調用C函數size_t strlen(const char *s)：

MethodHandle strlen = CLinker.getInstance().downcallHandle( 
        LibraryLookup.ofDefault().lookup("strlen"), 
        MethodType.methodType(long.class, MemoryAddress.class), 
        FunctionDescriptor.of(C_LONG, C_POINTER) 
    ); 

上面代碼首先找到strlen符號;然后描述它的簽名。最后使用downcallHandle()得到表示strlen()函數的MethodHandle對象;最后，就可以調用strlen()方法啦~

try (MemorySegment str = CLinker.toCString("Hello")) { 
   long len = strlen.invokeExact(str.address()); // 5 
} 

反過來，也可以把Java函數作為參數傳遞給C函數進行回調：

比如有一個C函數：

void qsort(void *base, size_t nmemb, size_t size, 
           int (*compar)(const void *, const void *)); 

要調用這個C函數，必須準備一個函數指針compar，為了使用它，我們首先要得到它的MethodHandle：

MethodHandle qsort = CLinker.getInstance().downcallHandle( 
        LibraryLookup.ofDefault().lookup("qsort"), 
        MethodType.methodType(void.class, MemoryAddress.class, long.class, 
                              long.class, MemoryAddress.class), 
        FunctionDescriptor.ofVoid(C_POINTER, C_LONG, C_LONG, C_POINTER) 
    ); 

接著，用一個純Java類來實現compar函數：

class Qsort { 
    static int qsortCompare(MemoryAddress addr1, MemoryAddress addr2) { 
            return MemoryAccess.getIntAtOffset(MemorySegment.ofNativeRestricted(),  
                                               addr1.toRawLongValue()) -  
                   MemoryAccess.getIntAtOffset(MemorySegment.ofNativeRestricted(), 
                                               addr2.toRawLongValue()); 
    } 
} 

然后需要一個MethodHandle指向上述函數：

MethodHandle comparHandle 
    = MethodHandles.lookup() 
                   .findStatic(Qsort.class, "qsortCompare", 
                               MethodType.methodType(int.class, 
                                                     MemoryAddress.class, 
                                                     MemoryAddress.class)); 

然后，使用upcallStub()方法，得到一個函數指針(應該說是用Java描述的C函數指針)：

MemorySegment comparFunc 
    = CLinker.getInstance().upcallStub(comparHandle, 
                                            FunctionDescriptor.of(C_INT, 
                                                                  C_POINTER, 
                                                                  C_POINTER)); 
); 

最后，把這個"C函數指針"傳給C函數：

try (MemorySegment array = MemorySegment.allocateNative(4 * 10)) { 
    array.copyFrom(MemorySegment.ofArray(new int[] { 0, 9, 3, 4, 6, 5, 1, 8, 2, 7 })); 
    qsort.invokeExact(array.address(), 10L, 4L, comparFunc.address()); 
    int[] sorted = array.toIntArray(); // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] 
} 

好了，這就是使用外部鏈接API來使用本地代碼的全過程，是不是很酷炫呢?

預覽功能：密封類

類的繼承是面向對象的一個重要特性，但是濫用繼承對對象模型的建模也是非常不利的。對于這一點，Java還有較大的改進空間，密封類，正式對對象繼承的一種重大改進。

首先，來看JDK內部的一個例子：

package java.lang; 
 
abstract class AbstractStringBuilder { ... } 
public final class StringBuffer  extends AbstractStringBuilder { ... } 
public final class StringBuilder extends AbstractStringBuilder { ... } 

AbstractStringBuilder有兩個子類StringBuffer和StringBuilder。但是，我們的代碼卻無法繼承AbstractStringBuilder，因為AbstractStringBuilder是包內可見的，并不是public的。在很多場合，我們的對象模式其實并不希望徹底公開，我們有時候僅僅希望只有一些指定的類可以繼承，而不是可以任由繼承擴展。這就是密封類的設計初衷。

密封類/接口在聲明的時候，就可以指定哪些類可以從這里繼承，比如：

package com.example.geometry; 
 
public abstract sealed class Shape 
    permits Circle, Rectangle, Square { ... } 

注意新關鍵字sealed，它表示被修飾的類或者接口是密封的，緊接著使用permits關鍵字，指定哪些子類可以繼承它，這里只有Circle，Rectangle和Square可以從Shape繼承(繼承類和密封類必須要在同一個模塊，如果在unamed模塊，就需要在同一個package)。

使用密封類，還有一些限制，比如：

1.子類必須是直接繼承，而不是間接的

2.子類必須說明如果處理得到的密封屬性，三選一，必選一個：

• 子類標記為final，一了百了
• 子類也作為sealed類，并做有限的繼承擴展
• 子類申明為non-sealed，公開使用(這種情況，密封類的初衷就被打破了，繼承關系就不可控了)

下面的代碼說明了這3種情況：

package com.example.geometry; 
//使用final 
public final class Circle extends Shape { ... } 
//使用sealed 
public sealed class Rectangle extends Shape  
    permits TransparentRectangle, FilledRectangle { ... } 
public final class TransparentRectangle extends Rectangle { ... } 
public final class FilledRectangle extends Rectangle { ... } 
//使用non-sealed 
public non-sealed class Square extends Shape { ... } 

寫在最后的話

看了那么多Java 16的新功能，心里是不是有點小激動?不要猶豫了，下一個試試?

阿丙友情提示：不要在自己的項目中嘗試最新版本，等穩定后再嘗試，可以在自己的demo和自己項目上嘗試。

我是敖丙，你知道的越多，不知道的越多，我們下期見。