一文揭秘Java多线程下的JIT编译陷阱与解决

public class TradeProcessor {
    private final Lock lock = new ReentrantLock();
    
    public void executeTrade(Trade trade) {
        lock.lock();
        try {
            // 交易处理逻辑
            process(trade);
        } finally {
            lock.unlock(); // 此处抛出异常
        }
    }
}

public class JitOptimizationPuzzle {
    private boolean running = true;
    private int counter = 0;
    
    public static void main(String[] args) throws Exception {
        JitOptimizationPuzzle puzzle = new JitOptimizationPuzzle();
        Thread worker = new Thread(puzzle::work);
        worker.start();
        
        Thread.sleep(1000); // 确保worker线程启动
        puzzle.shutdown();
        worker.join();
    }
    
    void work() {
        while (running) {
            // 空循环体
        }
        System.out.println("Worker stopped. Counter: " + counter);
    }
    
    void shutdown() {
        running = false;
    }
}

// 初始编译
 234  5    3       JitOptimizationPuzzle::work (9 bytes)
// 优化后编译
 567  6    3       JitOptimizationPuzzle::work (9 bytes)   made not entrant

void work() {
    if (!running) return; // 仅检查一次
    while (true);         // 无限循环！
}

// 优化前的机器码
0x01: mov    0x10(%rsi), %eax   // 读取running字段
0x04: test   %eax, %eax
0x06: jne    0x01               // 跳回循环开始

// 优化后的机器码
0x01: mov    0x10(%rsi), %eax   // 只读一次
0x04: test   %eax, %eax
0x06: jne    LOOP_END           // 直接跳过检查
LOOP_INF:
0x08: jmp    LOOP_INF           // 无限循环

- private boolean running = true;
+ private volatile boolean running = true;

void work() {
    while (running) {
        Thread.onSpinWait();
    }
}

void work() {
    while (running) {
        // 阻止JIT优化
        if (counter == Integer.MIN_VALUE) break; // 永不发生
    }
}

private static final VarHandle RUNNING_HANDLE;

void work() {
    while ((boolean) RUNNING_HANDLE.getVolatile(this)) {
        // 精确控制屏障位置
        RUNNING_HANDLE.loadLoadFence();
    }
}

-XX:+DoEscapeAnalysis       # 启用逃逸分析（推荐）
-XX:-OptimizeStringConcat   # 禁止字符串优化 
-XX:+IgnoreSpinCount        # 忽略自旋计数

-XX:CompileThreshold=100000 # 提高编译阈值
-XX:TieredStopAtLevel=3     # 停在C1编译级别

while (pending.compareAndSet(true, false)) {
    // 伪代码：双重检查+内存屏障
    if (hasPendingCommands()) {
        Thread.onSpinWait();
        continue;
    }
    UNSAFE.loadFence();
    break;
}

@JCStressTest
@Outcome(id = "0", expect = ACCEPTABLE)
@State
public class JitConsistencyTest {
    private boolean flag = true;
    private int value;

    @Actor
    public void writer() {
        value = 42;
        flag = false;
    }

    @Actor
    public void reader(I_Result r) {
        while (flag); // 被优化的循环
        r.r1 = value; // 可能看到0
    }
}

# 查看编译结果
jcmd <pid> Compiler.queue

# 输出汇编代码
java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly TestClass

lock.lock();
try {
    trade.execute();
    if (LOG.isDebugEnabled()) {  // JIT移除了整个块
        LOG.debug("Trade executed: " + trade); 
    }
} finally {
    lock.unlock();  // 此时锁状态损坏!
}