1、volatile 和 synchronized

Java 支持多线程同时访问一个对象或者对象的成员变量,由于每一个线程可以拥有这个变量的副本,所以程序执行的过程中,一个线程看到的变量不一定是最新的。

1.1、volatile

volatile 可以用来修饰成员变量,就是告知程序任何对该变量的访问均需要从共享内存中获取,而对它的改变必须同步刷新会共享内存,它能保证所有线程对变量访问的可见性。下面代码演示了,VolatileRunner 线程每次读 volatile 变量时都会去主内存中去读。

  1. package com.yj.thread;
  2. /**
  3. * @description: volatile
  4. * @author: erlang
  5. * @since: 2021-02-03 20:00
  6. */
  7. public class VolatileThread {
  8. private volatile static int value = 1;
  9. private static int num = 1;
  10. public static void main(String[] args) {
  11. new Thread(new Runner(), "RunnerThread").start();
  12. new Thread(new VolatileRunner(), "VolatileRunnerThread").start();
  13. }
  14. static class Runner implements Runnable {
  15. @Override
  16. public void run() {
  17. long start = System.currentTimeMillis();
  18. long i = 0;
  19. while (i++ < 100000_0000) {
  20. int b = num;
  21. }
  22. System.out.println(Thread.currentThread().getName() + " time: " + (System.currentTimeMillis() - start));
  23. }
  24. }
  25. static class VolatileRunner implements Runnable {
  26. @Override
  27. public void run() {
  28. long start = System.currentTimeMillis();
  29. long i = 0;
  30. while (i++ < 100000_0000) {
  31. int b = value;
  32. }
  33. System.out.println(Thread.currentThread().getName() + " time: " + (System.currentTimeMillis() - start));
  34. }
  35. }
  36. }

输出结果如下,通过结果可知,如果过多地使用 volatile 关键字是会降低程序的执行效率。

  1. RunnerThread time: 336
  2. VolatileRunnerThread time: 540

1.2 synchronized

synchronized 关键字可以修饰方法或者以同步块的形式来进行使用,它主要确保多个线程在同一个时刻,只能有一个线程处于方法或者同步块中,它保证了线程对变量访问的可见性和排他性。

下面的示例代码中,使用了同步块和同步方法。我们可以通过使用 javap 工具查看生成的 class 文件信息,来分析 synchronized 关键字的实现细节。

  1. package com.yj.thread;
  2. /**
  3. * @description: synchronized 关键字演示
  4. * @author: erlang
  5. * @since: 2021-02-03 20:19
  6. */
  7. public class SynchronizedThread {
  8. public static void main(String[] args) {
  9. // 对 SynchronizedThread 的 class 对象加锁
  10. synchronized (SynchronizedThread.class) {
  11. }
  12. // 静态同步方法,对 SynchronizedThread class 对象加锁
  13. synchronizedMethod();
  14. }
  15. public static synchronized void synchronizedMethod() {
  16. }
  17. }

在 SynchronizedThread.class 同级目下执行 javap -v SynchronizedThread,输出的部分结果如下

  1. public static void main(java.lang.String[]);
  2. descriptor: ([Ljava/lang/String;)V
  3. flags: ACC_PUBLIC, ACC_STATIC
  4. Code:
  5. stack=2, locals=3, args_size=1
  6. 0: ldc #2 // class com/yj/thread/SynchronizedThread
  7. 2: dup
  8. 3: astore_1
  9. 4: monitorenter // 监视器进入,获取锁
  10. 5: aload_1
  11. 6: monitorexit // 监视器退出,释放锁
  12. 7: goto 15
  13. 10: astore_2
  14. 11: aload_1
  15. 12: monitorexit // 系统异常情况下,监视器退出,释放锁
  16. 13: aload_2
  17. 14: athrow
  18. 15: invokestatic #3 // Method synchronizedMethod:()V
  19. 18: return
  20. Exception table:
  21. from to target type
  22. 5 7 10 any
  23. 10 13 10 any
  24. LineNumberTable:
  25. line 12: 0
  26. line 14: 5
  27. line 16: 15
  28. line 17: 18
  29. LocalVariableTable:
  30. Start Length Slot Name Signature
  31. 0 19 0 args [Ljava/lang/String;
  32. StackMapTable: number_of_entries = 2
  33. frame_type = 255 /* full_frame */
  34. offset_delta = 10
  35. locals = [ class "[Ljava/lang/String;", class java/lang/Object ]
  36. stack = [ class java/lang/Throwable ]
  37. frame_type = 250 /* chop */
  38. offset_delta = 4
  39. public static synchronized void synchronizedMethod();
  40. descriptor: ()V
  41. // 方法修饰符,表示 public static synchronized
  42. flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
  43. Code:
  44. stack=0, locals=0, args_size=0
  45. 0: return
  46. LineNumberTable:
  47. line 21: 0

从 class 信息中,我们可以看出对于同步块的是实现使用了 monitorenter 和 monitorexit 指令,而同步方法则是依靠方法修饰符的 ACC_SYNCHRONIZED 来完成的。无论采用哪种方式,其本质都是对一个对象的监视器(monitor)进行获取,而这个获取过程是排他的,即同一时刻只能有一个线程获取到由 synchronized 所保护对象的监视器。

任意一个对象都有自己的 monitor,当这个对象由同步块或者同步方法调用时,执行方法的线程必须先获取到该对象的 monitor 才能进入同步块或者同步方法,而没有获取到 monitor 的线程将会阻塞在同步块和同步方法的入口处,进入 BLOCKED 状态。

下图描述了对象、对象监视器(Monitor)、同步队列(EntryList)和执行线程之间的关系。从图中可以看出,在任意线程对 Object(由 synchronized 保护)的访问,首先要获得 Object 的 Monitor。如果获取失败,线程进入同步队列,线程状态变为 BLOCKED。当获得了锁的线程释放锁,则该释放操作唤醒阻塞在 EntryList 中的线程,去重新尝试获取 Monitor。

六、线程间通信 - 图1

2、等待/唤醒机制

一个线程修改了一个对象的值,而另一个线程感知到了变化,然后进行相应的操作;整个过程开始于一个线程,而最终执行又是另一个线程。前者是生产者,后者就是消费者,这种模式隔离了做什么(what)和怎么做(how),在功能层面上实现类解耦,体系结构上具备了良好的扩展性,这在 Java 语言中如何实现类似功能呢?

简单的办法是让消费者线程不断地循环检查变量是否符合预期,如下面代码所示,在 while 循环中设置不满足的条件,如果条件满足则退出 while 循环,从而完成消费者的工作。

  1. while (value != expected) {
  2. Thread.sleep(1000);
  3. }
  4. doSomething();

上面的伪代码在条件不满足时就睡眠一段时间,这样做的目的是防止过快的无效尝试,这种方式看似能够是是实现所需的功能,但是却存在如下问题。

  1. 难以确保及时性:在睡眠时,基本不消耗处理器资源,但是如果睡得太久,就不能及时发现条件已经变化,也就是及时性难以保证
  2. 难以降低开销:如果降低睡眠的时间,比如睡眠 1 毫秒,这样消费者能更加迅速地发现条件变化,但是却可能消耗更多的处理器资源,造成了无端的浪费

以上两个问题,看似矛盾难以调和,但是 Java 通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。等待/通知的相关方法时任意 Java 对象都具备的,因为这些方法被定义在 java.lang.Object 里了。方法如下:

方法名称 描述
notify() 通知一个在对象上等待的喜爱昵称,使其从 wait 方法返回,而返回的前提是该线程获取到了对象的锁
notifyAll() 通知所有等待在该对象上的线程
wait() 调用该方法的线程进入 WAITING 状态,只有等待另外线程的通知或被中断才会返回,需要注意,调用 wait() 方法后,会释放对象的锁
wait(long) 超时等待一段时间,这里的参数时间是毫秒,也就是等待长达 n 毫秒,如果没有通知就超时返回
wait(long, int) 对于超时时间更细粒度的控制,可以达到纳秒

等待/通知机制,是指一个线程 A 调用了对象 O 的 wait 方法进入等待状态,而另一个线程 B 调用了队形 O 的 notify 或者 notifyAll 方法,线程 A 收到通知后从对象 O 的 wait 方法返回,进而执行后续操作。上述两个线程通过对象 O 来完成交互,而对象上的 wait 方法和 notify/notifyAll 的关系就如同开关信号一样,用来完成等待和通知方之间的交互工作。示例代码如下:

  1. package com.yj.thread;
  2. import java.time.LocalDateTime;
  3. import java.time.format.DateTimeFormatter;
  4. import java.util.concurrent.TimeUnit;
  5. /**
  6. * @description: 等待/唤醒
  7. * @author: erlang
  8. * @since: 2021-02-04 21:38
  9. */
  10. public class WaitNotifyThread {
  11. static boolean flag = true;
  12. final static Object LOCK = new Object();
  13. final static DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
  14. public static void main(String[] args) throws InterruptedException {
  15. Thread waitThread = new Thread(new Wait(), "WaitThread");
  16. waitThread.start();
  17. TimeUnit.SECONDS.sleep(1);
  18. Thread notifyThread = new Thread(new Notify(), "NotifyThread");
  19. notifyThread.start();
  20. }
  21. static class Wait implements Runnable {
  22. @Override
  23. public void run() {
  24. // 加锁,获取 LOCK 对象的 Monitor
  25. synchronized (LOCK) {
  26. while (flag) {
  27. try {
  28. System.out.println(Thread.currentThread().getName() + " flag is true. wait @ " + LocalDateTime.now().format(FORMATTER));
  29. // 等待的同时,释放锁
  30. LOCK.wait();
  31. } catch (InterruptedException e) {
  32. }
  33. }
  34. }
  35. System.out.println(Thread.currentThread().getName() + " flag is false. running @ " + LocalDateTime.now().format(FORMATTER));
  36. }
  37. }
  38. static class Notify implements Runnable {
  39. @Override
  40. public void run() {
  41. // 加锁,获取 LOCK 对象的 Monitor
  42. synchronized (LOCK) {
  43. // 获取 LOCK 的锁,然后进行通知,通知时不会释放 LOCK 的锁
  44. // 直到当前线程释放了 LOCK 之后,WaitThread 才能从 wait 方法中返回
  45. System.out.println(Thread.currentThread().getName() + " lock. notifyAll @ " + LocalDateTime.now().format(FORMATTER));
  46. LOCK.notify();
  47. flag = false;
  48. try {
  49. TimeUnit.SECONDS.sleep(3);
  50. } catch (InterruptedException e) {
  51. e.printStackTrace();
  52. }
  53. }
  54. // 获取 LOCK 锁
  55. synchronized (LOCK) {
  56. System.out.println(Thread.currentThread().getName() + " lock. sleep @ " + LocalDateTime.now().format(FORMATTER));
  57. try {
  58. TimeUnit.SECONDS.sleep(2);
  59. } catch (InterruptedException e) {
  60. e.printStackTrace();
  61. }
  62. }
  63. }
  64. }
  65. }

输出结果如下,下面的结果的第三行和第四行输出的顺序可能会互换。

  1. WaitThread flag is true. wait @ 22:07:15
  2. NotifyThread lock. notifyAll @ 22:07:16
  3. NotifyThread lock. sleep @ 22:07:19
  4. WaitThread flag is false. running @ 22:07:21

上面的代码,说明了调用 wait、notify 以及 notifyAll 时信息需要注意的细节,如下。

  1. 使用 wait、notify 和 notifyAll 时需要先对调用对象加锁
  2. 调用 wait 方法后,线程状态由 RUNNING 变为 WAITING,并将当前线程放置到对象的等待队列
  3. notify 或 notifyAll 方法调用后,等待线程依旧不会从 wait 返回,需要调用 notify 或 notifyAll 方法的线程释放锁之后,等待线程才有机会从 wait 方法返回
  4. notify 方法将等待队列中的一个等待线程从等待队列中移到同步队列中;而 notifyAll 方法则是将等待队列中所有的线程全部移到同步队列中,被移动的线程状态由 WAITING 变为 BLOCKED
  5. 从 wait 方法返回的前提是获得了调用对象的锁

从上述细节中可以看到,等待/通知机制依托于同步机制。其目的就是确保等待线程从 wait 方法返回时,能够感知到线程对变量做出的修改。

如图所示,WaitThread 首先获取了对象的锁,然后调用对象的 wait 方法,放弃锁并进入 WaitSet 中,进入等待状态。由于 WaitThread 释放了对象的锁,NotifyThread 随后获取了对象的锁,并调用对象的 notify 方法,将 WaitThread 从 WaitSet 移到 EntryList 中,此时 WaitThread 的状态变为阻塞状态。NotifyThread 释放了锁之后,WaitThread 再次获取到锁并从 wait 方法返回继续执行。

六、线程间通信 - 图2

3、等待/通知的经典范式

从 WaitNotify 示例中可以提炼出等待/通知的经典范式,该范式分为两部分,分别针对等待方(消费者)和通知方(生产者)。

3.1、等待方遵循的原则

  1. 获取对象的锁
  2. 如果条件不满足,那么调用对象的 wait 方法,被通知后仍要检查条件
  3. 条件满足则执行对应的逻辑

对应伪代码如下:

  1. synchronized(LOCK) {
  2. while (condition != true) {
  3. LOCK.wait();
  4. }
  5. // 对应的逻辑代码
  6. ...
  7. }

3.2、通知方遵循的原则

  1. 获取对象的锁
  2. 改变条件
  3. 通知所有等待在对象上的线程

对应的伪代码如下:

  1. synchronized(LOCK) {
  2. // 改变条件
  3. ...
  4. // 唤醒
  5. LOCK.notifyAll();
  6. }