1、volatile 和 synchronized

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

1.1、volatile

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

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

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

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

1.2 synchronized

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

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

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

在 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
  40.   public static synchronized void synchronizedMethod();
  41.     descriptor: ()V
  42.     // 方法修饰符，表示 public static synchronized
  43.     flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
  44.     Code:
  45.       stack=0, locals=0, args_size=0
  46.          0: return
  47.       LineNumberTable:
  48.         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;
  3. import java.time.LocalDateTime;
  4. import java.time.format.DateTimeFormatter;
  5. import java.util.concurrent.TimeUnit;
  7. /**
  8.  * @description: 等待/唤醒
  9.  * @author: erlang
  10.  * @since: 2021-02-04 21:38
  11.  */
  12. public class WaitNotifyThread {
  14.     static boolean flag = true;
  16.     final static Object LOCK = new Object();
  18.     final static DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
  20.     public static void main(String[] args) throws InterruptedException {
  21.         Thread waitThread = new Thread(new Wait(), "WaitThread");
  22.         waitThread.start();
  23.         TimeUnit.SECONDS.sleep(1);
  24.         Thread notifyThread = new Thread(new Notify(), "NotifyThread");
  25.         notifyThread.start();
  26.     }
  28.     static class Wait implements Runnable {
  29.         @Override
  30.         public void run() {
  31.             // 加锁，获取 LOCK 对象的 Monitor
  32.             synchronized (LOCK) {
  33.                while (flag) {
  34.                    try {
  35.                        System.out.println(Thread.currentThread().getName() + " flag is true. wait @ " + LocalDateTime.now().format(FORMATTER));
  36.                        // 等待的同时，释放锁
  37.                        LOCK.wait();
  38.                    } catch (InterruptedException e) {
  40.                    }
  41.                }
  42.             }
  44.             System.out.println(Thread.currentThread().getName() + " flag is false. running @ " + LocalDateTime.now().format(FORMATTER));
  45.         }
  46.     }
  48.     static class Notify implements Runnable {
  49.         @Override
  50.         public void run() {
  51.             // 加锁，获取 LOCK 对象的 Monitor
  52.             synchronized (LOCK) {
  53.                 // 获取 LOCK 的锁，然后进行通知，通知时不会释放 LOCK 的锁
  54.                 // 直到当前线程释放了 LOCK 之后，WaitThread 才能从 wait 方法中返回
  55.                 System.out.println(Thread.currentThread().getName() + " lock. notifyAll @ " + LocalDateTime.now().format(FORMATTER));
  56.                 LOCK.notify();
  57.                 flag = false;
  58.                 try {
  59.                     TimeUnit.SECONDS.sleep(3);
  60.                 } catch (InterruptedException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  65.             // 获取 LOCK 锁
  66.             synchronized (LOCK) {
  67.                 System.out.println(Thread.currentThread().getName() + " lock. sleep @ " + LocalDateTime.now().format(FORMATTER));
  68.                 try {
  69.                     TimeUnit.SECONDS.sleep(2);
  70.                 } catch (InterruptedException e) {
  71.                     e.printStackTrace();
  72.                 }
  73.             }
  74.         }
  75.     }
  76. }

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

  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. }