JDK 21性能优化详解
1. Generational ZGC（分代ZGC）
特性概述
Generational ZGC是JDK 21中对Z Garbage Collector的重要增强，为ZGC添加了分代收集能力。这个改进显著提高了垃圾收集的效率，特别是对于年轻对象的处理。
技术细节
Generational ZGC的核心特性：
- 分代收集：将堆内存分为年轻代和老年代
- 年轻代优化：针对短生命周期对象的快速回收
- 老年代收集：保持ZGC的低延迟特性
- 动态调整：根据应用行为动态调整代的大小
代码示例和配置
bash
# 启用分代ZGC的JVM参数
java -XX:+UseZGC -XX:+ZGenerational -Xmx4g MyApplication
# 分代ZGC相关的重要参数
-XX:+UseZGC # 启用ZGC
-XX:+ZGenerational # 启用分代收集
-Xmx<size> # 设置最大堆大小
-XX:SoftMaxHeapSize=<size> # 设置软最大堆大小
-XX:ZCollectionInterval=<seconds> # 设置收集间隔
java
// 监控分代ZGC性能的示例代码
public class GenerationalZGCMonitoring {
public static void monitorGenerationalZGC() {
// 获取内存池信息
List<MemoryPoolMXBean> memoryPools = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean pool : memoryPools) {
if (pool.getName().contains("ZHeap")) {
System.out.println("ZHeap usage: " + pool.getUsage());
}
if (pool.getName().contains("Young")) {
System.out.println("Young generation usage: " + pool.getUsage());
}
if (pool.getName().contains("Old")) {
System.out.println("Old generation usage: " + pool.getUsage());
}
}
// 获取GC信息
List<GarbageCollectorMXBean> gcs = ManagementFactory.getGarbageCollectorMXBeans();
for (GarbageCollectorMXBean gc : gcs) {
if (gc.getName().contains("ZGC")) {
System.out.println("ZGC collections: " + gc.getCollectionCount());
System.out.println("ZGC time: " + gc.getCollectionTime() + "ms");
}
}
}
// 性能测试对比
public static void performanceComparison() {
System.out.println("Starting GC performance comparison...");
// 测试传统ZGC
testGC("ZGC (Non-Generational)", "-XX:+UseZGC");
// 测试分代ZGC
testGC("ZGC (Generational)", "-XX:+UseZGC -XX:+ZGenerational");
}
private static void testGC(String gcName, String gcOption) {
try {
ProcessBuilder pb = new ProcessBuilder(
"java", gcOption, "-Xmx2g", "-cp", System.getProperty("java.class.path"),
"MemoryAllocationTest"
);
long startTime = System.currentTimeMillis();
Process process = pb.start();
process.waitFor();
long endTime = System.currentTimeMillis();
System.out.println(gcName + " test completed in " + (endTime - startTime) + "ms");
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 内存分配测试类
class MemoryAllocationTest {
public static void main(String[] args) {
List<byte[]> objects = new ArrayList<>();
long start = System.currentTimeMillis();
// 创建大量短生命周期对象（主要在年轻代）
for (int i = 0; i < 1000000; i++) {
objects.add(new byte[1024]); // 1KB对象
if (i % 100000 == 0) {
// 定期清理，模拟真实应用行为
objects.clear();
System.gc();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
long end = System.currentTimeMillis();
System.out.println("Total time: " + (end - start) + "ms");
}
}性能对比测试
java
// 分代ZGC性能测试
public class GenerationalZGCPerformanceTest {
public static void main(String[] args) {
System.out.println("Starting Generational ZGC Performance Test...");
// 测试年轻代收集效率
testYoungGenerationCollection();
// 测试整体性能
testOverallPerformance();
}
private static void testYoungGenerationCollection() {
System.out.println("\n=== Young Generation Collection Test ===");
long startTime = System.currentTimeMillis();
long youngObjects = 0;
// 创建大量短生命周期对象
for (int i = 0; i < 1000000; i++) {
// 这些对象应该主要在年轻代分配
String temp = "Object " + i + " with some data to make it larger";
youngObjects++;
// 定期清理，模拟真实应用行为
if (i % 10000 == 0) {
// 清理引用，允许GC回收
temp = null;
if (i % 100000 == 0) {
System.gc(); // 强制GC（仅用于测试）
}
}
}
long endTime = System.currentTimeMillis();
System.out.println("Created " + youngObjects + " young objects in " +
(endTime - startTime) + "ms");
}
private static void testOverallPerformance() {
System.out.println("\n=== Overall Performance Test ===");
List<Object> longLivedObjects = new ArrayList<>();
long startTime = System.currentTimeMillis();
// 创建混合生命周期的对象
for (int i = 0; i < 500000; i++) {
// 20%的对象是长生命周期的
if (i % 5 == 0) {
longLivedObjects.add(new byte[1024 * 10]); // 10KB长生命周期对象
} else {
// 80%的对象是短生命周期的
byte[] temp = new byte[1024]; // 1KB短生命周期对象
// temp会在下次循环中被覆盖，成为垃圾
}
// 模拟应用处理时间
if (i % 50000 == 0) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("Processed " + i + " objects");
}
}
long endTime = System.currentTimeMillis();
System.out.println("Mixed workload completed in " + (endTime - startTime) + "ms");
System.out.println("Long-lived objects: " + longLivedObjects.size());
}
}使用建议
-
适用场景：
- 有大量短生命周期对象的应用
- 对延迟敏感的高吞吐量应用
- 需要大堆内存支持的应用
-
配置建议：
- 堆内存建议至少4GB
- 监控年轻代和老年代的使用情况
- 根据应用特点调整SoftMaxHeapSize参数
-
注意事项：
- 分代ZGC在JDK 21中是实验性特性
- 需要充分测试后在生产环境使用
- 某些JVM参数可能不兼容
2. 虚拟线程性能优化
特性概述
虚拟线程的性能优化是JDK 21的重要改进，包括调度器优化、内存管理改进和与垃圾收集器的更好集成。
技术细节
虚拟线程性能优化的关键改进：
- 调度器优化：改进的FIFO调度器
- 内存管理：减少虚拟线程的内存占用
- GC集成：与ZGC和Shenandoah GC的更好集成
- 监控改进：增强的虚拟线程监控能力
代码示例
java
// 虚拟线程性能测试
public class VirtualThreadPerformanceTest {
public static void main(String[] args) throws InterruptedException {
System.out.println("Virtual Thread Performance Test");
// 测试大量虚拟线程的创建和执行
testVirtualThreadCreation();
// 测试虚拟线程与I/O操作的性能
testVirtualThreadIO();
// 与平台线程的性能对比
compareWithPlatformThreads();
}
private static void testVirtualThreadCreation() throws InterruptedException {
System.out.println("\n=== Virtual Thread Creation Test ===");
int threadCount = 100000;
List<Thread> threads = new ArrayList<>();
long startTime = System.currentTimeMillis();
// 创建10万个虚拟线程
for (int i = 0; i < threadCount; i++) {
final int taskId = i;
Thread vt = Thread.ofVirtual()
.name("vt-" + taskId)
.start(() -> {
// 简单的任务
if (taskId % 10000 == 0) {
System.out.println("Task " + taskId + " completed");
}
});
threads.add(vt);
}
long creationTime = System.currentTimeMillis() - startTime;
System.out.println("Created " + threadCount + " virtual threads in " +
creationTime + "ms");
// 等待所有线程完成
startTime = System.currentTimeMillis();
for (Thread thread : threads) {
thread.join();
}
long executionTime = System.currentTimeMillis() - startTime;
System.out.println("Executed " + threadCount + " virtual threads in " +
executionTime + "ms");
System.out.println("Total time: " + (creationTime + executionTime) + "ms");
}
private static void testVirtualThreadIO() throws InterruptedException {
System.out.println("\n=== Virtual Thread I/O Test ===");
int taskCount = 10000;
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
long startTime = System.currentTimeMillis();
List<CompletableFuture<Void>> futures = new ArrayList<>();
for (int i = 0; i < taskCount; i++) {
final int taskId = i;
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
try {
// 模拟I/O操作（如网络请求、数据库查询）
Thread.sleep(10);
if (taskId % 1000 == 0) {
System.out.println("I/O Task " + taskId + " completed");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, executor);
futures.add(future);
}
// 等待所有任务完成
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
long totalTime = System.currentTimeMillis() - startTime;
System.out.println("Completed " + taskCount + " I/O tasks in " + totalTime + "ms");
executor.shutdown();
}
private static void compareWithPlatformThreads() throws InterruptedException {
System.out.println("\n=== Platform vs Virtual Threads Comparison ===");
int taskCount = 10000;
// 平台线程测试
long platformStartTime = System.currentTimeMillis();
ExecutorService platformExecutor = Executors.newFixedThreadPool(200);
List<CompletableFuture<Void>> platformFutures = new ArrayList<>();
for (int i = 0; i < taskCount; i++) {
final int taskId = i;
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, platformExecutor);
platformFutures.add(future);
}
CompletableFuture.allOf(platformFutures.toArray(new CompletableFuture[0])).join();
long platformTime = System.currentTimeMillis() - platformStartTime;
platformExecutor.shutdown();
// 虚拟线程测试
long virtualStartTime = System.currentTimeMillis();
ExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();
List<CompletableFuture<Void>> virtualFutures = new ArrayList<>();
for (int i = 0; i < taskCount; i++) {
final int taskId = i;
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, virtualExecutor);
virtualFutures.add(future);
}
CompletableFuture.allOf(virtualFutures.toArray(new CompletableFuture[0])).join();
long virtualTime = System.currentTimeMillis() - virtualStartTime;
virtualExecutor.shutdown();
System.out.println("Platform threads time: " + platformTime + "ms");
System.out.println("Virtual threads time: " + virtualTime + "ms");
System.out.println("Performance improvement: " +
String.format("%.2f", (double) platformTime / virtualTime) + "x");
}
}监控和调优
java
// 虚拟线程监控
public class VirtualThreadMonitoring {
public static void monitorVirtualThreads() {
// 获取线程MXBean
ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
// 启用线程CPU时间监控
if (threadBean.isThreadCpuTimeSupported()) {
threadBean.setThreadCpuTimeEnabled(true);
}
// 监控线程数量
int totalThreads = threadBean.getThreadCount();
int peakThreads = threadBean.getPeakThreadCount();
long totalStartedThreads = threadBean.getTotalStartedThreadCount();
System.out.println("Current threads: " + totalThreads);
System.out.println("Peak threads: " + peakThreads);
System.out.println("Total started threads: " + totalStartedThreads);
// 获取线程信息
ThreadInfo[] threadInfos = threadBean.dumpAllThreads(false, false);
int virtualThreads = 0;
int platformThreads = 0;
for (ThreadInfo threadInfo : threadInfos) {
String threadName = threadInfo.getThreadName();
if (threadName != null && threadName.startsWith("virtual-")) {
virtualThreads++;
} else {
platformThreads++;
}
}
System.out.println("Virtual threads: " + virtualThreads);
System.out.println("Platform threads: " + platformThreads);
}
// 性能分析工具
public static class PerformanceAnalyzer {
private final Map<String, Long> timingData = new ConcurrentHashMap<>();
public void startTiming(String operation) {
timingData.put(operation, System.nanoTime());
}
public void endTiming(String operation) {
Long startTime = timingData.get(operation);
if (startTime != null) {
long duration = System.nanoTime() - startTime;
System.out.println(operation + " took " + duration / 1_000_000 + "ms");
timingData.remove(operation);
}
}
public void printThreadStatistics() {
ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
if (threadBean.isThreadCpuTimeSupported() && threadBean.isThreadCpuTimeEnabled()) {
long[] threadIds = threadBean.getAllThreadIds();
for (long threadId : threadIds) {
ThreadInfo threadInfo = threadBean.getThreadInfo(threadId);
if (threadInfo != null) {
long cpuTime = threadBean.getThreadCpuTime(threadId);
System.out.println("Thread " + threadInfo.getThreadName() +
" CPU time: " + cpuTime / 1_000_000 + "ms");
}
}
}
}
}
}3. JIT编译器优化
特性概述
JDK 21继续改进了JIT（Just-In-Time）编译器，包括更好的优化算法、更快的编译速度和更智能的编译决策。
技术细节
JIT编译器的主要优化：
- 逃逸分析优化：改进的对象逃逸分析
- 向量化优化：更好的自动向量化支持
- 内联优化：改进的方法内联策略
- 去优化优化：减少不必要的去优化操作
代码示例和配置
bash
# JIT编译器优化相关JVM参数
-XX:+UseCompressedOops # 使用压缩对象指针
-XX:+UseCompressedClassPointers # 使用压缩类指针
-XX:+OptimizeStringConcat # 优化字符串连接
-XX:+UseStringDeduplication # 字符串去重
-XX:CompileThreshold=1000 # 调整编译阈值
-XX:TieredStopAtLevel=4 # 启用分层编译
java
// JIT优化测试
public class JITOptimizationTest {
public static void main(String[] args) {
System.out.println("JIT Optimization Test");
// 预热JIT编译器
warmupJIT();
// 测试不同场景下的性能
testLoopOptimization();
testEscapeAnalysis();
testStringOperations();
}
private static void warmupJIT() {
System.out.println("Warming up JIT compiler...");
for (int i = 0; i < 100000; i++) {
// 执行一些计算密集型操作来预热JIT
Math.sqrt(i);
Math.log(i + 1);
}
System.out.println("JIT warmup completed");
}
private static void testLoopOptimization() {
System.out.println("\n=== Loop Optimization Test ===");
int iterations = 10000000;
// 测试简单循环
long startTime = System.nanoTime();
int sum = 0;
for (int i = 0; i < iterations; i++) {
sum += i;
}
long simpleLoopTime = System.nanoTime() - startTime;
// 测试优化后的循环
startTime = System.nanoTime();
long sum2 = 0;
for (int i = 0; i < iterations; i += 2) {
sum2 += i + (i + 1);
}
long optimizedLoopTime = System.nanoTime() - startTime;
System.out.println("Simple loop: " + simpleLoopTime / 1000 + " μs");
System.out.println("Optimized loop: " + optimizedLoopTime / 1000 + " μs");
}
private static void testEscapeAnalysis() {
System.out.println("\n=== Escape Analysis Test ===");
int iterations = 1000000;
// 测试对象逃逸分析
long startTime = System.nanoTime();
for (int i = 0; i < iterations; i++) {
// 创建局部对象，不逃逸出方法
Point p = new Point(i, i * 2);
int result = p.x + p.y;
// p对象不会逃逸，可能被栈分配
}
long escapeAnalysisTime = System.nanoTime() - startTime;
System.out.println("Escape analysis test completed in " +
escapeAnalysisTime / 1000 + " μs");
}
private static void testStringOperations() {
System.out.println("\n=== String Operations Test ===");
int iterations = 100000;
// 测试字符串连接优化
long startTime = System.nanoTime();
for (int i = 0; i < iterations; i++) {
String result = "Value: " + i + ", Square: " + (i * i);
}
long stringConcatTime = System.nanoTime() - startTime;
// 测试StringBuilder
startTime = System.nanoTime();
for (int i = 0; i < iterations; i++) {
StringBuilder sb = new StringBuilder();
sb.append("Value: ").append(i).append(", Square: ").append(i * i);
String result = sb.toString();
}
long stringBuilderTime = System.nanoTime() - startTime;
System.out.println("String concatenation: " + stringConcatTime / 1000 + " μs");
System.out.println("StringBuilder: " + stringBuilderTime / 1000 + " μs");
}
// 简单的Point类用于测试
private static class Point {
final int x, y;
Point(int x, int y) {
this.x = x;
this.y = y;
}
}
}4. 其他性能优化
内存管理优化
java
// 内存使用优化示例
public class MemoryOptimizationExample {
// 对象池模式减少GC压力
public static class ObjectPool<T> {
private final Queue<T> pool = new ConcurrentLinkedQueue<>();
private final Supplier<T> factory;
public ObjectPool(Supplier<T> factory) {
this.factory = factory;
}
public T acquire() {
T object = pool.poll();
return object != null ? object : factory.get();
}
public void release(T object) {
// 重置对象状态
pool.offer(object);
}
}
// 使用对象池
public static void demonstrateObjectPooling() {
ObjectPool<StringBuilder> stringBuilderPool =
new ObjectPool<>(() -> new StringBuilder(128));
// 使用对象池中的StringBuilder
StringBuilder sb = stringBuilderPool.acquire();
sb.append("Hello").append(" ").append("World");
String result = sb.toString();
// 清理并返回到池中
sb.setLength(0); // 重置
stringBuilderPool.release(sb);
System.out.println("Result: " + result);
}
// 内存映射文件提高I/O性能
public static void demonstrateMemoryMappedFile() {
try {
Path tempFile = Files.createTempFile("mmap", ".txt");
byte[] data = "Hello, Memory Mapped File!".getBytes();
Files.write(tempFile, data);
// 使用内存映射文件
try (RandomAccessFile file = new RandomAccessFile(tempFile.toFile(), "r");
FileChannel channel = file.getChannel()) {
MappedByteBuffer buffer = channel.map(
FileChannel.MapMode.READ_ONLY, 0, channel.size());
byte[] content = new byte[(int) channel.size()];
buffer.get(content);
System.out.println("Mapped file content: " + new String(content));
}
Files.delete(tempFile);
} catch (IOException e) {
e.printStackTrace();
}
}
}并发性能优化
java
// 并发性能优化示例
public class ConcurrencyOptimizationExample {
// 使用Striped锁减少竞争
public static class StripedLock {
private final ReentrantLock[] locks;
private final int stripes;
public StripedLock(int stripes) {
this.stripes = stripes;
this.locks = new ReentrantLock[stripes];
for (int i = 0; i < stripes; i++) {
locks[i] = new ReentrantLock();
}
}
public void lock(Object key) {
int stripe = Math.abs(key.hashCode()) % stripes;
locks[stripe].lock();
}
public void unlock(Object key) {
int stripe = Math.abs(key.hashCode()) % stripes;
locks[stripe].unlock();
}
}
// 高性能计数器
public static class HighPerformanceCounter {
private final LongAdder counter = new LongAdder();
public void increment() {
counter.increment();
}
public long getCount() {
return counter.sum();
}
}
// 无锁队列示例
public static class LockFreeQueue<T> {
private final AtomicReference<Node<T>> head;
private final AtomicReference<Node<T>> tail;
public LockFreeQueue() {
Node<T> dummy = new Node<>(null);
head = new AtomicReference<>(dummy);
tail = new AtomicReference<>(dummy);
}
public void enqueue(T item) {
Node<T> newNode = new Node<>(item);
Node<T> prevTail = tail.getAndSet(newNode);
prevTail.next = newNode;
}
public T dequeue() {
Node<T> headNode, tailNode, nextNode;
do {
headNode = head.get();
tailNode = tail.get();
nextNode = headNode.next;
if (headNode == tailNode) {
if (nextNode == null) {
return null; // 队列为空
}
tail.compareAndSet(tailNode, nextNode);
}
} while (!head.compareAndSet(headNode, nextNode));
T result = nextNode.item;
nextNode.item = null; // 避免内存泄漏
return result;
}
private static class Node<T> {
volatile T item;
volatile Node<T> next;
Node(T item) {
this.item = item;
}
}
}
}5. 性能监控和调优工具
JVM监控脚本
bash
#!/bin/bash
# JVM性能监控脚本
# 监控GC统计
jstat -gc $1 1s 10
# 监控编译统计
jstat -compiler $1
# 监控内存使用
jstat -gccapacity $1
# 生成堆转储
jmap -dump:live,format=b,file=heap_dump.hprof $1
# 生成线程转储
jstack $1 > thread_dump.txt
# 监控类加载
jstat -class $1应用性能监控
java
// 应用性能监控类
public class ApplicationPerformanceMonitor {
private final MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
public void monitorApplication() {
try {
// 监控内存使用
MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
System.out.println("Heap memory: " + heapUsage.getUsed() + "/" + heapUsage.getMax());
// 监控线程
ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
System.out.println("Thread count: " + threadBean.getThreadCount());
// 监控GC
List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
for (GarbageCollectorMXBean gcBean : gcBeans) {
System.out.println("GC " + gcBean.getName() +
": " + gcBean.getCollectionCount() +
" collections, " + gcBean.getCollectionTime() + "ms");
}
// 监控编译
CompilationMXBean compilationBean = ManagementFactory.getCompilationMXBean();
if (compilationBean != null) {
System.out.println("Compilation time: " + compilationBean.getTotalCompilationTime() + "ms");
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 性能数据收集
public static class PerformanceMetrics {
private long gcTime;
private long compilationTime;
private long memoryUsed;
private long threadCount;
// getters and setters
public long getGcTime() { return gcTime; }
public void setGcTime(long gcTime) { this.gcTime = gcTime; }
public long getCompilationTime() { return compilationTime; }
public void setCompilationTime(long compilationTime) { this.compilationTime = compilationTime; }
public long getMemoryUsed() { return memoryUsed; }
public void setMemoryUsed(long memoryUsed) { this.memoryUsed = memoryUsed; }
public long getThreadCount() { return threadCount; }
public void setThreadCount(long threadCount) { this.threadCount = threadCount; }
}
}总结
JDK 21在性能优化方面做出了重要改进：
- 垃圾收集器：分代ZGC提供了更好的垃圾收集性能
- 虚拟线程：显著提高了并发应用的性能和可扩展性
- JIT编译器：持续的编译器优化提升了应用性能
- 内存管理：改进的内存管理和对象分配策略
这些性能优化使得JDK 21成为一个更加高效、稳定的Java平台版本，特别适合对性能要求较高的企业级应用和高并发场景。