Java 性能优化实战：从 JIT/AOT 到 GraalVM 原生镜像

public class JITCompilerType {
    public static void main(String[] args) {
        String jvmName = System.getProperty("java.vm.name");
        System.out.println("JVM: " + jvmName);
        if (jvmName.contains("Client")) {
            System.out.println("使用 C1 编译器");
        } else if (jvmName.contains("Server")) {
            System.out.println("使用 C2 编译器");
        }
    }
}

java -XX:+TieredCompilation MyApp      # 启用分层编译（默认）
java -XX:+PrintCompilation MyApp       # 打印编译事件
java -XX:CICompilerCount=4 MyApp     # 指定 C2 编译线程数

public class JITCompilationDemo {
    public static int calculate(int x) {
        int sum = 0;
        for (int i = 0; i < x; i++) sum += i;
        return sum;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) calculate(100); // 预热

        long start = System.nanoTime();
        for (int i = 0; i < 1000000; i++) calculate(100);
        long end = System.nanoTime();
        System.out.println("耗时: " + (end - start) / 1_000_000 + " ms");
    }
}

# JDK 9-15 的 jaotc 使用
jaotc --output libApp.so --jar MyApp.jar
java -XX:AOTLibrary=./libApp.so MyApp

# JDK 11+ 启用 Graal JIT 替代 C2
java -XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler MyApp

export GRAALVM_HOME=/path/to/graalvm-ce-java17
export PATH=$GRAALVM_HOME/bin:$PATH
java -version
native-image --version

native-image -cp myapp.jar com.example.MainClass
native-image --verbose -cp myapp.jar -o myapp com.example.MainClass

// META-INF/native-image/reflect-config.json
[{
  "name": "com.example.ConfigService",
  "allDeclaredConstructors": true,
  "allDeclaredMethods": true,
  "methods": [{"name": "loadConfiguration", "parameterTypes": ["java.lang.String"]}]
}]

// META-INF/native-image/proxy-config.json
[["java.lang.Runnable"], ["com.example.ServiceInterface"]]

java -agentlib:native-image-agent=config-output-dir=META-INF/native-image -cp myapp.jar Main

--no-fallback                           # 禁止 fallback 模式
--initialize-at-build-time=<class>      # 构建时初始化
--initialize-at-run-time=<class>        # 运行时初始化
--gc=serial                            # GC 选择（serial/G1）
-O2                                    # 优化级别
-H:+ReportExceptionStackTraces        # 打印异常堆栈

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<build>
    <plugins>
        <plugin>
            <groupId>org.graalvm.buildtools</groupId>
            <artifactId>native-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

mvn -Pnative native:compile             # 构建 Native Image
mvn -Pnative spring-boot:build-image   # 使用 Buildpacks
./target/my-spring-app                  # 启动（约 50-200 ms）

import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.RuntimeHintsRegistrar;
import org.springframework.context.annotation.ImportRuntimeHints;

public class MyRuntimeHints implements RuntimeHintsRegistrar {
    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        hints.reflection().registerType(ConfigService.class,
            t -> t.withMethods(m -> m.getName().equals("loadConfiguration")));
        hints.resources().registerPattern("application-*.properties");
        hints.serialization().registerType(UserDto.class);
    }
}

@Configuration
@ImportRuntimeHints(MyRuntimeHints.class)
public class ApplicationConfig {}

# 查看 Java 进程
jcmd -l

# 启动 60 秒 JFR 记录
jcmd <pid> JFR.start name=myrec duration=60s filename=/tmp/recording.jfr

# 检查记录状态
jcmd <pid> JFR.check

# 停止记录
jcmd <pid> JFR.stop name=myrec

import jdk.jfr.*;

@Name("com.example.OrderProcessing")
@Label("Order Processing Event")
@Category("Business Logic")
public class OrderProcessingEvent extends Event {
    @Label("Order ID") private String orderId;
    @Label("Processing Time") private long processingTime;

    public void setOrderId(String id) { this.orderId = id; }
    public void setProcessingTime(long t) { this.processingTime = t; }
}

// 使用
OrderProcessingEvent event = new OrderProcessingEvent();
event.begin();
try {
    processOrder(orderId, amount);
} finally {
    event.end();
    event.setProcessingTime(event.getDuration().toMillis());
    event.commit();
}

# CPU 火焰图
./profiler.sh -d 30 -f /tmp/cpu.html <pid>

# 内存分配
./profiler.sh -e alloc -d 30 -f /tmp/alloc.html <pid>

# 锁竞争
./profiler.sh -e lock -d 30 -f /tmp/lock.html <pid>

# JDK 10+ AppCDS
java -XX:DumpLoadedClassList=classes.lst -cp app.jar com.example.Main
java -Xshare:dump -XX:SharedClassListFile=classes.lst \
     -XX:SharedArchiveFile=app-cds.jsa -cp app.jar
java -Xshare:on -XX:SharedArchiveFile=app-cds.jsa -cp app.jar com.example.Main

# JDK 13+ 动态归档（推荐）
java -XX:ArchiveClassesAtExit=app.jsa -cp app.jar com.example.Main
java -XX:SharedArchiveFile=app.jsa -cp app.jar com.example.Main

FROM eclipse-temurin:17-jdk AS builder
WORKDIR /app
COPY target/app.jar app.jar
RUN java -XX:ArchiveClassesAtExit=app.jsa -jar app.jar || true

FROM eclipse-temurin:17-jre
WORKDIR /app
COPY --from=builder /app/app.jar app.jar
COPY --from=builder /app/app.jsa app.jsa
ENTRYPOINT ["java", "-XX:SharedArchiveFile=app.jsa", "-jar", "app.jar"]

public class EscapeAnalysisDemo {
    static class Point {
        int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }
    }

    public static void createPoint(int x, int y) {
        Point p = new Point(x, y);  // 不逃逸，可栈上分配
        System.out.println(p.x + ", " + p.y);
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) createPoint(i, i * 2);
        System.out.println("耗时: " + (System.currentTimeMillis() - start) + " ms");
    }
}

# 禁用逃逸分析（频繁 GC）
java -Xms64m -Xmx64m -XX:-DoEscapeAnalysis EscapeAnalysisDemo
# 启用逃逸分析（无 GC 压力）
java -Xms64m -Xmx64m -XX:+DoEscapeAnalysis EscapeAnalysisDemo

-XX:MaxInlineSize=35           # 常规方法内联上限（字节码）
-XX:FreqInlineSize=325         # 频繁调用方法内联上限
-XX:+PrintInlining             # 打印内联决策

public class LockElisionDemo {
    public static void main(String[] args) {
        long start = System.nanoTime();
        for (int i = 0; i < 10000000; i++) {
            StringBuffer sb = new StringBuffer();  // 局部变量，不会逃逸
            sb.append("Hello").append(i).append("World");
            sb.toString();
        }
        System.out.println("耗时: " + (System.nanoTime() - start) / 1_000_000 + " ms");
    }
}

# 观察 OSR 编译（以 % 标记）
java -XX:+PrintCompilation OnStackReplacementDemo 2>&1 | grep '%'

String s1 = "hello";                    // 字面量自动入池
String s2 = new String("hello");        // 堆对象
String s3 = s2.intern();                // 返回常量池引用
System.out.println(s1 == s3);           // true

public class StringConcatenationDemo {
    // 反例：循环中使用 + 拼接（每次创建新 StringBuilder）
    public static String badConcat(int count) {
        String result = "";
        for (int i = 0; i < count; i++) result += i;
        return result;
    }

    // 正例：显式使用 StringBuilder，预分配容量
    public static String goodConcat(int count) {
        StringBuilder sb = new StringBuilder(count * 2);
        for (int i = 0; i < count; i++) sb.append(i);
        return sb.toString();
    }
}

-XX:+CompactStrings        # 启用（默认）
-XX:-CompactStrings        # 禁用（纯 UTF-16）

int expectedSize = 100;
int initialCapacity = (int) (expectedSize / 0.75f) + 1;  // ≈ 135
HashMap<String, String> map = new HashMap<>(initialCapacity);

// 反例：默认容量 10，频繁扩容
List<String> list = new ArrayList<>();

// 正例：预分配容量
List<String> list = new ArrayList<>(10000);

// 批量添加：优先使用构造器传入集合或 addAll()
List<String> copy = new ArrayList<>(source);

map.computeIfAbsent("users", k -> new ArrayList<>()).add("Alice");

ByteBuffer heap = ByteBuffer.allocate(1024);       // 堆内
ByteBuffer direct = ByteBuffer.allocateDirect(1024); // 堆外

public class ZeroCopyDemo {
    // 传统方式：4 次上下文切换 + 4 次数据拷贝
    // 零拷贝：2 次上下文切换 + 1-2 次数据拷贝

    public static void zeroCopySend(Path filePath, SocketChannel socket)
            throws Exception {
        try (FileChannel fileChannel = FileChannel.open(filePath)) {
            long position = 0;
            long count = fileChannel.size();
            while (position < count) {
                position += fileChannel.transferTo(position, count - position, socket);
            }
        }
    }
}

Selector selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));
server.configureBlocking(false);
server.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();
    Iterator<SelectionKey> it = selector.selectedKeys().iterator();
    while (it.hasNext()) {
        SelectionKey key = it.next();
        if (key.isAcceptable()) { /* 接受连接 */ }
        else if (key.isReadable()) { /* 读取数据 */ }
        it.remove();
    }
}

# 编译优化
-XX:+TieredCompilation
-XX:CICompilerCount=4
-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler

# 逃逸分析
-XX:+DoEscapeAnalysis
-XX:+EliminateAllocations
-XX:+EliminateLocks

# 字符串优化
-XX:+CompactStrings
-XX:+UseStringDeduplication

# GC 配置
-XX:+UseG1GC
-XX:+UseZGC
-XX:+UseShenandoahGC

# 启动优化
-XX:+UseAppCDS
-XX:SharedArchiveFile=app.jsa
-XX:ArchiveClassesAtExit=app.jsa

# IO 与堆外内存
-XX:MaxDirectMemorySize=512m