synchronized优化

public class EscapeAnalysisDemo {
 
    // ========== 案例 1：无逃逸 (NoEscape) ==========
    public String concatNoEscape(String s1, String s2) {
        // sb 在方法内部创建
        StringBuffer sb = new StringBuffer();
        // sb.append() 虽然内部用了 synchronized，但 sb 不会逃逸
        sb.append(s1);    // synchronized(this) -> this 就是 sb
        sb.append(s2);    // synchronized(this) -> this 就是 sb
        // toString() 返回的是一个新的 String 对象，sb 本身没有被返回
        return sb.toString();
        // 方法结束后，sb 的生命周期终结，没有任何外部引用指向它
        // ✅ 逃逸分析结论：sb 是 NoEscape -> 锁可以被消除
    }
 
    // ========== 案例 2：全局逃逸 (GlobalEscape) ==========
    private StringBuffer sharedBuffer; // 实例字段，存储在堆上
 
    public void concatGlobalEscape(String s1, String s2) {
        // sb 在方法内部创建
        StringBuffer sb = new StringBuffer();
        sb.append(s1);
        sb.append(s2);
        // ❌ 关键：sb 的引用被赋值给了实例字段
        this.sharedBuffer = sb;
        // 其他线程可能通过 this.sharedBuffer 访问到 sb
        // ❌ 逃逸分析结论：sb 是 GlobalEscape -> 锁不能被消除
    }
 
    // ========== 案例 3：参数逃逸 (ArgEscape) ==========
    public void concatArgEscape(String s1, String s2) {
        StringBuffer sb = new StringBuffer();
        sb.append(s1);
        sb.append(s2);
        // sb 作为参数传递给 print 方法
        // 如果 JIT 能内联 print() 并确认其中不会逃逸，也可能优化
        // 但通常保守处理，不做锁消除
        print(sb); // ⚠️ ArgEscape
    }
 
    private void print(StringBuffer sb) {
        System.out.println(sb.toString());
    }
}

// StringBuffer.append() 的简化版本（JDK 源码）
@Override
public synchronized StringBuffer append(String str) { // ← 注意 synchronized
    toStringCache = null;
    super.append(str);  // 调用 AbstractStringBuilder.append()
    return this;
}

public class LockEliminationCase1 {
 
    /**
     * 这个方法在逻辑上不涉及多线程共享。
     * StringBuffer 的每次 append 都包含 synchronized，
     * 但 JIT 会通过逃逸分析 + 锁消除将其优化掉。
     */
    public String buildGreeting(String name, int age) {
        // sb 是方法局部变量，在栈帧上分配引用
        StringBuffer sb = new StringBuffer();      // new 对象，逃逸分析的目标
 
        sb.append("Hello, ");                      // synchronized(sb) -> 锁消除目标
        sb.append(name);                           // synchronized(sb) -> 锁消除目标
        sb.append("! You are ");                   // synchronized(sb) -> 锁消除目标
        sb.append(age);                            // synchronized(sb) -> 锁消除目标
        sb.append(" years old.");                  // synchronized(sb) -> 锁消除目标
 
        return sb.toString();                      // 返回新 String，sb 本身不逃逸
        // 方法结束，sb 无任何外部引用 -> NoEscape -> 5 次锁操作全部消除
    }
}

// JIT 优化后的等效伪代码（实际是机器码层面）
public String buildGreeting(String name, int age) {
    // 锁已被完全移除，甚至 StringBuffer 可能被标量替换
    char[] value = new char[initialCapacity];
    int count = 0;
    // 直接操作底层数组，无任何 synchronized
    // ... append 逻辑内联展开 ...
    return new String(value, 0, count);
}

public class LockEliminationCase2 {
 
    /**
     * 统计字符串中每个字符的出现次数。
     * 使用了 Hashtable（所有方法都是 synchronized），
     * 但由于 map 不逃逸，所有锁都会被消除。
     */
    public int countUniqueChars(String text) {
        // map 是局部变量，不会逃逸出此方法
        Hashtable<Character, Integer> map = new Hashtable<>();  // NoEscape 对象
 
        for (int i = 0; i < text.length(); i++) {             // 遍历字符串
            char c = text.charAt(i);                           // 取出当前字符
            // Hashtable.containsKey() 是 synchronized 方法 -> 锁消除
            // Hashtable.get() 是 synchronized 方法 -> 锁消除
            // Hashtable.put() 是 synchronized 方法 -> 锁消除
            Integer count = map.get(c);                        // synchronized -> 消除
            if (count == null) {                               // 首次出现
                map.put(c, 1);                                 // synchronized -> 消除
            } else {
                map.put(c, count + 1);                         // synchronized -> 消除
            }
        }
 
        return map.size();                                     // synchronized -> 消除
        // map 从未赋给字段、从未返回、从未传给其他线程
        // ✅ 逃逸分析: NoEscape -> 循环中所有锁操作全部消除
    }
}

public class LockEliminationCase3 {
 
    /**
     * 看似简单的方法，但如果使用了某些内部带锁的 API，
     * JIT 仍然可以通过锁消除来避免性能损失。
     */
    public String formatResult(double value) {
        // StringBuffer 在 JDK 早期版本中用于 String.format 内部实现
        // 即使开发者没有直接写 synchronized，间接调用链中也可能存在
        StringBuffer sb = new StringBuffer();               // 局部对象
        sb.append("Result: ");                              // synchronized -> 消除
        sb.append(String.valueOf(value));                   // synchronized -> 消除
        return sb.toString();                               // sb 不逃逸
    }
}

// ========== 性能对比基准测试（JMH 风格伪代码）==========
 
// 测试 1：锁消除开启（默认）
// JVM 参数：-XX:+DoEscapeAnalysis -XX:+EliminateLocks
@Benchmark
public String withLockElimination() {
    StringBuffer sb = new StringBuffer();   // NoEscape -> 锁被消除
    sb.append("Hello");                     // 无 monitorenter/monitorexit
    sb.append(" World");                    // 无 monitorenter/monitorexit
    return sb.toString();
    // 典型结果：~15 ns/op
}
 
// 测试 2：锁消除关闭
// JVM 参数：-XX:+DoEscapeAnalysis -XX:-EliminateLocks
@Benchmark
public String withoutLockElimination() {
    StringBuffer sb = new StringBuffer();   // 仍然 NoEscape，但锁不消除
    sb.append("Hello");                     // 执行 monitorenter/monitorexit
    sb.append(" World");                    // 执行 monitorenter/monitorexit
    return sb.toString();
    // 典型结果：~50 ns/op（约 3 倍慢）
}

# 1. 打印 JIT 编译日志，观察哪些方法被编译
java -XX:+UnlockDiagnosticVMOptions \
     -XX:+PrintCompilation \
     -XX:+PrintInlining \
     -XX:+TraceClassLoading \
     YourMainClass
 
# 2. 对比开启/关闭锁消除的性能差异
# 开启（默认）
java -XX:+DoEscapeAnalysis -XX:+EliminateLocks YourBenchmark
 
# 关闭锁消除
java -XX:+DoEscapeAnalysis -XX:-EliminateLocks YourBenchmark
 
# 关闭逃逸分析（锁消除也会随之失效）
java -XX:-DoEscapeAnalysis YourBenchmark
 
# 3. 使用 JITWatch 可视化工具分析 JIT 编译日志
# 需要先生成日志：
java -XX:+UnlockDiagnosticVMOptions \
     -XX:+LogCompilation \
     -XX:LogFile=jit.log \
     YourMainClass
# 然后用 JITWatch 打开 jit.log 进行图形化分析

public class QuizService {
    private List<String> resultCache = new ArrayList<>();
 
    public void processRequest(String input) {
        Vector<String> tempList = new Vector<>();    // Vector 的 add 方法是 synchronized
        tempList.add(input);
        tempList.add(input.toUpperCase());
        tempList.add(input.toLowerCase());
 
        resultCache.addAll(tempList);   // 将 tempList 传递给 resultCache
    }
}

public class LockCoarseningBasic {
 
    private final Object lock = new Object(); // 同一把锁对象
    private int count = 0;                     // 共享计数器
    private String lastOp = "";                // 最后操作记录
 
    /**
     * 原始写法：三个紧密相邻的 synchronized 块
     * 每个块都锁同一个对象 lock
     */
    public void fragmentedSync() {
        // -------- 第一个同步块 --------
        synchronized (lock) {           // 第 1 次加锁（monitorenter）
            count++;                    // 临界区操作：计数器自增
        }                               // 第 1 次解锁（monitorexit）
 
        // 中间仅有一个简单的局部变量赋值，无副作用
        int temp = count;               // 非同步区域的轻量操作
 
        // -------- 第二个同步块 --------
        synchronized (lock) {           // 第 2 次加锁（monitorenter）
            count += temp;              // 临界区操作：累加
        }                               // 第 2 次解锁（monitorexit）
 
        // -------- 第三个同步块 --------
        synchronized (lock) {           // 第 3 次加锁（monitorenter）
            lastOp = "fragmentedSync";  // 临界区操作：记录操作名
        }                               // 第 3 次解锁（monitorexit）
    }
 
    /**
     * JIT 锁粗化后的等价代码（概念演示，非真实反编译）
     * 三个同步块被合并为一个
     */
    public void coarsenedSync() {
        synchronized (lock) {           // 仅 1 次加锁（monitorenter）
            count++;                    // 原第一个同步块的操作
            int temp = count;           // 原来夹在中间的局部变量赋值，被纳入同步块
            count += temp;              // 原第二个同步块的操作
            lastOp = "coarsenedSync";   // 原第三个同步块的操作
        }                               // 仅 1 次解锁（monitorexit）
    }
}

public class LoopLockCoarsening {
 
    private final StringBuilder sb = new StringBuilder(); // 共享可变对象
 
    /**
     * 原始写法：循环内每次迭代都加锁解锁
     * 假设此方法只被单线程或受控方式调用
     */
    public String buildReport(String[] items) {
        for (int i = 0; i < items.length; i++) {     // 遍历所有条目
            synchronized (sb) {                       // 每次迭代：加锁
                sb.append("[").append(i).append("] "); // 拼接序号
                sb.append(items[i]);                   // 拼接内容
                sb.append("\n");                        // 换行
            }                                          // 每次迭代：解锁
        }
        return sb.toString();                          // 返回最终结果
    }
 
    /**
     * JIT 锁粗化后的等价代码（概念演示）
     * 锁被提升到循环外部
     */
    public String buildReportCoarsened(String[] items) {
        synchronized (sb) {                            // 仅加锁 1 次
            for (int i = 0; i < items.length; i++) {   // 循环体完全在同步块内
                sb.append("[").append(i).append("] ");  // 拼接序号
                sb.append(items[i]);                    // 拼接内容
                sb.append("\n");                         // 换行
            }
        }                                              // 仅解锁 1 次
        return sb.toString();                           // 返回最终结果
    }
}

public class CoarseningBenchmarkDemo {
 
    private final Object monitor = new Object();  // 锁对象
    private long value = 0;                         // 共享变量
 
    /**
     * 未粗化版本：5 个相邻同步块
     * 每个块只做一次简单运算
     */
    public void fineGrained() {
        synchronized (monitor) {  // 第 1 次 enter/exit
            value += 1;           // 简单加法
        }
        synchronized (monitor) {  // 第 2 次 enter/exit
            value += 2;           // 简单加法
        }
        synchronized (monitor) {  // 第 3 次 enter/exit
            value += 3;           // 简单加法
        }
        synchronized (monitor) {  // 第 4 次 enter/exit
            value += 4;           // 简单加法
        }
        synchronized (monitor) {  // 第 5 次 enter/exit
            value += 5;           // 简单加法
        }
    }
 
    /**
     * 粗化后等价版本：1 个同步块
     */
    public void coarsened() {
        synchronized (monitor) {  // 仅 1 次 enter/exit
            value += 1;           // 合并后的连续操作
            value += 2;
            value += 3;
            value += 4;
            value += 5;
        }
    }
}

public class BadCoarseningExample {
 
    private final Object lock = new Object();  // 锁对象
    private int counter = 0;                    // 共享计数器
 
    /**
     * 不应被粗化的场景：同步块之间有耗时操作
     */
    public void shouldNotCoarsen() throws Exception {
        synchronized (lock) {            // 同步块 1
            counter++;                   // 快速操作
        }
 
        // ⚠️ 中间有一个耗时的网络调用
        // 如果把这段代码也纳入同步块，其他线程将被长时间阻塞
        Thread.sleep(1000);              // 模拟耗时 I/O 操作（1 秒）
 
        synchronized (lock) {            // 同步块 2
            counter--;                   // 快速操作
        }
    }
 
    /**
     * 不应被粗化的场景：锁对象不同
     */
    private final Object lockA = new Object();  // 锁对象 A
    private final Object lockB = new Object();  // 锁对象 B
 
    public void differentLocks() {
        synchronized (lockA) {           // 锁对象是 lockA
            counter++;
        }
        synchronized (lockB) {           // 锁对象是 lockB —— 不同对象，无法合并
            counter--;
        }
    }
}

// 锁粗化默认开启，可通过以下参数关闭（一般不建议关闭）
// -XX:-EliminateLocks       关闭锁消除（同时会影响锁粗化的部分路径）
// -XX:-DoEscapeAnalysis     关闭逃逸分析（锁消除依赖此分析，锁粗化不强依赖）
 
// 查看 JIT 编译器的锁优化日志：
// -XX:+PrintEliminateLocks  打印锁消除和锁粗化的详细信息
// -XX:+UnlockDiagnosticVMOptions  解锁诊断参数（部分参数需要先开启此选项）
 
// 实际运行命令示例：
// java -XX:+UnlockDiagnosticVMOptions -XX:+PrintEliminateLocks MyApp

public class StringBufferCoarsening {
 
    /**
     * StringBuffer 的连续 append 是锁粗化的经典场景
     * 每个 append 方法都有 synchronized 修饰
     */
    public String classicExample(String name, int age) {
        StringBuffer sb = new StringBuffer();  // 创建 StringBuffer（线程安全）
        sb.append("Name: ");                   // synchronized append #1
        sb.append(name);                       // synchronized append #2
        sb.append(", Age: ");                  // synchronized append #3
        sb.append(age);                        // synchronized append #4
        return sb.toString();                  // 返回拼接结果
        // JIT 会将 4 次 synchronized append 粗化为 1 次 synchronized 块
        // 但更好的做法：如果确认单线程，直接使用 StringBuilder
    }
}

public class Quiz {
    private final Object lock = new Object();
    private final Object lock2 = new Object();
    private int x = 0;
 
    public void methodA() {
        synchronized (lock)  { x++; }
        synchronized (lock2) { x--; }  // 注意：不同的锁对象
    }
 
    public void methodB() {
        synchronized (lock) { x++; }
        doHeavyIO();                    // 耗时 I/O 操作
        synchronized (lock) { x--; }
    }
 
    public void methodC() {
        synchronized (lock) { x = 1; }
        int temp = x * 2;              // 轻量局部计算
        synchronized (lock) { x = temp; }
    }
 
    public void methodD() {
        synchronized (lock) { x++; }
        synchronized (lock) { x--; }
        synchronized (lock) { x += 10; }
    }
}

// 连续同步块，锁对象相同 —— JIT 会合并
synchronized (lock) { doA(); }  // 第一段
// 中间可能有少量无副作用的非同步代码
synchronized (lock) { doB(); }  // 第二段
// 合并后等价于：
// synchronized (lock) { doA(); /* gap code */ doB(); }

// 循环体内的同步块 —— JIT 通常不会将锁提到循环外
for (int i = 0; i < 10000; i++) {
    synchronized (lock) {   // 不会粗化为循环外的单次锁
        list.add(i);        // 因为这会让锁持有时间从微秒级变成毫秒级
    }                       // 严重阻塞其他线程
}

public String concat(String a, String b) {
    StringBuffer sb = new StringBuffer();  // StringBuffer 内部方法均为 synchronized
    sb.append(a);
    sb.append(b);
    return sb.toString();
}