文章目录
- 4.3 线程间通信
- 4.3.1 volatile和synchronized 关键字
- 4.3.2 等待/通知机制
- 4.3.3 等待/通知的经典范式
- 4.3.4 管道输入 / 输出流
- 4.3.5 Thread.join()的使用
- 4.3.6 ThreadLocal的使用
4.3 线程间通信
线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一步一步地执行，直到终止。但是，每个运行中的线程，如果仅仅是孤立地运行，那么没有一点儿价值，或者说价值很少，如果多个线程能够相互配合完成工作，这将会带来巨大的价值。
4.3.1 volatile和synchronized 关键字
Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个变量的拷贝(虽然对象以及成员变量分配的内存是在共享内存中的，但是每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行，这是现代多核处理器的一个显著特性)，所以程序在执行过程中，一个线程看到的变量并不一定是最新的。
关键字 volatile 可以用来修饰字段(成员变量)，就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。
举个例子，定义一个表示程序是否运行的成员变量boolean on=true，那么另一个线程可能对它执行关闭动作(on=false)，这里涉及多个线程对变量的访问，因此需要将其定义成为volatile boolean on=true，这样其他线程对它进行改变时，可以让所有线程感知到变化，因为所有对on变量的访问和修改都需要以共享内存为准。但是，过多地使用 volatile是不必要的，因为它会降低程序执行的效率。
关键字sychronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可则性和排他性。
在下面代码中，使用了同步块和同步方法，通过使用javap工具查看生成的class文件信息来分析synchronized关键字的实现细节，示例如下：
public class Synchronized {
public static void main(String[] args) {
// 对Synchronized Class对象进行加锁
synchronized (Synchronized.class) {
}
// 静态同步方法，对Synchronized Class对象进行加锁
m();
}
public static synchronized void m() {
}
}
打开cmd，在 Synchronized.class 所在目录执行javap -v Synchronized.class（即javap -verbose Synchronized.class），部分输出如下：
D:\project1\java8\java8\xin-javademo\target\classes\com\xin\demo\threaddemo\bookdemo>javap -v Synchronized.class
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC // 方法修饰符
Code:
stack=2, locals=3, args_size=1
0: ldc #2 // class com/xin/demo/threaddemo/bookdemo/Synchronized
2: dup
3: astore_1
4: monitorenter // 监视器进入，获取锁
5: aload_1
6: monitorexit // 监视器退出，释放锁
7: goto 15
10: astore_2
11: aload_1
12: monitorexit
13: aload_2
14: athrow
15: invokestatic #3 // Method m:()V
18: return
public static synchronized void m();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED // 方法修饰符
Code:
stack=0, locals=0, args_size=0
0: return
LineNumberTable:
line 14: 0
}
SourceFile: "Synchronized.java"
上面class信息中，对于同步块的实现使用了monitorenter和monitorexit指令，而同步方法则是依靠方法修饰符上的ACC_SYNCHRONIZED来完成的。无论采用哪种方式，其本质是对一个对象的监视器(monitor)进行获取，而这个获取过程是排他的，也就是同一时刻只能有一个线程获取到由synchronized 所保护对象的监视器。
任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法、而没有获取到监视器(执行该方法)的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。
下图描述了对象、对象的监视器、同步队列和执行线程之间的关系。
从上图可以看到，任意线程对Object(Object由synchronized保护)的访问，首先获得Obiect的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱(获得了锁的线程)释放了锁，则该释放操作唤醒阻塞在同步队列中的线程使其重新尝试对监视器的获取。
4.3.2 等待/通知机制
一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”(what)和“怎么做”(How)，在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在Java语言中如何实现类似的功能呢?
简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。
while (value != desire) {
Thread.sleep(1000);
}
doSomething();
上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够解实现所需的功能，但是却存在如下问题。
- 1. 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
- 2. 难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。
等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.0bject上，方法和描述如下表所示。
等待/通知的相关方法：
| 方法名称 | 描述 |
|---|---|
| notify() | 通知一个在对象上等待的线程，使其从wait()方法返回，而返回的前提是该线程获取到了对象的锁 |
| notifyAll() | 通知所有等待在该对象上的线程 |
| wait() | 调用该方法的线程进入WAITING状态，只有等待另外线程的通知或被中断才会返圆，需要注意，调用wait()方法后，会释放对象的锁 |
| wait(long) | 超时等待一段时间，这里的参数时间是毫秒，也就是等待长达n秒，如果没有通知就超时返回 |
| wait(long, int) | 对于超时时间更细粒度的控制，可以达到纳秒 |
等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态。而另一个线程B调用了对象〇的notify()或者 notifyAll()方法，线程A收到通知后从对象O的 wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对对象上的wait()和notify()/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之同的交互工作。
在如下代码中，创建了两个线程–WaitThread和NotifyThread，前者检查flag值是否为false，如果符合要求，进行后续操作，否则在lock上等待，后者在睡眠了一段时间后对lock进行通知。
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
public class WaitNotify {
static boolean flag = true;
static Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
Thread waitThread = new Thread(new Wait(), "WaitThread");
waitThread.start();
TimeUnit.SECONDS.sleep(1);
Thread notifyThread = new Thread(new Notify(), "NotifyThread");
notifyThread.start();
}
static class Wait implements Runnable {
@Override
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
// 当条件不满足时，继续wait，同时释放了1ock的锁
while (flag) {
try {
System.out.println(Thread.currentThread() + " flag is true. wait@ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.wait();
} catch (InterruptedException e) {
}
}
// 条件满足时，完成工作
System.out.println(Thread.currentThread() + " flag is false. running@ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
}
static class Notify implements Runnable {
@Override
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
// 获取lock的锁，然后进行通知，通知时不会释放lock的锁
// 直到当前线程释放了lock后，WaitThread才能从wait方法中返回
System.out.println(Thread.currentThread() + " hold lock. notify@ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.notifyAll();
flag = false;
SleepUtils.second(5);
}
// 再次加锁
synchronized (lock) {
System.out.println(Thread.currentThread() + " hold lock again. sleep@ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
SleepUtils.second(5);
}
}
}
}
打印：
Thread[WaitThread,5,main] flag is true. wait@ 00:44:15
Thread[NotifyThread,5,main] hold lock. notify@ 00:44:16
Thread[NotifyThread,5,main] hold lock again. sleep@ 00:44:21
Thread[WaitThread,5,main] flag is false. running@ 00:44:26
上述第3行和第4行输出的顺序可能会互换，而上述例子主要说明了调用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()方法，从而放弃了锁并进人了对象的等待队列 WaitQueue 中，进入等待状态。由于 WaitThread 释放了对象的锁，NotifyThread 随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从 WaitQueue移到 SynchronizedQueue中，此时WaitThread 的状态变为阻塞状态。NotifyThread 释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。
4.3.3 等待/通知的经典范式
从4.3.2节中的WaitNotify示例中可以提炼出等待/通知的经典范式，该范式分为两部分，分别针对等待方(消费者)和通知方(生产者)。
等待方遵循如下原则。
- 获取对象的锁。
- 如果条件不满足，那么调用对象的 wait()方法，被通知后仍要检查条件。
- 条件满足则执行对应的逻辑。
对应的伪代码如下。
synchronized(对象) {
while() {
对象.wait();
}
对应的处理逻辑
}
通知方遵循如下原则。
- 获得对象的锁。
- 改变条件。
- 通知所有等待在对象上的线程。
对应的伪代码如下。
synchronized(对象) {
改变条件
对象.notifyAll();
}
4.3.4 管道输入 / 输出流
管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
管道输人/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、PipedReader和 PipedWriter，前两种面向字节，而后两种面向字符。
在下面代码中，创建了printThread，它用来接受main 线程的输入，任何main 线程的输入均通过 PipedWriter写人，而printThread在另一端通过 PipedReader将内容读出并打印。
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
public class Piped {
public static void main(String[] args) throws Exception {
PipedWriter out = new PipedWriter();
PipedReader in = new PipedReader();
// 将输出流和输入流进行连接，否则在使用时会抛出IOException
out.connect(in);
Thread printThread = new Thread(new Print(in), "PrintThread");
printThread.start();
int receive = 0;
try {
while ((receive = System.in.read()) != -1) {
out.write(receive);
}
} finally {
out.close();
}
}
static class Print implements Runnable {
private PipedReader in;
public Print(PipedReader in) {
this.in = in;
}
@Override
public void run() {
int receive = 0;
try {
while ((receive = in.read()) != -1) {
System.out.println((char) receive);
}
} catch (IOException ex) {
}
}
}
}
运行该示例，输人一组字符串，可以看到被 printThread 进行了原样输出。
Repeat my words.
Repeat my words.
对于 Piped 类型的流，必须先要进行绑定，也就是调用connect()方法，如果没有将输入/输出流绑定起来，对于该流的访问将会抛出异常。
4.3.5 Thread.join()的使用
如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从 thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和 join(long millis, int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程tread在给定的超时时间里没有终止，那么将会从该超时方法中返回。
在下面代码中，创建了10个线程，编号0~9，每个线程调用前一个线程的join()方法，也就是线程0结束了，线程1才能从join()方法中返回，而线程0需要等待 main 线程结束。
public class Join {
public static void main(String[] args) {
Thread previous = Thread.currentThread();
for (int i = 0; i < 10; i++) {
// 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
Thread thread = new Thread(new Domino(previous), String.valueOf(i));
thread.start();
previous = thread;
}
}
static class Domino implements Runnable {
private Thread thread;
public Domino(Thread thread) {
this.thread = thread;
}
@Override
public void run() {
try {
thread.join();
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + " terminate.");
}
}
}
打印：
0 terminate.
1 terminate.
2 terminate.
3 terminate.
4 terminate.
5 terminate.
6 terminate.
7 terminate.
8 terminate.
9 terminate.
从上述输出可以看到，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从join()方法返回，这里涉及了等待/通知机制(等待前驱线程结束，接收前驱线程结束通知)。
下面代码是JDK中Thread.join()方法的源码(进行了部分调整)。
public final synchronized void join() throws InterruptedException {
// 条件不满足，继续等待
while (isAlive) {
wait(0);
}
// 条件符合，方法返回
}
当线程终止时，会调用线程自身的nofityAll()方法，会通知所有等待在该线程对象上的线程、可以看到join()方法的逻辑结构与4.3.3节中描述的等待/通知经典范式一致，即加锁、循环和处理逻辑3个步骤。
4.3.6 ThreadLocal的使用
ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存铙结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。
可以通过set(T) 方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。
在下面代码中，构建了一个常用的 Profiler类，它具有 begin() 和 end()两个方法，而end()方法返回从begin()方法调用开始到end()方法被调用时的时间差，单位是毫秒。
import java.util.concurrent.TimeUnit;
public class Profiler {
private static final ThreadLocal<Long> TIME_THREADLOCAL = new ThreadLocal() {
protected Long initialValue() {
return System.currentTimeMillis();
}
};
public static final void begin() {
TIME_THREADLOCAL.set(System.currentTimeMillis());
}
public static final long end() {
return System.currentTimeMillis() - TIME_THREADLOCAL.get();
}
public static void main(String[] args) throws InterruptedException {
Profiler.begin();
TimeUnit.SECONDS.sleep(1);
System.out.println("Cost: " + Profiler.end() + " mills");
}
}
打印：
Cost: 1000 mills
Profiler可以被复用在方法调用耗时统计的功能上，在方法的入口前执行begin()方法，在方法调用后执行end()方法，好处是两个方法的调用不用在一个方法或者类中、比如在AOP(面向方面编程)中，可以在方法调用前的切人点执行begi0方法，而在方法调用后的切入点执行end()方法，这样依旧可以获得方法的执行耗时。
