本文是 Inside Java Newscast #1 的集体体验与解读。视频地址：点击这里

⎯⎯⎯⎯⎯⎯ Chapters ⎯⎯⎯⎯⎯⎯

• 0:00 – Intro
• 0:57 – Java 16 – Intro
• 1:16 – Java 16 – Records
• 1:43 – Java 16 – Type Pattern Matching
• 1:58 – Java 16 – Sealed Classes – Preview
• 2:25 – Java 16 – Stream API
• 2:51 – Java 16 – HTTP/2 API
• 3:14 – Java 16 – Unix Domain Sockets
• 3:32 – Java 16 – Project Panama (Incubating)
• 4:07 – Java 16 – JDK Flight Recorder
• 4:39 – Java 16 – jpackage
• 5:02 – Java 16 – Performance
• 5:23 – Java 16 – Security
• 5:48 – Java 16 – Ports
• 5:55 – Java 16 – Deprecations/Limitations
• 6:49 – Java 16 – Outro
• 7:08 – Java 17
• 7:22 – Java 17 – Another Port
• 7:34 – Java 17 – Applet for Removal
• 7:55 – Java 17 – Sealed Classes
• 8:12 – Outro

Java 16 – Records

相干 JEP 地址：

• JEP 359: Records(Preview)
• JEP 384: Records (Second Preview)
• JEP 395: Records

Records 这个个性我认真钻研过实现：参考我写的另一篇文章 Java Record 的一些思考 – 默认办法应用以及基于预编译生成相干字节码的底层实

简略说来其实就是（编译后查看下字节码就能看进去），在编译后，依据 Record 源码插入相干域与办法的字节码，包含：

1. 主动生成的 private final field
2. 主动生成的全属性结构器
3. 主动生成的 public getter 办法

4. 主动生成的 hashCode()，equals()，toString() 办法：

   1. 从字节码能够看出，这三个办法的底层实现是 invokeDynamic 另一个办法
   2. 调用的是 ObjectMethods.java 这个类中的 bootstrap 办法

这个还让我闹了个笑话，我认为这个是 Project Valhala 的 Inline Object 曾经实现了（参考我的这个系列：JEP 尝鲜系列），还去 StackOverflow 问，这个 Record 为啥能有 wait() 办法，并且能够进行 synchronized 同步（因为如果是 Project Valhala 的 Inline Object 的话是没有一般类的对象头的，没法用一般类对象的办法实现同步），后果。。。。。最初还是 Goetz 大佬一眼就看出我是误会了：

Record 这个个性当初是为了适应什么场景设计的，以及某些设计为何被舍弃，能够参考 Gotez 大佬的这篇文章 java-14-feature-spotlight. 其重中次要的看点总结如下：

1.Java Records 最罕用于的中央就是办法多个返回后果，原来咱们可能须要用 Apache-commons 外面的 Pair 或者 Tuple 这样的对象封装，或者本人新建一个类型。当初能够应用 Record。

2. 第二个常见利用即在 Stream 中传递的过程中放弃原有对象，并且缩小运算，例如 Stream 排序：

List<Player> topN
        = players.stream()
             .sorted(Comparator.comparingInt(p -> getScore(p)))
             .limit(N)
             .collect(toList());

这么写的话，每次作比拟都会调用一次 getScore(p)，这个调用次数是 O(n^2)。利用 Record 能够用比拟少的代码和改变实现缩小运算：

record PlayerScore(Player player, Score score) {
    // convenience constructor for use by Stream::map
    PlayerScore(Player player) {this(player, getScore(player)); }
}

List<Player> topN
    = players.stream()
             .map(PlayerScore::new)
             .sorted(Comparator.comparingInt(PlayerScore::score))
             .limit(N)
             .map(PlayerScore::player)
             .collect(toList());

最初再举荐下我写的这篇对于 Record 的序列化的一些解析和思考：Java Record 的一些思考 – 序列化相干

Java 16 – Type Pattern Matching

相干 JEP 地址：

• JEP 305: Pattern Matching for instanceof (Preview)
• JEP 375: Pattern Matching for instanceof (Second Preview)
• JEP 394: Pattern Matching for instanceof

类型模式匹配始终是一个呼声很高的个性，如果和下一大节的 Sealed Class 个性 以及 Patterns in switch 联合起来应用会有更好的成果，这个咱们在下一节会更具体的阐明.

Nicolai 对 Type Pattern Matching 的阐明

Nicolai 的这篇文章 对 Type Pattern Matching 的阐明十分具体，总结如下：

原来须要这么写的代码：

void feed(Animal animal) {if (animal instanceof Elephant) {((Elephant) animal).eatPlants();}
    else if (animal instanceof Tiger) {((Tiger) animal).eatMeat();}
    
}

当初能够间接这么写：

void feed(Animal animal) {if (animal instanceof Elephant elephant)
        elephant.eatPlants();
    else if (animal instanceof Tiger tiger)
        tiger.eatMeat();}

不须要空指针判断 ，因为 instanceof 曾经自带 null 判断了， 符合条件的 Type Pattern Matching 变量不会为 null。并且，Type Pattern Matching 不反对向上匹配，因为这个没有意义，即上面的代码会编译报错：

public void upcast(String string) {
    // compile error
    if (string instanceof CharSequence sequence)
        System.out.println("Duh");
}

还有一个罕用的中央即实现 equals：

// old
@Override
public boolean equals(Object o) {if (this == o)
        return true;
    if (!(o instanceof Equals))
        return false;
    Type other = (Type) o;
    return someField.equals(other.someField)
        && anotherField.equals(other.anotherField);
}

// new
@Override
public final boolean equals(Object o) {
    return o instanceof Type other
        && someField.equals(other.someField)
        && anotherField.equals(other.anotherField);
}

其实 Type Pattern Matching 是个语法糖

其实这个个性是一个语法糖，咱们能够简略测试下：

public class TypePatternMatching {public static void main(String[] args) {Object object = new Object();
        if (object instanceof String s) {System.out.println("a");
        }
    }
}

查看编译后的字节码：

public class test.TypePatternMatching {public test.TypePatternMatching();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Object
       3: dup
       4: invokespecial #1                  // Method java/lang/Object."<init>":()V
       7: astore_1
       8: aload_1
       9: instanceof    #7                  // class java/lang/String
      12: ifeq          28
      15: aload_1
      16: checkcast     #7                  // class java/lang/String
      19: astore_2
      20: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      23: ldc           #15                 // String a
      25: invokevirtual #17                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      28: return
}

能够看出，字节码其实和上面的写法是一样的：

public static void main(String[] args) {Object object = new Object();
    if (object instanceof String) {String s = (String)object;
        System.out.println("a");
    }

}

大家能够反编译下这个 class，就能看进去。

Java 16 – Sealed Classes – Preview

Sealed Class 在 Java 17 曾经公布了，相干的 JEP 如下：

• JEP 360: Sealed Classes (Preview)
• JEP 397: Sealed Classes (Second Preview)
• JEP 409: Sealed Classes

在某些状况下，咱们可能想 枚举一个接口的所有实现类，例如：

interface Shape { }
record Circle(double radius) implements Shape { }
record Rectangle(double width, double height) implements Shape { }

double area(Shape shape) {if (shape instanceof Circle circle)
        return circle.radius() * circle.radius() * Math.PI;
    if (shape instanceof Rectangle rect)
        return rect.width() * rect.height();
    throw new IllegalArgumentException("Unknown shape");
}

咱们如何能确定咱们枚举完了所有的 Shape 呢？Sealed Class 这个个性为咱们解决这个问题，Sealed Class 能够在申明的时候就决定这个类能够被哪些类继承：

sealed interface Shape permits Rectangle, Circle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
double area(Shape shape) {if (shape instanceof Circle circle)
        return circle.radius() * circle.radius() * Math.PI;
    if (shape instanceof Rectangle rect)
        return rect.width() * rect.height();
    throw new IllegalArgumentException("Unknown shape");
}

Sealed Class（能够是 abstract class 或者 interface）在申明时须要指定所有的实现类的名称。针对继承类，有如下限度：

• Sealed Class 的继承类必须和 Sealed Class 在 同一个模块下 ，如果 没有指定模块 ，就必须在 同一个包下
• 每个继承类必须间接继承 Sealed Class，不能间接继承

• 每个继承类必须是上面三种之一：

  • final 的 class，Java Record 自身就是 final 的
  • sealed 的 class，能够进一步指定会被哪些子类实现
  • non-sealed 的 class，也是一种扩大，然而突破 Sealed Class 的限度，Sealed Class 不晓得也不关怀这种的继承类还会有哪些子类。

举个例子即：

sealed interface Shape permits Rectangle, Circle, Triangle, WeirdShape {}
    
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}


sealed interface Triangle extends Shape permits RightTriangle, NormalTriangle {}
record RightTriangle(double width, double height) implements Triangle {}
record NormalTriangle(double width, double height) implements Triangle {}

static non-sealed class WeirdShape implements Shape {}
class Star extends WeirdShape {}

double area(Shape shape) {if (shape instanceof Circle circle)
        return circle.radius() * circle.radius() * Math.PI;
    if (shape instanceof Rectangle rect)
        return rect.width() * rect.height();
    if (shape instanceof RightTriangle rt)
        return rt.width() * rt.height() / 2;
    if (shape instanceof NormalTriangle nt)
        return nt.width() * nt.height() / 2;
    throw new IllegalArgumentException("Unknown shape");

}

如果联合 Pattern Matching for switch 这个个性，就能实现更加不便的写法，然而目前 Java 17 中，Pattern Matching for switch 还处于 Preview：JEP 406: Pattern Matching for switch (Preview)。咱们须要在编译参数和启动参数中加上 --enable-preview，这样就能像上面这样写代码：

double area(Shape shape) {return switch (shape) {case Circle circle -> circle.radius() * circle.radius() * Math.PI;
        case Rectangle rect -> rect.width() * rect.height();
        case RightTriangle rt -> rt.width() * rt.height() / 2;
        case NormalTriangle nt -> nt.width() * nt.height() / 2;
        default -> throw new IllegalArgumentException("Unknown shape");
    };

}

Java 16 – Stream API 更新

Java 16 中针对 Stream API 有两个更新，这里先提一个题外话，如果想看 JDK 不同版本之间有何差别，减少或者删除了哪些 API，能够通过上面这个链接查看：

• https://javaalmanac.io/jdk/17…

门路中的两个版本就是要比照的两个版本，其界面如下：

同时，咱们也能够通过 JDK 内置 jdeps 工具查找过期以及废除 API 以及对应的替换

jdeps --jdk-internals -R --class-path 'libs/*' $project

libs 是你的所有依赖的目录，$project 是你的我的项目 jar 包，示例输入：

...
JDK Internal API                         Suggested Replacement
----------------                         ---------------------
sun.misc.BASE64Encoder                   Use java.util.Base64 @since 1.8
sun.reflect.Reflection                   Use java.lang.StackWalker @since 9

对于这个更新，我写了一篇文章进行解析：Java 16 中新增的 Stream 接口的一些思考，核心内容总结如下：

假如有邮件这个 Record 类，蕴含 id，以及发送到的邮箱和抄送到的邮箱：

record Mail(int id, Set<String> sendTo, Set<String> cc) {}

咱们想找到一批邮件的所有不同的联系人，最初放到一个 List 中，可能会这么写：

Set<String> collect = mails.stream().flatMap(mail -> {Set<String> result = new HashSet<>();
    result.addAll(mail.sendTo());
    result.addAll(mail.cc());
    return result.stream();}).collect(Collectors.toSet());

然而，这样写显然很不优雅，首先是对于 每一个 Mail 都创立了额定的 Set 和对应的 Stream，并且，对于 每个 mail 的 sendTo 还有 cc 都遍历了两遍（addAll 一遍，后续 Stream 又一遍）。其实咱们的目前只是将 mail 中的 cc 以及 sendTo 取出来，用于参加后续的 Stream。在这种场景下，就非常适合用 mapMulti：

Set<String> collect = mails.stream().<String>mapMulti((mail, consumer) -> {mail.cc().forEach(consumer::accept);
    mail.sendTo().forEach(consumer::accept);
}).collect(Collectors.toSet());

能够看出：

• mapMulti 的入参是一个 BiConsumer，其实就是 应用其参数中的 consumer 接管参加 Stream 后续的对象
• mapMulti 的思路就是将参数中的 须要参加后续 Stream 的对象传入 consumer 来持续 Stream
• consumer 没有限度对象类型，想要限度必须加上形参 <String> 否则最初返回的是 Set<Object> 而不是 Set<String>

对于 Stream 减少了 toList 间接转换成 List，因为不波及 collect 外面的截断操作，所以比 collect 占用的内存更小，须要的操作更少并且更快 。之前转换成 List，须要 collect(Collectors.toList())， 生成的 List 是 ArrayList，是可变的 。然而这次新加的 Api，toList 生成的是 UnmodifiableList，是不可变的 。所以这两个 API 不能间接相互替换，须要做一些查看确认没有更改能力替换。

Java 16 – HTTP/2 API

Java 16 中还引入了两个对于 HTTP/2 API 的 JDK 补充，参考：

• JDK-8252304: Seed an HttpRequest.Builder from an existing HttpRequest
• JDK-8252382: Add a new factory method to concatenate a sequence of BodyPublisher instances into a single publisher

Java 16 – Unix Domain Sockets

相干 JEP：

• JEP 380: Unix-Domain Socket Channels

Unix domain sockets 以本地文件的模式命名，让咱们能够像拜访本地文件一样拜访本地网络连贯。这个用于在同一个机器部署的不同过程之间的通信，上面是一个简略的 BIO 的例子：

// 创立 UnixDomainSocketAddress
Path socketFile = Path.of("/home/zhanghaxi/process1");
UnixDomainSocketAddress address = UnixDomainSocketAddress.of(socketFile);

// 服务端监听
ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
serverChannel.bind(address);
SocketChannel channel = serverChannel.accept();

// 客户端连贯

SocketChannel channel = SocketChannel.open(StandardProtocolFamily.UNIX);
channel.connect(address);

对于 NIO 的例子，请参考：https://docs.oracle.com/en/ja…

相比于 TCP/IP 本地回环连贯拜访，因为 Unix Domain Sockets 晓得他拜访的是本地过程，所以 缩小了很多查看与校验 （例如寻址与路由），同时 因为不必做这些查看，包的大小也要小一些。反对 Unix Domain Sockets 的操作系统有 Linux, MacOS 和 Windows 10 以上的版本以及 Windows Server 2019 以上的版本.

Java 16 – Project Panama (Incubating)

Project Panama 是一个让 Java 变得更全面的我的项目，目前还处于孵化中的状态。他目前次要包含以下三个 API：

• Vector API：让 Java 也能应用新的 CPU 指令例如 SIMD（Single Instruction Multiple Data）相干指令来优化计算速度
• Foreign Linker API：让 Java 能够间接调用零碎库，不必通过 JNI 再封装一层。
• Foreign-Memory Access API：让 Java 能够间接操作内部内存，冲破现有对外内存 API 的限度，同时也是能够整合对立现有堆外内存操作的 API。

Vector API

相干 JEP：

• JEP 338: Vector API (Incubator)
• JEP 414: Vector API (Second Incubator)：Java 17 中的
• JEP 417: Vector API (Third Incubator)：Java 18 中的

其中最次要的利用就是应用了 CPU 的 SIMD（单指令多数据）解决，它提供了通过程序的多通道数据流，可能有 4 条通道或 8 条通道或任意数量的单个数据元素流经的通道。并且 CPU 一次在所有通道上并行组织操作，这能够极大减少 CPU 吞吐量。通过 Vector API，Java 团队正在致力让 Java 程序员应用 Java 代码间接拜访它；过来，他们必须在汇编代码级别对向量数学进行编程，或者应用 C/C++ 与 Intrinsic 一起应用，而后通过 JNI 提供给 Java。

一个次要的优化点就是循环，过来的循环（标量循环），一次在一个元素上执行，那很慢。当初，您能够应用 Vector API 将标量算法转换为速度更快的数据并行算法。一个应用 Vector 的例子：

// 测试指标为吞吐量
@BenchmarkMode(Mode.Throughput)
// 须要预热，排除 jit 即时编译以及 JVM 采集各种指标带来的影响，因为咱们单次循环很屡次，所以预热一次就行
@Warmup(iterations = 1)
// 单线程即可
@Fork(1)
// 测试次数，咱们测试 10 次
@Measurement(iterations = 10)
// 定义了一个类实例的生命周期，所有测试线程共享一个实例
@State(value = Scope.Benchmark)
public class VectorTest {
    private static final VectorSpecies<Float> SPECIES =
            FloatVector.SPECIES_256;

    final int size = 1000;
    final float[] a = new float[size];
    final float[] b = new float[size];
    final float[] c = new float[size];

    public VectorTest() {for (int i = 0; i < size; i++) {a[i] = ThreadLocalRandom.current().nextFloat(0.0001f, 100.0f);
            b[i] = ThreadLocalRandom.current().nextFloat(0.0001f, 100.0f);
        }
    }

    @Benchmark
    public void testScalar(Blackhole blackhole) throws Exception {for (int i = 0; i < a.length; i++) {c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
        }
    }

    @Benchmark
    public void testVector(Blackhole blackhole) {
        int i = 0;
        // 高于数组长度的 SPECIES 一次解决数据长度的倍数
        int upperBound = SPECIES.loopBound(a.length);
        // 每次循环解决 SPECIES.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;
        }
    }

    public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(VectorTest.class.getSimpleName()).build();
        new Runner(opt).run();}
}

留神应用处于孵化的 Java 个性须要加上额定的启动参数将模块裸露，这里是--add-modules jdk.incubator.vector，须要在 javac 编译和 java 运行都加上这些参数，应用 IDEA 即：

测试后果：

Benchmark               Mode  Cnt         Score         Error  Units
VectorTest.testScalar  thrpt   10   7380697.998 ± 1018277.914  ops/s
VectorTest.testVector  thrpt   10  37151609.182 ± 1011336.900  ops/s

其余应用，请参考：fizzbuzz-simd-style，这是一篇比拟有意思的文章（尽管这个性能优化感觉不只因为 SIMD，还有算法优化的功绩，哈哈）

Foreign Linker API

相干 JEP：

• JEP 389: Foreign Linker API (Incubator)
• JEP 412: Foreign Function & Memory API (Incubator)：在 Java 17 中，和 Foreign Linker API 整合到了一起
• JEP 419: Foreign Function & Memory API (Second Incubator)：位于 Java 18 中

通过这个 API，咱们能够应用纯 Java 代码来调用零碎的库，例如应用 Java 代码弹出一个 Windows 提示框：

以上例子来自于 https://headcrashing.wordpres…，感兴趣的能够查看下

Foreign-Memory Access API

• JEP 370: Foreign-Memory Access API (Incubator)
• JEP 383: Foreign-Memory Access API (Second Incubator)
• JEP 393: Foreign-Memory Access API (Third Incubator)
• JEP 412: Foreign Function & Memory API (Incubator)：在 Java 17 中，和 Foreign Linker API 整合到了一起
• JEP 419: Foreign Function & Memory API (Second Incubator)：位于 Java 18 中

很多风行的高性能 Java 框架和中间件应用了堆外内存，然而目前 Java 中操作堆外内存的 API 不够欠缺：

• ByteBuffer API 能够提供间接内存的拜访 (DirectBuffer 还有 MMAP Buffer)，然而大小受限（2 GB，起因因为 Buffer classes limited by 32-bit addressing），并且有很多问题遗留了很多年未能解决，例如：MappedByteBuffer.release()/close() to release system resources，Please make DirectByteBuffer performance enhancements, Add absolute bulk put and get methods
• Unsafe API：性能很高，能够被 JIT 优化，然而没有限度内存拜访，哪一块内存都能拜访，如果拜访到一块曾经开释的内存，就会导致 JVM 解体。
• JNI 调用：性能较差，因为无奈被 JIT 优化（例如办法内联）

如果这些 API 开发实现，应用 Java 操作内存将更加容易了解和高效

Java 16 – JDK Flight Recorder

JFR 是我最喜爱的 Java 个性性能，我针对 JFR 写了很多篇文章，应用 JFR 定位过很多性能瓶颈以及线上问题，请参考以下系列或者文章：

• JFR 全解系列
• JFR 导致的雪崩问题定位与解决
• JFR 定位因为 SSL 导致 CPU Load 飚高的问题
• 一次鞭辟入里的 Log4j2 日志输入阻塞问题的定位
• spring-data-redis 上百万的 QPS 压力太大连贯失败，我 TM 人傻了

Java 16 中，针对 JFR，在 Java 14 引入的 JFR Stream 的根底上，减少了通过 JMX 裸露的 JFR Stream。原来咱们只能外部生产解决 JFR Event，当初能够通过 JMX 近程生产 JFR Event：JDK-8253898: JFR: Remote Recording Stream

Java 16 – jpackage

相干 JEP：

• 已废除 JEP 311: Java Packager API & CLI
• JEP 343: Packaging Tool (Incubator)
• JEP 392: Packaging Tool

这个是将 Java 程序打包成可安装包的工具，目前反对的操作系统以及格局包含：

• Linux: deb and rpm
• macOS: pkg and dmg
• Windows: msi and exe

能够参考这个文章试用下：Building Self-Contained, Installable Java Applications with JEP 343: Packaging Tool

Java 16 – Performance

性能相干的更新有很多

Hotspot 实现 Elastic Metaspace

相干 JEP：Elastic Metaspace

原来的元空间实现中，每个类加载器占用一个独自的元空间形象，当类加载器被回收后，这块内存被开释然而不会退还给零碎而是持续给其余类加载器复用，元空间的零碎内存占用只会始终增大不会放大，也就是不会将内存退还给零碎。当初优化了这一点，能够动静伸缩元空间。这块的具体源码剖析，我会在之后出一期相似于 全网最硬核 TLAB 解析 的文章解析这块。

G1 和 Parallel GC 优化

如果想具体理解这块的优化，能够参考这篇文章：JDK 16 G1/Parallel GC changes

ZGC 优化

相干 JEP：

• JEP 376: ZGC: Concurrent Thread-Stack Processing

ZGC 原本曾经根本将 GC 每个阶段都做成并发的了，GC 根扫描还是须要 STW。这个 JEP 优化了 GC 根扫描中的线程栈扫描，让这个扫描也能够“半并行化”了。这块我也会在日后进行具体的剖析。

Shenandoah GC 优化

• Shenandoah: should not block pacing reporters
• Shenandoah: reconsider free budget slice for marking
• Shenandoah: pacer should wait on lock instead of exponential backoff
• Shenandoah: support manageable SoftMaxHeapSize option
• Shenandoah: Concurrent weak reference processing
• Shenandoah: “adaptive” heuristic is prone to missing load spikes

Java 16 – Security

对于安全性相干的优化，请参考：JDK 16 Security Enhancements

Java 16 – Deprecations/Limitations

Primitive Wrapper Warnings

相干 JEP：

• JEP 390: Warnings for Value-Based Classes

这是一个令人激动的更新，是为了我期待已久的 Project Valhala 做铺垫的（对，就是我之前把 Record 误会了的那个）。

目前，原始类型的封装类型类（例如 Integer）的结构器标记为了过期，并且会在未来的版本被移除，用他们外面的静态方法 valueOf() 代替。

我独自写了一篇文章来剖析这个，参考：JEP 解读与尝鲜系列 4 – Java 16 中对于 Project Valhalla 的铺垫

Strong Encapsulation By Default

相干 JEP：

• JEP 396: Strongly Encapsulate JDK Internals by Default
• JEP 403: Strongly Encapsulate JDK Internals：Java 17 公布的，曾经齐全去掉了 --illegal-access，如果应用，会有 OpenJDK 64-Bit Server VM warning: Ignoring option --illegal-access=warn; support was removed in 17.0 的提醒。

为了推动 Java 模块化，针对 --illegal-access 的个性进行了批改。Java 16 之前默认是 permit，遇到拜访没有凋谢的包会在第一次有提醒，然而还是能够失常运行：

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by j9ms.internal.Nimbus
    (file:...) to constructor NimbusLookAndFeel()
WARNING: Please consider reporting this
    to the maintainers of j9ms.internal.Nimbus
WARNING: Use --illegal-access=warn to enable warnings
    of further illegal reflective access operations
WARNING: All illegal access operations will be denied
    in a future release

Java 16 则是 deny。即默认禁止非法包拜访，用户能够通过启动参数 --illegal-access=permit 批改。Java 17 则是移除了这个参数，加上这个启动参数也有效了，会有提醒并且反射拜访外部未裸露的包会报错，例如：

var dc = ClassLoader.class.getDeclaredMethod("defineClass",
        String.class,
        byte[].class,
        int.class,
        int.class);
dc.setAccessible(true);

应用启动参数--illegal-access=warn 运行：

OpenJDK 64-Bit Server VM warning: Ignoring option --illegal-access=warn; support was removed in 17.0
Exception in thread "main" java.lang.reflect.InaccessibleObjectException: Unable to make protected final java.lang.Class java.lang.ClassLoader.defineClass(java.lang.String,byte[],int,int) throws java.lang.ClassFormatError accessible: module java.base does not "opens java.lang" to unnamed module @378bf509
    at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:354)
    at java.base/java.lang.reflect.AccessibleObject.checkCanSetAccessible(AccessibleObject.java:297)
    at java.base/java.lang.reflect.Method.checkCanSetAccessible(Method.java:199)
    at java.base/java.lang.reflect.Method.setAccessible(Method.java:193)

然而，通过启动参数 --add-opens java.base/java.lang=ALL-UNNAMED 还是能够突破封包管制.