程序计数器 (Program Counter Register)

概述

程序计数器（PC Register）是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器。在 Java 虚拟机的概念模型里，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。

基本特性

1. 线程私有性

java

public class PCRegisterExample {
    private static int sharedCounter = 0;
    
    public static void main(String[] args) {
        // 每个线程都有自己的程序计数器
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                incrementCounter(); // 每个线程的 PC 独立跟踪执行位置
            }
        }, "Thread-1");
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                incrementCounter(); // 不同线程的 PC 互不影响
            }
        }, "Thread-2");
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("最终计数: " + sharedCounter);
    }
    
    private static synchronized void incrementCounter() {
        sharedCounter++;
        // 每个线程的程序计数器独立记录当前执行的字节码位置
    }
}

2. 内存区域特点

┌─────────────────────────────────────────────────────────────┐
│                        JVM 内存结构                          │
├─────────────────────────────────────────────────────────────┤
│                      线程共享区域                            │
│  ┌─────────────────┐  ┌─────────────────────────────────┐   │
│  │      堆内存      │  │          方法区                 │   │
│  │    (Heap)       │  │      (Method Area)             │   │
│  └─────────────────┘  └─────────────────────────────────┘   │
├─────────────────────────────────────────────────────────────┤
│                      线程私有区域                            │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────┐   │
│  │   程序计数器     │  │    虚拟机栈     │  │   本地方法栈 │   │
│  │ (PC Register)   │  │  (VM Stack)     │  │(Native Stack)│   │
│  │                 │  │                 │  │             │   │
│  │ • 线程私有      │  │ • 栈帧管理      │  │ • JNI 调用   │   │
│  │ • 字节码指针    │  │ • 方法调用      │  │ • 本地方法   │   │
│  │ • 执行位置      │  │ • 局部变量      │  │             │   │
│  │ • 无 OOM       │  │                 │  │             │   │
│  └─────────────────┘  └─────────────────┘  └─────────────┘   │
└─────────────────────────────────────────────────────────────┘

工作原理

1. 字节码执行跟踪

java

public class BytecodeTrackingExample {
    public void demonstratePCRegister() {
        int a = 10;        // PC: 0  - iconst_10
                          // PC: 1  - istore_1
        
        int b = 20;        // PC: 2  - bipush 20
                          // PC: 4  - istore_2
        
        int sum = a + b;   // PC: 5  - iload_1
                          // PC: 6  - iload_2
                          // PC: 7  - iadd
                          // PC: 8  - istore_3
        
        if (sum > 25) {    // PC: 9  - iload_3
                          // PC: 10 - bipush 25
                          // PC: 12 - if_icmple 19
            
            System.out.println("Sum is greater than 25");
                          // PC: 15 - getstatic
                          // PC: 18 - invokevirtual
        }
                          // PC: 19 - return
    }
    
    // 查看字节码的工具方法
    public static void printBytecode() {
        // 使用 javap -c ClassName 查看字节码
        // 每条字节码指令都有对应的 PC 值
        
        /*
        示例字节码输出：
        
        public void demonstratePCRegister();
          Code:
             0: bipush        10      // PC = 0
             2: istore_1              // PC = 2
             3: bipush        20      // PC = 3
             5: istore_2              // PC = 5
             6: iload_1               // PC = 6
             7: iload_2               // PC = 7
             8: iadd                  // PC = 8
             9: istore_3              // PC = 9
            10: iload_3               // PC = 10
            11: bipush        25      // PC = 11
            13: if_icmple     20      // PC = 13
            16: getstatic     #2      // PC = 16
            19: invokevirtual #3      // PC = 19
            20: return               // PC = 20
        */
    }
}

2. 分支和跳转控制

java

public class BranchControlExample {
    public void demonstrateBranching(int value) {
        // 条件分支
        if (value > 0) {           // PC 记录条件跳转指令位置
            positiveAction();      // 跳转到正数处理分支
        } else if (value < 0) {    // PC 记录另一个条件跳转
            negativeAction();      // 跳转到负数处理分支
        } else {
            zeroAction();          // 默认分支
        }
        
        // 循环控制
        for (int i = 0; i < 10; i++) {  // PC 跟踪循环的跳转
            processItem(i);             // 循环体执行
        }                               // PC 跳回循环条件检查
    }
    
    public void demonstrateSwitch(int option) {
        // switch 语句的跳转表
        switch (option) {
            case 1:                // PC 通过跳转表直接定位
                handleOption1();
                break;             // PC 跳转到 switch 结束
            case 2:
                handleOption2();
                break;
            case 3:
                handleOption3();
                break;
            default:
                handleDefault();
        }
    }
    
    public void demonstrateException() {
        try {
            riskyOperation();      // PC 正常执行
        } catch (Exception e) {    // 异常发生时 PC 跳转到异常处理器
            handleException(e);
        } finally {                // PC 确保 finally 块执行
            cleanup();
        }
    }
    
    private void positiveAction() { /* 实现 */ }
    private void negativeAction() { /* 实现 */ }
    private void zeroAction() { /* 实现 */ }
    private void processItem(int item) { /* 实现 */ }
    private void handleOption1() { /* 实现 */ }
    private void handleOption2() { /* 实现 */ }
    private void handleOption3() { /* 实现 */ }
    private void handleDefault() { /* 实现 */ }
    private void riskyOperation() throws Exception { /* 实现 */ }
    private void handleException(Exception e) { /* 实现 */ }
    private void cleanup() { /* 实现 */ }
}

3. 方法调用和返回

java

public class MethodCallExample {
    public void callerMethod() {
        System.out.println("调用前");  // PC: 当前位置
        
        int result = calledMethod(10); // PC: 方法调用指令
                                      // 保存返回地址到栈帧
                                      // PC 跳转到被调用方法
        
        System.out.println("返回值: " + result); // PC: 方法返回后的位置
    }
    
    public int calledMethod(int param) {
        // 新方法开始，PC 重置为该方法的起始位置
        int localVar = param * 2;     // PC: 0 (相对于该方法)
        
        if (param > 5) {
            return localVar;           // PC: 返回指令，恢复调用者的 PC
        }
        
        return 0;                      // PC: 另一个返回路径
    }
    
    // 递归调用中的 PC 行为
    public int factorial(int n) {
        if (n <= 1) {
            return 1;                  // PC: 递归终止条件
        }
        
        return n * factorial(n - 1);   // PC: 递归调用
                                      // 每次递归都有独立的 PC 上下文
    }
    
    // 异常处理中的 PC 跳转
    public void exceptionHandling() {
        try {
            int result = 10 / 0;       // PC: 异常发生点
        } catch (ArithmeticException e) {
            // PC 跳转到异常处理器
            System.out.println("除零异常");
        }
        // PC 继续正常执行流程
    }
}

本地方法调用

1. JNI 调用中的 PC 行为

java

public class NativeMethodExample {
    // 加载本地库
    static {
        System.loadLibrary("example"); // 假设的本地库
    }
    
    // 声明本地方法
    public native int nativeCalculation(int a, int b);
    public native String nativeStringOperation(String input);
    
    public void demonstrateNativeCall() {
        System.out.println("调用本地方法前"); // PC: Java 字节码位置
        
        int result = nativeCalculation(10, 20); // PC: 调用本地方法
                                                // PC 变为 undefined（本地方法执行期间）
        
        System.out.println("本地方法返回: " + result); // PC: 恢复 Java 字节码执行
    }
    
    public void mixedExecution() {
        // Java 方法执行
        int javaResult = javaCalculation(5, 3);    // PC: 跟踪 Java 字节码
        
        // 本地方法执行
        int nativeResult = nativeCalculation(5, 3); // PC: undefined 期间
        
        // 返回 Java 执行
        int total = javaResult + nativeResult;      // PC: 恢复字节码跟踪
        
        System.out.println("总计: " + total);
    }
    
    private int javaCalculation(int a, int b) {
        return a * b + 1;
    }
    
    // 模拟 JNI 调用栈
    public void demonstrateJNIStack() {
        /*
        调用栈示例：
        
        Java 方法栈帧:
        ┌─────────────────────────────────┐
        │ demonstrateJNIStack()           │ <- PC 跟踪这里的字节码
        │ - 局部变量表                     │
        │ - 操作数栈                       │
        │ - PC: 当前字节码位置             │
        └─────────────────────────────────┘
        
        本地方法栈帧:
        ┌─────────────────────────────────┐
        │ nativeCalculation()             │ <- PC 为 undefined
        │ - C/C++ 栈帧                    │
        │ - 本地变量                       │
        │ - 返回地址                       │
        └─────────────────────────────────┘
        */
        
        nativeCalculation(1, 2);
    }
}

2. PC 状态转换

java

public class PCStateTransition {
    public void demonstrateStateTransitions() {
        // 状态 1: 正常 Java 字节码执行
        int value = 42;                    // PC: 指向具体字节码位置
        
        // 状态 2: 方法调用
        String result = processValue(value); // PC: 保存返回地址，跳转到新方法
        
        // 状态 3: 本地方法调用
        // int nativeResult = nativeMethod(); // PC: 变为 undefined
        
        // 状态 4: 异常处理
        try {
            int division = value / 0;       // PC: 异常发生点
        } catch (Exception e) {
            // PC: 跳转到异常处理器
            handleException(e);
        }
        
        // 状态 5: 恢复正常执行
        System.out.println(result);        // PC: 继续正常字节码执行
    }
    
    private String processValue(int value) {
        // 新的 PC 上下文
        return "Processed: " + value;
    }
    
    private void handleException(Exception e) {
        System.out.println("处理异常: " + e.getMessage());
    }
    
    // PC 在不同执行模式下的行为
    public void executionModes() {
        /*
        1. 解释执行模式:
           - PC 逐条指向字节码指令
           - 解释器逐条执行
        
        2. 编译执行模式 (JIT):
           - PC 可能指向编译后的本地代码
           - 热点代码被编译为机器码
        
        3. 混合执行模式:
           - 冷代码解释执行 (PC 指向字节码)
           - 热代码编译执行 (PC 指向机器码)
        */
        
        // 这个循环可能触发 JIT 编译
        for (int i = 0; i < 10000; i++) {
            hotMethod(i); // 热点方法，可能被 JIT 编译
        }
    }
    
    private void hotMethod(int value) {
        // 频繁调用的方法，JIT 编译器可能优化
        // PC 行为会从字节码跟踪转为机器码跟踪
    }
}

线程安全与并发

1. 线程间 PC 独立性

java

public class ThreadPCIndependence {
    private static final Object lock = new Object();
    private static int sharedResource = 0;
    
    public static void main(String[] args) {
        // 创建多个线程，每个都有独立的 PC
        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            new Thread(() -> {
                workerMethod(threadId); // 每个线程的 PC 独立跟踪执行
            }, "Worker-" + i).start();
        }
    }
    
    private static void workerMethod(int threadId) {
        // 每个线程的 PC 独立跟踪这个方法的执行
        for (int i = 0; i < 100; i++) {
            synchronized (lock) {          // PC: 同步块入口
                sharedResource++;          // PC: 共享资源操作
                
                if (threadId == 0 && i % 20 == 0) {
                    System.out.println("Thread " + threadId + 
                                     ": iteration " + i + 
                                     ", shared: " + sharedResource);
                }
            }                              // PC: 同步块出口
            
            // 模拟一些工作
            doSomeWork(i);                 // PC: 跟踪方法调用
        }
    }
    
    private static void doSomeWork(int value) {
        // 每个线程的 PC 独立跟踪这里的执行
        try {
            Thread.sleep(1); // PC: 可能导致线程切换
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

2. 线程切换时的 PC 保存

java

public class ThreadContextSwitching {
    public void demonstrateContextSwitch() {
        /*
        线程切换过程中 PC 的保存和恢复：
        
        1. 线程 A 执行中:
           ┌─────────────────────────────────┐
           │ Thread A                        │
           │ PC: 指向当前字节码位置           │
           │ Stack: 方法调用栈               │
           │ Registers: CPU 寄存器状态       │
           └─────────────────────────────────┘
        
        2. 线程切换发生:
           - 保存线程 A 的 PC 值
           - 保存其他上下文信息
           - 加载线程 B 的 PC 值
           - 恢复线程 B 的上下文
        
        3. 线程 B 执行:
           ┌─────────────────────────────────┐
           │ Thread B                        │
           │ PC: 恢复到之前保存的位置         │
           │ Stack: 线程 B 的方法调用栈      │
           │ Registers: 线程 B 的寄存器状态  │
           └─────────────────────────────────┘
        */
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // PC 跟踪每次循环的执行位置
                processData("Thread-1", i);
                
                // 可能发生线程切换，PC 被保存
                Thread.yield();
                // 线程恢复时，PC 从保存的位置继续
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 独立的 PC 跟踪
                processData("Thread-2", i);
                Thread.yield();
            }
        });
        
        thread1.start();
        thread2.start();
    }
    
    private void processData(String threadName, int iteration) {
        // 每个线程的 PC 独立跟踪这个方法的执行
        if (iteration % 100 == 0) {
            System.out.println(threadName + " - iteration: " + iteration);
        }
    }
}

调试和监控

1. PC 相关的调试信息

java

public class PCDebugging {
    public static void main(String[] args) {
        demonstrateStackTrace();
    }
    
    public static void demonstrateStackTrace() {
        try {
            methodA();
        } catch (Exception e) {
            // 栈跟踪显示了每个方法调用时的 PC 位置
            printDetailedStackTrace(e);
        }
    }
    
    private static void methodA() {
        methodB();
    }
    
    private static void methodB() {
        methodC();
    }
    
    private static void methodC() {
        // 模拟异常
        throw new RuntimeException("演示异常");
    }
    
    private static void printDetailedStackTrace(Exception e) {
        System.out.println("异常栈跟踪分析:");
        
        StackTraceElement[] stackTrace = e.getStackTrace();
        for (int i = 0; i < stackTrace.length; i++) {
            StackTraceElement element = stackTrace[i];
            
            System.out.printf("[%d] %s.%s(%s:%d)%n",
                i,
                element.getClassName(),
                element.getMethodName(),
                element.getFileName(),
                element.getLineNumber()  // 对应源码行号，间接反映 PC 位置
            );
        }
    }
    
    // 获取当前执行位置信息
    public static void getCurrentExecutionInfo() {
        StackTraceElement currentMethod = Thread.currentThread().getStackTrace()[1];
        
        System.out.println("当前执行信息:");
        System.out.println("类名: " + currentMethod.getClassName());
        System.out.println("方法名: " + currentMethod.getMethodName());
        System.out.println("文件名: " + currentMethod.getFileName());
        System.out.println("行号: " + currentMethod.getLineNumber());
    }
    
    // 方法执行时间分析
    public static void analyzeMethodExecution() {
        long startTime = System.nanoTime();
        
        // 执行一些操作
        for (int i = 0; i < 1000000; i++) {
            Math.sqrt(i); // PC 跟踪每次循环
        }
        
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        
        System.out.println("方法执行时间: " + duration + " 纳秒");
        System.out.println("平均每次操作: " + (duration / 1000000.0) + " 纳秒");
    }
}

2. 性能分析工具

java

public class PCPerformanceAnalysis {
    // 使用 JMX 监控线程执行
    public static void monitorThreadExecution() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        
        // 启用 CPU 时间测量
        if (threadBean.isCurrentThreadCpuTimeSupported()) {
            threadBean.setThreadCpuTimeEnabled(true);
        }
        
        long threadId = Thread.currentThread().getId();
        long startCpuTime = threadBean.getCurrentThreadCpuTime();
        long startUserTime = threadBean.getCurrentThreadUserTime();
        
        // 执行一些计算密集型任务
        performComputationTask();
        
        long endCpuTime = threadBean.getCurrentThreadCpuTime();
        long endUserTime = threadBean.getCurrentThreadUserTime();
        
        System.out.println("CPU 时间: " + (endCpuTime - startCpuTime) / 1_000_000 + " ms");
        System.out.println("用户时间: " + (endUserTime - startUserTime) / 1_000_000 + " ms");
        System.out.println("系统时间: " + ((endCpuTime - startCpuTime) - (endUserTime - startUserTime)) / 1_000_000 + " ms");
    }
    
    private static void performComputationTask() {
        // 计算密集型任务，PC 频繁跟踪执行位置
        double result = 0;
        for (int i = 0; i < 1000000; i++) {
            result += Math.sin(i) * Math.cos(i);
        }
        System.out.println("计算结果: " + result);
    }
    
    // 分析方法调用频率
    public static void analyzeMethodCallFrequency() {
        Map<String, Integer> methodCallCount = new HashMap<>();
        
        // 模拟方法调用统计
        for (int i = 0; i < 10000; i++) {
            String methodName = getCurrentMethodName();
            methodCallCount.merge(methodName, 1, Integer::sum);
            
            if (i % 3 == 0) {
                helperMethodA();
            } else if (i % 3 == 1) {
                helperMethodB();
            } else {
                helperMethodC();
            }
        }
        
        // 输出统计结果
        methodCallCount.forEach((method, count) -> 
            System.out.println(method + ": " + count + " 次调用"));
    }
    
    private static String getCurrentMethodName() {
        return Thread.currentThread().getStackTrace()[2].getMethodName();
    }
    
    private static void helperMethodA() {
        // PC 跟踪这个方法的执行
    }
    
    private static void helperMethodB() {
        // PC 跟踪这个方法的执行
    }
    
    private static void helperMethodC() {
        // PC 跟踪这个方法的执行
    }
}

最佳实践

1. 理解 PC 对性能的影响

java

public class PCPerformanceBestPractices {
    // 1. 减少方法调用开销
    public void optimizeMethodCalls() {
        // 避免：频繁的小方法调用
        // for (int i = 0; i < 1000000; i++) {
        //     smallMethod(i); // 每次调用都需要 PC 跳转
        // }
        
        // 推荐：内联或批量处理
        for (int i = 0; i < 1000000; i++) {
            // 直接内联简单逻辑，减少 PC 跳转
            int result = i * 2 + 1;
            processResult(result);
        }
    }
    
    // 2. 优化分支预测
    public void optimizeBranchPrediction(int[] data) {
        // 避免：随机分支模式
        // for (int value : data) {
        //     if (Math.random() > 0.5) { // 随机分支，难以预测
        //         processPositive(value);
        //     } else {
        //         processNegative(value);
        //     }
        // }
        
        // 推荐：可预测的分支模式
        Arrays.sort(data); // 排序后分支更可预测
        for (int value : data) {
            if (value > 0) {
                processPositive(value);
            } else {
                processNegative(value);
            }
        }
    }
    
    // 3. 减少异常处理开销
    public void optimizeExceptionHandling(String[] inputs) {
        // 避免：使用异常控制流程
        // for (String input : inputs) {
        //     try {
        //         int value = Integer.parseInt(input);
        //         process(value);
        //     } catch (NumberFormatException e) {
        //         // 异常会导致 PC 跳转开销
        //         handleInvalidInput(input);
        //     }
        // }
        
        // 推荐：预先验证，避免异常
        for (String input : inputs) {
            if (isValidNumber(input)) {
                int value = Integer.parseInt(input);
                process(value);
            } else {
                handleInvalidInput(input);
            }
        }
    }
    
    private boolean isValidNumber(String input) {
        if (input == null || input.isEmpty()) return false;
        try {
            Integer.parseInt(input);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }
    
    private void processResult(int result) { /* 实现 */ }
    private void processPositive(int value) { /* 实现 */ }
    private void processNegative(int value) { /* 实现 */ }
    private void process(int value) { /* 实现 */ }
    private void handleInvalidInput(String input) { /* 实现 */ }
}

2. 调试技巧

java

public class PCDebuggingTechniques {
    // 1. 使用断点调试
    public void debugWithBreakpoints() {
        int value = 10;
        
        // 在 IDE 中设置断点，观察 PC 位置
        value = value * 2;     // 断点 1: 观察 PC 跳转
        
        if (value > 15) {      // 断点 2: 观察条件分支
            System.out.println("Value is large");
        }
        
        methodCall();          // 断点 3: 观察方法调用时的 PC 保存
    }
    
    private void methodCall() {
        System.out.println("In method call");
    }
    
    // 2. 日志记录执行路径
    public void logExecutionPath() {
        Logger logger = Logger.getLogger(getClass().getName());
        
        logger.info("开始执行: " + getCurrentLocation());
        
        for (int i = 0; i < 5; i++) {
            logger.fine("循环迭代 " + i + " at " + getCurrentLocation());
            
            if (i % 2 == 0) {
                logger.fine("偶数分支 at " + getCurrentLocation());
                processEven(i);
            } else {
                logger.fine("奇数分支 at " + getCurrentLocation());
                processOdd(i);
            }
        }
        
        logger.info("执行完成: " + getCurrentLocation());
    }
    
    private String getCurrentLocation() {
        StackTraceElement element = Thread.currentThread().getStackTrace()[2];
        return element.getMethodName() + ":" + element.getLineNumber();
    }
    
    private void processEven(int value) {
        System.out.println("处理偶数: " + value);
    }
    
    private void processOdd(int value) {
        System.out.println("处理奇数: " + value);
    }
    
    // 3. 性能分析
    public void profileExecution() {
        // 使用 JProfiler, VisualVM 等工具
        // 观察方法调用频率和 PC 跳转模式
        
        long startTime = System.nanoTime();
        
        // 热点代码
        for (int i = 0; i < 1000000; i++) {
            hotMethod(i);
        }
        
        long endTime = System.nanoTime();
        System.out.println("执行时间: " + (endTime - startTime) / 1_000_000 + " ms");
    }
    
    private void hotMethod(int value) {
        // 这个方法可能被 JIT 编译器优化
        // PC 行为会从字节码跟踪变为机器码跟踪
        Math.sqrt(value);
    }
}

总结

程序计数器是 JVM 中最简单但最重要的组件之一：

关键特性

线程私有 - 每个线程都有独立的 PC 寄存器
字节码跟踪 - 指向当前执行的字节码指令
无内存溢出 - 唯一不会发生 OutOfMemoryError 的区域
本地方法特殊性 - 执行本地方法时 PC 值为 undefined

工作机制

顺序执行 - 正常情况下 PC 顺序递增
分支跳转 - 条件语句、循环、异常处理时 PC 跳转
方法调用 - 保存返回地址，跳转到新方法
线程切换 - 保存和恢复 PC 值

性能影响

分支预测 - 影响 CPU 流水线效率
方法调用开销 - 频繁调用影响性能
异常处理 - 异常跳转有额外开销
JIT 编译 - 热点代码编译后 PC 行为改变

最佳实践

减少不必要的方法调用
优化分支结构
避免异常控制流程
理解 JIT 编译影响
合理使用调试工具

理解程序计数器的工作原理有助于编写更高效的 Java 代码，进行有效的性能调优和问题诊断。

程序计数器 (Program Counter Register) ​

概述 ​

基本特性 ​

1. 线程私有性 ​

2. 内存区域特点 ​

工作原理 ​

1. 字节码执行跟踪 ​

2. 分支和跳转控制 ​

3. 方法调用和返回 ​

本地方法调用 ​

1. JNI 调用中的 PC 行为 ​

2. PC 状态转换 ​

线程安全与并发 ​

1. 线程间 PC 独立性 ​

2. 线程切换时的 PC 保存 ​

调试和监控 ​

1. PC 相关的调试信息 ​

2. 性能分析工具 ​

最佳实践 ​

1. 理解 PC 对性能的影响 ​

2. 调试技巧 ​

总结 ​

关键特性 ​

工作机制 ​

性能影响 ​

最佳实践 ​

程序计数器 (Program Counter Register)

概述

基本特性

1. 线程私有性

2. 内存区域特点

工作原理

1. 字节码执行跟踪

2. 分支和跳转控制

3. 方法调用和返回

本地方法调用

1. JNI 调用中的 PC 行为

2. PC 状态转换

线程安全与并发

1. 线程间 PC 独立性

2. 线程切换时的 PC 保存

调试和监控

1. PC 相关的调试信息

2. 性能分析工具

最佳实践

1. 理解 PC 对性能的影响

2. 调试技巧

总结

关键特性

工作机制

性能影响

最佳实践