先想一个问题:

现在创建两个线程,分别执行一百万次count++并输出,结果是什么?
200万?小于两百万?大于两百万?还是0?

答案可能是0,也可能是小于200万。
这个答案由具体代码决定。

而这个问题也恰恰串起了今天Java并发编程内容的主线:线程什么时候执行,一次自增是怎样完成的,以及 Java 如何约束两个线程对同一份数据的访问。
不过在此之前,我们需要了解什么是线程。

一、什么是线程和进程?

进程是程序的一次运行实例。 操作系统为进程提供虚拟地址空间、打开的文件等运行资源。独立启动两次同一个 Java 程序,通常会得到两个 JVM 进程。 当创建一个进程的时候,每个进程都会包含一个线程,这个线程叫做主线程。

线程是进程中的一条执行流。 Java 程序启动后,主线程执行 main()。如果 main() 又创建并启动了新的线程 t1、t2,程序里就有了三条可以分别推进的执行流。

每个 Java 线程有自己的 JVM 栈。线程调用方法时,会建立自己的栈帧,保存这次调用的局部变量等信息。堆由线程共享,因此两个线程可以各自执行自己的循环,同时访问同一个堆里的对象。最开始提出的计数例子正是这样,**两个线程各有自己的循环变量 i,却可以修改同一个 count。

那么认识完线程和进程,我们思考一个问题:

为什么要有线程?

多进程可以充分利用CPU资源去处理复杂业务,提高效率,但是从进程的生命周期来看,一个完整的进程需要走完以下流程:
创建进程—>申请资源—>加入PCB链表—>销毁进程—>释放资源—>把该进程从PCB链表中删除。
其中申请资源和释放资源对系统性能影响较大,为了节约资源,引出了线程的概念,线程使用的资源是进程启动时从操作系统中申请来的资源,也可以把线程叫做轻量级的进程。

线程的优势:

  1. 线程的创建速度比进程快。
  2. 线程的销毁速度比进程快。
  3. 线程CPU调度的速度比进程快。

线程与进程的区别:

  1. 进程中包含线程,至少有一个主线程。
  2. 进程是申请资源的最小单位。
  3. 线程是CPU调度的最小单位。
  4. 线程共享进程申请来的所有资源。
  5. 一个线程如果崩溃了,就会影响整个进程。

二、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,两个线程各做一次自增。

顺序t1t2共享的 count
1读到 00
2也读到 00
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 层上,同一把监视器锁的释放与后续获取建立可见性保证,互斥则确保后一个线程等前一次自增写完后,才开始自己的自增。

Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐