Java并发编程1:进程、线程、上下文切换与synchronized
先想一个问题:
现在创建两个线程,分别执行一百万次count++并输出,结果是什么?
200万?小于两百万?大于两百万?还是0?
答案可能是0,也可能是小于200万。
这个答案由具体代码决定。
而这个问题也恰恰串起了今天Java并发编程内容的主线:线程什么时候执行,一次自增是怎样完成的,以及 Java 如何约束两个线程对同一份数据的访问。
不过在此之前,我们需要了解什么是线程。
一、什么是线程和进程?
进程是程序的一次运行实例。 操作系统为进程提供虚拟地址空间、打开的文件等运行资源。独立启动两次同一个 Java 程序,通常会得到两个 JVM 进程。 当创建一个进程的时候,每个进程都会包含一个线程,这个线程叫做主线程。
线程是进程中的一条执行流。 Java 程序启动后,主线程执行 main()。如果 main() 又创建并启动了新的线程 t1、t2,程序里就有了三条可以分别推进的执行流。
每个 Java 线程有自己的 JVM 栈。线程调用方法时,会建立自己的栈帧,保存这次调用的局部变量等信息。堆由线程共享,因此两个线程可以各自执行自己的循环,同时访问同一个堆里的对象。最开始提出的计数例子正是这样,**两个线程各有自己的循环变量 i,却可以修改同一个 count。
那么认识完线程和进程,我们思考一个问题:
为什么要有线程?
多进程可以充分利用CPU资源去处理复杂业务,提高效率,但是从进程的生命周期来看,一个完整的进程需要走完以下流程:
创建进程—>申请资源—>加入PCB链表—>销毁进程—>释放资源—>把该进程从PCB链表中删除。
其中申请资源和释放资源对系统性能影响较大,为了节约资源,引出了线程的概念,线程使用的资源是进程启动时从操作系统中申请来的资源,也可以把线程叫做轻量级的进程。
线程的优势:
- 线程的创建速度比进程快。
- 线程的销毁速度比进程快。
- 线程CPU调度的速度比进程快。
线程与进程的区别:
- 进程中包含线程,至少有一个主线程。
- 进程是申请资源的最小单位。
- 线程是CPU调度的最小单位。
- 线程共享进程申请来的所有资源。
- 一个线程如果崩溃了,就会影响整个进程。
二、Java 线程有哪些状态?怎样转换?
Java 用 Thread.State 表示线程状态。操作系统调度时会区分“已经就绪”和“正在 CPU 上运行”,在 Java 的状态枚举中,这两种情况都可以表现为 RUNNABLE。
| 状态 | 什么时候进入 | 什么时候离开 |
|---|---|---|
新建NEW | 创建 Thread 对象后 | 调用 start(),线程可进入 RUNNABLE |
可运行RUNNABLE | 正在执行,或具备执行条件、等待处理器等资源 | 遇到等待、阻塞,或执行结束 |
阻塞态BLOCKED | 要进入或重新进入 synchronized,但监视器锁被占用 | 成功取得所需的锁后继续执行 |
等待WAITING | 无时限地等待另一个动作,例如调用 wait(),或对还在运行的线程调用 join() | 等待条件满足,或当前线程被中断。wait() 返回前还需要重新取得相应的锁 |
限时等待TIMED_WAITING | 调用 sleep(),或进行带时限的等待 | 到期、被中断,或相应的等待条件提前满足 |
终止TERMINATED | 线程执行完毕或因未捕获的异常退出 | 终止状态 |
现在,认识完线程与线程的状态之后,我们回到最初的问题:
三、两个线程都执行 count++,为什么打印出 0?
public class CountWithoutJoin {
private static int count;
public static void main(String[] args) {
Runnable task = () -> {
for (int i = 0; i < 1_000_000; i++) {
count++;
}
};
Thread t1 = new Thread(task, "t1");
Thread t2 = new Thread(task, "t2");
t1.start();
t2.start();
System.out.println(count);
}
}
如果按照正常的推算,t1和t2线程各执行一百万次count++,再进行打印,理论上我们应该得到两百万,再不济也是小于两百万,可实际上输出的结果是0.
这是为什么?
原理如下:
主线程 t1.start() → t2.start() → 读取并打印 count:0
t1 → 开始自增
t2 → 开始自增
这里的关键是:线程直接是相互独立的。
也就是说,主函数的打印语句并不会等待t1和t2线程执行完之后再执行,这就导致t1和t2还未来得及执行count++,打印语句就已经执行。
start() 让工作线程具备执行条件,调用它的主线程可以继续执行。**几个线程各有自己的执行进度。
换句话说,它们之间并不会互相等待,至于为什么,这就要看CPU了。
四、CPU 怎样安排线程执行?
时间片轮转
对于 new Thread(...) 创建的平台线程,通常由操作系统决定线程什么时候运行。假设只有一个逻辑 CPU,三个同优先级的线程都处于就绪状态,每个时间片取 5 ms,轮转过程可以画成这样。
时间 0 5 10 15 20 ms
| t1 | t2 | t3 | t1 |
t1 先运行。时间片用完后,如果它还有工作并且仍然就绪,就回到队尾等待下一轮。如果 t1 在时间片用完前就开始等待磁盘操作,操作系统可以提前切换到 t2。等前面的 I/O 完成,t1 才重新具备被调度的条件。
这里的 5 ms 是示意值。Windows 会在当前最高优先级的就绪线程之间轮转。Linux 也有正式的轮转策略 SCHED_RR,它属于实时调度策略。实际运行顺序还受系统策略、优先级和可用逻辑 CPU 数量影响。
上下文切换
从 t1 切换到 t2 时,操作系统需要保存 t1 的执行现场,例如指令位置、栈指针和其他寄存器,再恢复 t2 的现场。下一次 t1 得到 CPU,就可以从之前停下的位置继续。这个过程叫上下文切换。
上下文切换本身要消耗 CPU 时间。切得越频繁,业务代码可用的执行时间就可能越少。I/O 密集型任务可以利用切换,让另一个任务在等待期间继续工作。对于单个逻辑 CPU 上持续运行的纯计算任务,交替执行仍需完成同样多的计算,还要承担切换开销。
说到这里,就能够解释了上面的 0。
主线程调用完两次 start() 后,完全可能继续执行到打印语句。如果想要结果变成两百万,代码至少需要显式表达“等两个工作线程都结束,再进行打印”。
那么,我们该如何进行这个表达呢?
这里,我们引入一个join()方法。
在前面的程序里,给 main() 加上 throws InterruptedException,再把两次 join() 放在打印前。
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
t1.join() 的意思是让调用它的线程等 t1 结束。这里调用者是主线程。两个 start() 都已经执行,所以主线程等 t1 时,t2 也可以运行。两个 join() 都成功返回后再打印,工作线程结束前的操作对主线程可见。
做到这里,我们就做到了让线程按照我们预想中运行,即先执行完t1和t2线程各自的count++,再进行打印。
那么问题又来了。
这次答案会是预想中的两百万吗?
然而结果出乎意料。
实测这次打印了 1087944。
两个线程已经做完各自的一百万次循环,但是与预想中的结果差出近乎100万的数值。
这是为什么?
五、加上 join() 后,为什么仍然不到两百万?
从字节码看 count++
用 javap 查看这个静态字段的自增,可以看到下面几步。这里省略了指令偏移量和字段编号。
getstatic count 读取 count
iconst_1 准备常量 1
iadd 把读到的值加 1
putstatic count 将结果写回 count
问题出在从读到写之间可以插入另一个线程的操作。假设 count 初始为 0,两个线程各做一次自增。
| 顺序 | t1 | t2 | 共享的 count |
|---|---|---|---|
| 1 | 读到 0 | 0 | |
| 2 | 也读到 0 | 0 | |
| 3 | 算出 1,写回 | 1 | |
| 4 | 用先前读到的 0 算出 1,写回 | 1 |
结果只加了 1,这叫丢失更新。
两个线程争抢的是同一个共享变量,每次自增都依赖自己之前读到的值。
单核上,线程可能在读完后被切走。多核上,两个线程也可能在很接近的时间读到同一个值。join() 能等到两个线程做完,但主线程读结果时,丢失更新已经发生了。
也就是说,为什么没有得到理想中的两百万,反而得到了一百多万,是因为t1和t2在执行count++期间,产生了多次读写覆盖,导致许多原本计算好的结果产生了丢失。
如何解决这个问题?
这就要引出我们常见的锁了。
六、用 synchronized 保护整个自增
如果想要多线程计算准确,关键是:基于其他线程的计算结果上继续计算
做法是把 count++ 的读、改、写放进同一个临界区,并让两个线程进入前先去争抢同一把锁。
假设 t1 拿到锁,它读 0、算出 1、写回,然后释放锁。这个过程中t2线程即使获得了CPU的时间片,但也无法读到count,更无法写,直到t1将锁释放。
当t2 取得这把锁后,才能够开始读取,此时就可以从 1 接着算到 2。
其中,synchronized也属于我们常说的悲观锁。
它采用的是悲观策略:先取得保护,再操作。
想法是:别人可能同时修改,我先协调好,再开始。
互斥锁就是典型的悲观锁。
当然,与之相反的还有乐观锁,它执行的是乐观策略:先计算,提交时检查是否冲突
想法是:先尝试完成,如果依据已经变化,就放弃这次提交,重试或报告冲突。
不过这里就不多叙述其他锁了,回到正题。
七、synchronized 锁的是谁?
既然已经通过锁解决了问题,但原理上我们也要明白,synchronized究竟锁的是谁?它把谁给锁住了?方法?对象?变量?
准确地说,线程取得的是某个对象关联的监视器锁。 count 是要保护的数据。具体用哪个对象的锁,取决于 synchronized 写在哪里。
这里一共有三种写法。
| 写法 | 本例中的锁对象 | 两个线程为什么互斥 |
|---|---|---|
synchronized void add() | 修饰非静态方法,锁的是方法的调用者,即 this | 两个线程都在同一个 instance 上调用 add() |
static synchronized void add() | 修饰静态方法,锁的是类,即声明方法的类对应的 StaticCounter.class 对象 | 两个线程调用这个静态同步方法时,都申请同一个 Class 对象的锁 |
synchronized (lock) | 修饰代码块,锁的是lock 指向的那个对象,即传入的对象 | 两个线程通过同一个实例访问同一个 lock |
之后,我们把以下代码保存为 SynchronizedCountDemo.java。三个计数器分别运行,每组都由两个线程各加一百万次。
public class SynchronizedCountDemo {
private static final int TIMES = 1_000_000;
// 例 1 使用同步实例方法
static class InstanceCounter {
private int count;
synchronized void add() {
count++;
}
}
// 例 2 使用同步静态方法
static class StaticCounter {
private static int count;
static synchronized void add() {
count++;
}
}
// 例 3 使用同步代码块
static class BlockCounter {
private final Object lock = new Object();
private int count;
void add() {
synchronized (lock) {
count++;
}
}
}
public static void main(String[] args) throws InterruptedException {
InstanceCounter instance = new InstanceCounter();
runTwoThreads(instance::add);
System.out.println("同步实例方法 = " + instance.count);
runTwoThreads(StaticCounter::add);
System.out.println("同步静态方法 = " + StaticCounter.count);
BlockCounter block = new BlockCounter();
runTwoThreads(block::add);
System.out.println("同步代码块 = " + block.count);
}
private static void runTwoThreads(Runnable increment)
throws InterruptedException {
Runnable task = () -> {
for (int i = 0; i < TIMES; i++) {
increment.run();
}
};
Thread t1 = new Thread(task, "t1");
Thread t2 = new Thread(task, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
}
}
instance::add 可以读作 () -> instance.add()。同一个任务交给两个线程,所以两个线程调用的是同一个实例的 add()。运行结果如下。
同步实例方法 = 2000000
同步静态方法 = 2000000
同步代码块 = 2000000
用 javap 查看这三种写法,可以看到同步方法有 ACC_SYNCHRONIZED 标记。JVM 调用方法时,按实例方法或静态方法的规则获取对应的监视器锁。同步代码块则用 monitorenter 和 monitorexit 获取和释放 lock 所引用对象的监视器锁,正常或异常退出都有释放路径。三种写法仍然可能发生锁竞争,但同一时刻只有一个线程能持有该锁,自增就不会因为读到同一个旧值而少算。
八、缓存一致性协议在这里起什么作用?
多核处理器的不同核心可能把同一份内存数据缓存在各自的缓存里。缓存一致性协议用于协调这些副本。以常见的 MESI 为例,缓存以缓存行为单位记录状态。
| 状态 | 含义 |
|---|---|
M,Modified | 本核心拥有这条缓存行,并且已经修改 |
E,Exclusive | 本核心独占这一有效副本,数据尚未修改 |
S,Shared | 这条缓存行是有效的,其他核心也可能有副本 |
I,Invalid | 本地副本已经失效,下一次访问需要重新取得有效数据 |
例如,核心 A 和核心 B 都缓存了 count 所在的缓存行。A 要写入时,协议会协调写入权限,并让 B 的旧副本失效。B 之后再次读取这条缓存行时,需要取得有效的数据。
回到 count++。即使硬件正确协调了最终写入,两个线程也可能早就各自把 0 读出来,并分别算好了 1。缓存一致性协议协调的是缓存副本与内存访问,synchronized 保护的是整次读、改、写。Java 层上,同一把监视器锁的释放与后续获取建立可见性保证,互斥则确保后一个线程等前一次自增写完后,才开始自己的自增。
openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构
更多推荐



所有评论(0)