Java并发——并发编程底层原理

在现代软件开发中，并发编程已成为提升程序性能、充分利用多核处理器的关键手段。然而，许多开发者在使用线程、锁、并发工具时，往往忽略了底层操作系统和硬件是如何支撑起"同时执行"的假象的。理解并发编程的底层原理，不仅有助于写出更高效的代码，也能帮助我们更好地诊断性能问题。

本文将从CPU的时间片轮转机制 出发，剖析线程的执行流程，并深入探讨上下文切换的成本，帮助你建立并发编程的底层认知。

一、宏观并行 vs 微观串行：时间片轮转

我们常说的"多线程同时执行"，实际上是一种宏观上的并行。在单核CPU时代，一次只能执行一条指令；即便在多核CPU上，每个核心同一时刻也只能运行一个线程。那么，为什么我们能感受到多个任务同时进行呢？

答案就在于时间片轮转。

操作系统为每个线程分配一个短暂的时间片（通常几十毫秒），然后快速地在不同线程间切换执行。由于时间片极短，切换速度极快，用户感知上就像是所有任务在并行运行。这个过程就像电影播放：每秒24帧的画面快速切换，给人连续运动的错觉。

时间轴：
CPU核心1: [线程A] [线程B] [线程A] [线程C] ...
                ↑       ↑       ↑
             时间片   切换    时间片

在操作系统的调度器眼中，每个就绪线程都会进入一个就绪队列，调度器根据策略（如优先级、时间片轮转）决定下一个执行哪个线程。当线程的时间片用尽，或者主动让出CPU（如IO等待），调度器会触发切换。

多核下的变化

多核CPU的出现，使得多个线程可以真正同时运行在不同核心上，但每个核心内部依然是时间片轮转。因此，即使有多个核心，线程的数量仍然可以远超核心数，上下文切换依然不可避免。

二、线程的执行流程：从主线程到子线程

以Java程序为例，当我们启动一个应用时，JVM会创建一个主线程 （main），执行public static void main方法。主线程的调用栈首先入栈，然后根据代码逻辑创建其他子线程。

线程的创建与就绪

当我们调用new Thread().start()时，JVM会向操作系统请求创建一个新的原生线程（Native Thread）。操作系统内核会分配线程控制块（TCB），并将该线程加入就绪队列。但此时，新线程并不会立即执行，而是等待CPU调度。

主线程和子线程之间没有固定的执行顺序，完全由操作系统调度决定。因此，我们常说"线程的执行顺序是不可预测的"。

主线程：启动线程A、线程B → 继续执行
线程A：就绪队列 → 等待CPU
线程B：就绪队列 → 等待CPU
调度器：任意选择下一个线程

线程的调度策略

操作系统的线程调度通常有两种模式：

• 抢占式调度：线程只能被动地被调度器剥夺CPU使用权（如时间片耗尽或更高优先级线程就绪）。大多数现代操作系统（Linux、Windows）都采用抢占式。

• 协作式调度 ：线程主动让出CPU（如调用yield()），但已很少使用。

在抢占式调度下，开发者无法精确控制线程的执行顺序，必须通过同步机制（锁、信号量等）来协调对共享资源的访问。

三、上下文切换：隐藏的性能杀手

当CPU从一个线程切换到另一个线程时，操作系统必须保存当前线程的执行状态 ，并加载下一个线程的状态 。这个过程称为上下文切换（Context Switch）。

切换时保存什么？

上下文主要包括：

• 程序计数器：记录线程下一步要执行的指令地址。

• CPU寄存器：通用寄存器、栈指针、状态寄存器等。

• 内核栈信息：线程在内核空间的状态。

这些数据会从CPU寄存器保存到内存中的线程控制块（TCB），然后将下一个线程的TCB内容加载到寄存器中。整个过程由操作系统内核完成，对应用程序是透明的。

上下文切换的开销

上下文切换并非免费，它带来了多方面的开销：

1. 直接开销（时间成本）：

   • 保存/恢复寄存器、程序计数器等。

   • 内存映射表（TLB）刷新，导致后续内存访问的缓存缺失。

   • 调度器算法的执行开销。

2. 间接开销：

   • 缓存（L1/L2/L3）失效：切换后，新线程访问的数据很可能不在CPU缓存中，导致更多的缓存未命中。

   • CPU流水线清空：分支预测信息失效。

3. 量化成本 ：

   一次上下文切换通常需要几百纳秒到几微秒不等，看似微小，但若在极高并发下频繁切换，累积开销不容忽视。例如，每秒10万次切换，可能占据一个CPU核心的5%~10%的时间。

什么情况会触发上下文切换？

• 时间片用完：线程执行时间达到配额，调度器强制切换。

• 线程阻塞 ：主动等待锁、IO、调用sleep()、wait()等。

• 更高优先级线程就绪：抢占式调度中，高优先级线程可立即剥夺低优先级线程。

• 主动让出 ：调用Thread.yield()或Thread.sleep(0)，提示调度器可切换（但不保证）。

四、对并发编程的启示

理解了底层机制，我们就能更好地设计并发程序：

1. 减少不必要的线程：线程越多，上下文切换越频繁。使用线程池控制线程数量，避免创建过多线程。

2. 避免长时间持有锁：当线程持锁阻塞时，其他等待锁的线程会被挂起，导致切换；应尽量缩小同步块范围。

3. 合理使用yield ：yield只是提示，不能依赖它来控制顺序，滥用可能增加切换。

4. CPU密集型任务：线程数不应超过CPU核心数过多，否则频繁切换导致吞吐量下降。

5. IO密集型任务：可以多配置一些线程，因为线程常在IO上阻塞，主动让出CPU。

6. 利用现代并发工具 ：CompletableFuture、ForkJoinPool等框架能自动优化任务划分和线程管理。

五、总结

并发编程的底层，是操作系统和硬件精心编排的一场"时间分片"大戏。时间片轮转让我们在单核时代体验到"并行"的错觉，上下文切换则保证多任务公平执行的同时，也带来了性能损耗。了解这些底层机制，我们才能在实际开发中更理性地设计并发策略：既充分利用多核资源，又避免过度切换带来的开销。