Inside Java Newscast #1 深度解读

本文是 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 地址:

Records 这个特性我仔细研究过实现:参考我写的另一篇文章Java Record 的一些思考 - 默认方法使用以及基于预编译生成相关字节码的底层实

简单说来其实就是(编译后查看下字节码就能看出来),在编译后,根据 Record 源码插入相关域与方法的字节码,包括:

  1. 自动生成的 private final field
  2. 自动生成的全属性构造器
  3. 自动生成的 public getter 方法
  4. 自动生成的 hashCode(),equals(),toString() 方法:
  5. 从字节码可以看出,这三个方法的底层实现是 invokeDynamic 另一个方法
  6. 调用的是 ObjectMethods.java 这个类中的 bootstrap 方法

这个还让我闹了个笑话,我以为这个是 Project Valhala 的 Inline Object 已经实现了(参考我的这个系列: JEP 尝鲜系列),还去 StackOverflow 问,这个 Record 为啥能有 wait() 方法,并且可以进行 synchronized 同步(因为如果是 Project Valhala 的 Inline Object 的话是没有普通类的对象头的,没法用普通类对象的方法实现同步),结果。。。。。最后还是 Goetz 大佬一眼就看出我是误会了

image

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 地址:

类型模式匹配一直是一个呼声很高的特性,如果和下一小节的 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 如下:

在某些情况下,我们可能想枚举一个接口的所有实现类,例如:

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,可以通过下面这个链接查看:

路径中的两个版本就是要对比的两个版本,其界面如下:

image

同时,我们也可以通过 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 补充,参考:

Java 16 – Unix Domain Sockets

相关 JEP:

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/java/javase/16/core/internet-protocol-and-unix-domain-sockets-nio-example.html

相比于 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:

其中最主要的应用就是使用了 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 即:

image

image

测试结果:

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:

通过这个 API,我们可以使用纯 Java 代码来调用系统的库,例如使用 Java 代码弹出一个 Windows 提示框:
image

以上例子来自于 https://headcrashing.wordpress.com/2021/02/06/spare-keystrokes-with-the-record-keyword-modern-java-jdk-16-head-crashing-informatics-26-2/ ,感兴趣的可以查看下

Foreign-Memory Access API

很多流行的高性能 Java 框架和中间件使用了堆外内存,但是目前 Java 中操作堆外内存的 API 不够完善:

如果这些 API 开发完成,使用 Java 操作内存将更加容易理解和高效

Java 16 – JDK Flight Recorder

JFR 是我最喜欢的 Java 特性功能,我针对 JFR 写了很多篇文章,使用 JFR 定位过很多性能瓶颈以及线上问题,请参考以下系列或者文章:

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:

这个是将 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:

ZGC 本来已经基本将 GC 每个阶段都做成并发的了,GC 根扫描还是需要 STW。这个 JEP 优化了 GC 根扫描中的线程栈扫描,让这个扫描也可以 “半并行化” 了。这块我也会在日后进行详细的分析。

Shenandoah GC 优化

Java 16 – Security

关于安全性相关的优化,请参考:JDK 16 Security Enhancements

Java 16 – Deprecations/Limitations

Primitive Wrapper Warnings

相关 JEP:

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

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

我单独写了一篇文章来分析这个,参考:JEP解读与尝鲜系列4 - Java 16 中对于 Project Valhalla 的铺垫

Strong Encapsulation By Default

相关 JEP:

为了推进 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 还是可以打破封包控制.

posted @ 2022-01-07 10:31  干货满满张哈希  阅读(176)  评论(0编辑  收藏  举报