## 选择 JIT 如果：

✓ 应用长期运行（服务、守护进程）
✓ 有计算密集的热点代码
✓ 需要利用运行时信息优化
✓ 可以接受预热时间
✓ 需要动态代码加载/执行

## 选择 AOT 如果：

✓ 启动时间敏感（CLI、Serverless）
✓ 内存受限（嵌入式、移动端）
✓ 需要确定性性能（实时系统）
✓ 需要代码保护
✓ 部署环境无 JIT 支持

## 选择 AOT + JIT 混合如果：

✓ 需要快速启动又要峰值性能
✓ 可以接受 AOT 的文件大小
✓ 能够提供 Profile 数据

// 方案1: TinyCC JIT
// 轻量级 C 编译器，支持 JIT

#include <libtcc.h>

int main() {
    TCCState *s = tcc_new();
    tcc_set_output_type(s, TCC_OUTPUT_MEMORY);
    
    // 编译 C 代码
    const char *code = 
        "int compute(int n) {"
        "    int sum = 0;"
        "    for (int i = 0; i < n; i++)"
        "        sum += i * i;"
        "    return sum;"
        "}";
    
    tcc_compile_string(s, code);
    tcc_relocate(s);
    
    // 获取函数指针
    int (*compute)(int) = tcc_get_symbol(s, "compute");
    
    // 调用
    int result = compute(1000);
    printf("Result: %d\n", result);
    
    tcc_delete(s);
    return 0;
}

-- 方案2: LuaJIT (嵌入式场景的经典选择)
-- 内存占用: ~200KB (最小配置)
-- 特点: 轻量、快速、可嵌入

-- 嵌入到 C/C++ 应用
-- lua_State *L = luaL_newstate();
-- luaL_openlibs(L);
-- luaL_dostring(L, "print('Hello from Lua!')");

-- 游戏引擎中的脚本系统
local function update_entity(entity, dt)
    entity.x = entity.x + entity.vx * dt
    entity.y = entity.y + entity.vy * dt
end

-- FFI 调用底层 C 函数
local ffi = require("ffi")
ffi.cdef[[
    void draw_rect(int x, int y, int w, int h, uint32_t color);
]]

local function render(entity)
    ffi.C.draw_rect(
        math.floor(entity.x),
        math.floor(entity.y),
        entity.width,
        entity.height,
        entity.color
    )
end

// 方案3: Wren (轻量级脚本语言)
// 内存占用: ~4KB (虚拟机)
// 特点: 极轻量、类 Smalltalk 语法

// wren 代码
// class Game {
//     construct new() {
//         _entities = []
//     }
//     
//     update(dt) {
//         for (entity in _entities) {
//             entity.update(dt)
//         }
//     }
// }

// 嵌入到 C
#include "wren.h"

void main() {
    WrenVM* vm = wrenNewVM(&config);
    
    WrenInterpretResult result = wrenInterpret(vm, 
        "main", 
        "System.print(\"Hello, Wren!\")"
    );
    
    wrenFreeVM(vm);
}

// JIT Spraying 攻击概念
// 攻击者构造特殊的代码，使 JIT 生成可预测的机器码

// 防护措施:

// 1. V8 的防护
// - 代码随机化
// - 地址空间随机化 (ASLR)
// - 代码页不可执行 (W^X)

// 2. 应用层防护
// - 不要执行不可信的代码
// - 使用 Content Security Policy (CSP)
// - 限制 eval() 和 Function() 的使用

// 3. 输入验证
function sanitizeExpression(expr) {
    // 白名单验证
    const allowed = /^[\d\s+\-*/().]+$/;
    if (!allowed.test(expr)) {
        throw new Error('Invalid expression');
    }
    return expr;
}

// Java 安全实践

// 1. 限制动态代码执行
SecurityManager sm = new SecurityManager();
System.setSecurityManager(sm);

// 2. 使用受限的类加载器
public class SandboxClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 只允许加载特定包的类
        if (!name.startsWith("com.example.sandbox.")) {
            throw new SecurityException("Class not allowed: " + name);
        }
        return super.findClass(name);
    }
}

// 3. GraalVM 沙箱
Context context = Context.newBuilder("js")
    .allowAllAccess(false)        // 禁止所有访问
    .allowIO(false)               // 禁止 I/O
    .allowNativeAccess(false)     // 禁止原生访问
    .allowPolyglotAccess(false)   // 禁止多语言访问
    .build();

// 动态代码执行安全

// ❌ 不安全的 eval
const userInput = req.body.expression;
const result = eval(userInput);  // 危险！

// ✅ 安全的表达式求值
const { create, all } = require('mathjs');
const math = create(all, {
    // 限制可用函数
    restrictDefaults: true
});

const result = math.evaluate(userInput, scope);

// ✅ 使用沙箱 VM
const { VM } = require('vm2');
const vm = new VM({
    timeout: 1000,  // 1秒超时
    sandbox: {}     // 限制上下文
});

const result = vm.run(userInput);

// ✅ 使用 WebAssembly 沙箱
const wasmModule = await WebAssembly.compile(untrustedCode);
const instance = await WebAssembly.instantiate(wasmModule, {
    env: { memory: new WebAssembly.Memory({ initial: 1 }) }
});

# Java 安全配置
# 1. 限制反射
--add-opens java.base/java.lang=ALL-UNNAMED

# 2. 禁用不安全的 API
-Djdk.attach.allowAttachSelf=false

# 3. 使用 Security Manager
-Djava.security.manager
-Djava.security.policy=security.policy

# V8/Node.js 安全配置
# 1. 禁用危险标志
node --disallow-code-generation-from-strings app.js

# 2. 使用沙箱
node --experimental-permission --allow-fs-read=* app.js

# Java JIT 调试

# 1. 查看编译日志
java -XX:+PrintCompilation MyApp

# 2. 详细编译日志 (需要 debug build)
java -XX:+UnlockDiagnosticVMOptions \
     -XX:+LogCompilation \
     -XX:LogFile=jit.log \
     MyApp

# 3. 使用 JITWatch 分析
# https://github.com/AdoptOpenJDK/jitwatch
java -jar jitwatch-ui.jar

# 4. 禁用特定方法的编译
java -XX:CompileCommand=exclude,com/example/MyClass/myMethod \
     MyApp

# 5. 强制编译特定方法
java -XX:CompileCommand=compileonly,com/example/MyClass/myMethod \
     MyApp

# V8 调试

# 1. 查看优化/去优化
node --trace-opt --trace-deopt app.js

# 2. 查看内联缓存
node --trace-ic app.js

# 3. 查看字节码
node --print-bytecode app.js

# 4. 使用 TurboFan 日志
node --trace-turbo app.js

# 5. 使用 Chrome DevTools
node --inspect app.js
# chrome://inspect

// Java 性能分析

// 1. JMH 基准测试
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@Fork(2)
public class MyBenchmark {
    
    @Benchmark
    public void testMethod() {
        // 被测试的代码
    }
}

// 2. Async Profiler
// java -agentpath:libasyncProfiler.so=start,file=profile.html \
//      -cp app.jar Main

// 3. JFR (Java Flight Recorder)
// java -XX:StartFlightRecording=duration=60s,filename=recording.jfr \
//      -cp app.jar Main

// Node.js 性能分析

// 1. CPU Profile
const inspector = require('inspector');
const session = new inspector.Session();
session.connect();

session.post('Profiler.enable', () => {
    session.post('Profiler.start', () => {
        // 运行需要分析的代码
        runCode();
        
        session.post('Profiler.stop', (err, { profile }) => {
            // 保存 profile
            fs.writeFileSync('profile.cpuprofile', 
                JSON.stringify(profile));
        });
    });
});

// 2. 使用 clinic.js
// npx clinic doctor -- node app.js
// npx clinic flame -- node app.js
// npx clinic bubbleprof -- node app.js

// 3. 使用 0x
// npx 0x app.js

## 问题1: 应用启动慢

排查步骤:
1. 测量启动时间: time java -jar app.jar
2. 检查类加载: -verbose:class
3. 检查 JIT 编译: -XX:+PrintCompilation
4. 考虑 AOT 编译

## 问题2: 性能不稳定

排查步骤:
1. 检查去优化: -XX:+TraceDeoptimization
2. 检查 GC: -verbose:gc
3. 检查 JIT 编译队列
4. 确保足够的预热时间

## 问题3: 内存占用高

排查步骤:
1. 堆转储: jmap -dump:format=b,file=heap.hprof <pid>
2. 原生内存: -XX:NativeMemoryTracking=summary
3. 代码缓存: jcmd <pid> Compiler.codecache
4. 调整 -XX:ReservedCodeCacheSize

## 问题4: JIT 编译失败

排查步骤:
1. 检查编译日志
2. 查看是否触发了去优化
3. 检查是否达到了编译阈值
4. 检查代码是否有特殊模式

# JVM 生产环境推荐配置

# 基础配置
java \
    -server \
    -XX:+UseG1GC \
    -XX:MaxGCPauseMillis=200 \
    -XX:+UseStringDeduplication \
    -XX:+UseCompressedOops \
    -XX:+TieredCompilation \
    -XX:ReservedCodeCacheSize=256m \
    -XX:MetaspaceSize=256m \
    -XX:MaxMetaspaceSize=512m \
    -Xms2g -Xmx2g \
    -jar app.jar

# 监控配置
java \
    -XX:+HeapDumpOnOutOfMemoryError \
    -XX:HeapDumpPath=/var/log/app/heapdump.hprof \
    -XX:+UseGCLogFileRotation \
    -XX:NumberOfGCLogFiles=10 \
    -XX:GCLogFileSize=100M \
    -Xlog:gc*:file=/var/log/app/gc.log \
    -XX:StartFlightRecording=settings=profile \
    -jar app.jar

// Node.js 生产配置

// package.json
{
    "scripts": {
        "start": "node --max-old-space-size=2048 --gc-interval=100 app.js",
        "start:prod": "NODE_ENV=production node --max-old-space-size=2048 app.js"
    }
}

// 内存监控
const v8 = require('v8');

setInterval(() => {
    const stats = v8.getHeapStatistics();
    const usedMB = stats.used_heap_size / 1024 / 1024;
    const totalMB = stats.total_heap_size / 1024 / 1024;
    
    if (usedMB / totalMB > 0.9) {
        console.warn('Heap usage high:', usedMB.toFixed(1), 'MB');
        if (global.gc) global.gc();
    }
}, 30000);

# Prometheus 告警规则示例
groups:
  - name: jit_alerts
    rules:
      # JIT 编译队列过长
      - alert: JITCompilationQueueHigh
        expr: jvm_jit_compilation_queue_size > 100
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "JIT compilation queue is high"
      
      # 代码缓存接近满
      - alert: CodeCacheAlmostFull
        expr: jvm_memory_used_bytes{area="codecache"} / 
              jvm_memory_max_bytes{area="codecache"} > 0.9
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Code cache is almost full"
      
      # 去优化频繁
      - alert: DeoptimizationRateHigh
        expr: rate(jvm_jit_deoptimizations_total[5m]) > 10
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High deoptimization rate"

## JIT 相关故障恢复

### 代码缓存满
症状: 编译停止，性能下降
解决: 
1. 增大 ReservedCodeCacheSize
2. 提高编译阈值减少编译量
3. 重启应用

### 去优化风暴
症状: 性能突然下降
解决:
1. 检查是否有新类加载
2. 检查是否有类型变化
3. 重启应用重新预热

### 内存泄漏 (JIT 相关)
症状: 内存持续增长
解决:
1. 检查是否有过多的动态类生成
2. 检查 Profile 数据是否泄漏
3. 调整 JIT 参数限制编译

## JIT 友好代码审查清单

### 类型一致性
- [ ] 对象形状是否一致？
- [ ] 函数参数类型是否稳定？
- [ ] 是否避免了多态导致的 IC 失效？

### 内存分配
- [ ] 是否减少了不必要的对象分配？
- [ ] 是否使用了对象池？
- [ ] 是否使用了栈分配（对于小对象）？

### 循环优化
- [ ] 循环是否可以向量化？
- [ ] 是否有循环不变量可以外提？
- [ ] 是否消除了边界检查？

### 方法内联
- [ ] 热点方法是否足够小可以内联？
- [ ] 是否使用了 final/inline 提示？
- [ ] 虚方法调用是否可以避免？

### 同步
- [ ] 锁的范围是否最小？
- [ ] 是否可以使用无锁数据结构？
- [ ] 逃逸分析能否消除锁？