JIT 编译优化：逃逸分析与标量替换

public static double calculateDistance(double x1, double y1,
                                        double x2, double y2) {
    // 创建了两个 Point 对象
    Point p1 = new Point(x1, y1);
    Point p2 = new Point(x2, y2);
    return p1.distanceTo(p2);
}

// 分层编译的 5 个 Level：
Level 0  → 解释执行（Interpreter）
Level 1  → C1 编译，无 profiling
Level 2  → C1 编译，轻量 profiling（队列满时过渡）
Level 3  → C1 编译，完整 profiling（收集类型、分支信息）
Level 4  → C2 编译，利用 profiling 数据做激进优化 ← 逃逸分析在这层

// 一个方法的典型晋升路径：
解释执行 → C1(Level 3, 收集数据) → C2(Level 4, 激进优化)

// 触发编译的阈值（默认值）：
方法调用次数 ≥ 10000  → 触发 C1 编译
方法调用次数 ≥ 15000  → 触发 C2 编译（有 Level 3 的 profile 数据后）

# 查看哪些方法被编译了
java -XX:+PrintCompilation -jar app.jar

# 输出示例：
1247  345    b  3  com.example.App::calculateDistance (28 bytes)
1248  346    b  4  com.example.App::calculateDistance (28 bytes)
//       ↑         ↑
//   编译级别    Level 4 = C2 编译，逃逸分析即将生效

# 查看逃逸分析的详细日志（需要 debug 版 JVM）
java -XX:+PrintEscapeAnalysis -jar app.jar

/* ═══ 案例 A：对象逃逸 ✗ ═══ */
public Point createPoint(double x, double y) {
    Point p = new Point(x, y);
    return p;  // ← p 被返回给调用者，引用逃出方法
}               //    必须在堆上分配，无法优化

/* ═══ 案例 B：对象未逃逸 ✓ ═══ */
public static double calcDistance(double x1, double y1,
                                   double x2, double y2) {
    Point p1 = new Point(x1, y1);  // 局部变量
    Point p2 = new Point(x2, y2);  // 局部变量
    return p1.distanceTo(p2);
    // p1、p2 都没有逃出方法 → 可以做优化！
}

/* ═══ 案例 C：隐式逃逸 ✗ ═══ */
private static List<Point> cache = new ArrayList<>();

public static void processPoint(double x, double y) {
    Point p = new Point(x, y);
    cache.add(p);  // ← p 被存入静态字段（堆上），引用逃出
}

/* ═══ 案例 D：线程逃逸 ✗ ═══ */
public static void startCalc(double x, double y) {
    Point p = new Point(x, y);
    new Thread(() -> System.out.println(p)).start();
    // ← p 被另一个线程捕获，属于线程级逃逸
}

public static double sumDistances() {
    double sum = 0;
    for (int i = 0; i < 1_000_000; i++) {
        // 每次循环 new 两个 Point
        // 如果没有逃逸分析：100 万个 Point 上堆 → Young GC 频繁触发
        // 有逃逸分析：Point 在栈上分配 → 循环结束自动回收 → 零 GC
        sum += calcDistance(i, i, i + 1, i + 1);
    }
    return sum;
}

// 对比测试（JMH 基准测试）：
// -XX:-DoEscapeAnalysis  → ~120ms, 多次 Young GC
// -XX:+DoEscapeAnalysis  → ~8ms,   零 GC

/* ─── 优化前：源代码 ─── */
public static double calc(double x, double y) {
    Point p = new Point(x, y);    // 堆上分配对象
    return p.getX() + p.getY();      // 通过对象访问字段
}

/* ─── 优化后：C2 等效伪代码 ─── */
public static double calc(double x, double y) {
    double p_x = x;                  // 标量：直接存在寄存器/栈
    double p_y = y;                  // 标量：直接存在寄存器/栈
    return p_x + p_y;                // 无对象开销，纯算术运算
}

/* ─── 更复杂的例子：链式调用 ─── */
public static double complexCalc() {
    Point a = new Point(1.0, 2.0);
    Point b = new Point(3.0, 4.0);
    Point mid = new Point(              // mid 也未逃逸
        (a.getX() + b.getX()) / 2,
        (a.getY() + b.getY()) / 2
    );
    return mid.getX() * mid.getY();

    // C2 标量替换后等效：
    // double a_x = 1.0, a_y = 2.0;
    // double b_x = 3.0, b_y = 4.0;
    // double mid_x = (a_x + b_x) / 2;  // 2.0
    // double mid_y = (a_y + b_y) / 2;  // 3.0
    // return mid_x * mid_y;             // 6.0
    // → 最终优化为常量 6.0（常量折叠）
}

public static String concatString(String a, String b, String c) {
    StringBuffer sb = new StringBuffer();
    sb.append(a);
    sb.append(b);
    sb.append(c);
    return sb.toString();
}

/* StringBuffer 的 append 方法是 synchronized 的：
   public synchronized StringBuffer append(String str) { ... }

   但 sb 是局部变量，没有逃逸 → 不会有其他线程访问它
   → C2 锁消除：移除 synchronized 关键字
   → 等效于使用 StringBuilder（无锁版本）
*/

// 验证方式：
// -XX:+PrintEliminateLocks 可以看到被消除的锁
// 输出：Eliminated lock: StringBuffer::append

# 逃逸分析开关（JDK 8+ 默认开启）
-XX:+DoEscapeAnalysis

# 标量替换开关（JDK 8+ 默认开启）
-XX:+EliminateAllocations

# 锁消除开关（JDK 8+ 默认开启）
-XX:+EliminateLocks

# 查看逃逸分析结果（需要 UnlockDiagnosticVMOptions）
-XX:+UnlockDiagnosticVMOptions -XX:+PrintEscapeAnalysis

# 查看被消除的锁
-XX:+UnlockDiagnosticVMOptions -XX:+PrintEliminateLocks

# 查看标量替换详情
-XX:+UnlockDiagnosticVMOptions -XX:+PrintEliminateAllocations

/* ✓ 场景 1：紧密循环中的短生命周期对象 */
for (int i = 0; i < 10_000_000; i++) {
    BigDecimal price = new BigDecimal(i);   // 未逃逸
    BigDecimal tax = price.multiply(rate);   // 未逃逸
    total = total.add(tax);
    // 每次循环创建的 BigDecimal 都在栈上分配 → 零 GC
}

/* ✓ 场景 2：方法内联 + 逃逸分析 联合优化 */
public static double process() {
    Point p = createPoint(1.0, 2.0);  // createPoint 被内联
    return p.getX() * p.getY();
}
// 内联前：p 是 createPoint 的返回值 → 逃逸
// 内联后：p 变成 process() 的局部变量 → 未逃逸 → 标量替换！
// 方法内联是逃逸分析的"前置放大器"

/* ✗ 场景 3：复杂控制流 → 逃逸分析可能放弃 */
public static Point complexFlow(boolean flag, Map<String, Point> map) {
    Point p = new Point(1.0, 2.0);
    if (flag) {
        map.put("key", p);  // 条件分支中可能逃逸
    }
    return p.distanceTo(origin);
    // C2 分析复杂控制流成本高，可能保守地认为"已逃逸"
}