线程的通信和封闭

2019 年 10 月 7 日
筆記

线程通信的方式

要想实现线程之间的协同，如：线程先后执行顺序，获取某个线程的执行结果等，涉及线程之间的相互通信，分为下面四类

文件共享
网络共享
变量共享
JDK提供的线程协调API 细分为：~~suspend/resume~~, wait/notify, park/unpark

文件共享

变量共享

线程协作 – JDK API

典型场景：生产者 – 消费者模型（线程阻塞, 线程唤醒）示例：线程1区买包子，没有包子，则不执行。线程2生产包子，通知线程1继续执行

API – 被弃用的suspend和resume 调用suspend挂起目标线程，通过resume可以恢复线程执行，对调用顺序有要求，也要开发者自己注意锁的释放。这个被弃用的API，容易死锁，也容易导致永久挂起。代码示例：

  /** 正常的suspend/resume */  public void suspendResumeTest() throws Exception {  // 启动线程    Thread consumerThread =  new Thread(  () -> {  if (baozidian == null) { // 如果没包子，则进入等待                System.out.println("1、进入等待");  Thread.currentThread().suspend();  }  System.out.println("2、买到包子，回家");  });  consumerThread.start();  // 3秒之后，生产一个包子    Thread.sleep(3000L);  baozidian = new Object();  consumerThread.resume();  System.out.println("3、通知消费者");  }

  /** 死锁的suspend/resume。 suspend并不会像wait一样释放锁，故此容易写出死锁代码 */  public void suspendResumeDeadLockTest() throws Exception {  // 启动线程    Thread consumerThread =  new Thread(  () -> {  if (baozidian == null) { // 如果没包子，则进入等待                System.out.println("1、进入等待");  // 当前线程拿到锁，然后挂起                synchronized (this) {  Thread.currentThread().suspend();  }  }  System.out.println("2、买到包子，回家");  });  consumerThread.start();  // 3秒之后，生产一个包子    Thread.sleep(3000L);  baozidian = new Object();  // 争取到锁以后，再恢复consumerThread  synchronized (this) {  consumerThread.resume();  }  System.out.println("3、通知消费者");  }

  /** 先执行resume再执行suspend导致程序永久挂起的suspend/resume */  public void suspendResumeDeadLockTest2() throws Exception {  // 启动线程    Thread consumerThread =  new Thread(  () -> {  if (baozidian == null) {  System.out.println("1、没包子，进入等待");  try { // 为这个线程加上一点延时                  Thread.sleep(5000L);  } catch (InterruptedException e) {  e.printStackTrace();  }  // 这里的挂起执行在resume后面                Thread.currentThread().suspend();  }  System.out.println("2、买到包子，回家");  });  consumerThread.start();  // 3秒之后，生产一个包子    Thread.sleep(3000L);  baozidian = new Object();  consumerThread.resume();  System.out.println("3、通知消费者");  consumerThread.join();  }

wait/notify机制

这些方法只能由同一对象锁的线程持有者调用，也就是写在同步代码块里面，否则会抛出IllegalMonitorStateException异常。 wait方法导致当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁 notify/notifyAll唤醒一个/所有正在等待这个对象锁的线程 注意： 虽然wait会自动解锁，但对顺序有要求，如果在notify被调用之后，才开始wait方法的调用，线程会永远处于WAINTING状态代码示例：

/** 正常的wait/notify */  public void waitNotifyTest() throws Exception {  // 启动线程    new Thread(  () -> {  if (baozidian == null) { // 如果没包子，则进入等待                synchronized (this) {  try {  System.out.println("1、进入等待");  this.wait();  } catch (InterruptedException e) {  e.printStackTrace();  }  }  }  System.out.println("2、买到包子，回家");  })  .start();  // 3秒之后，生产一个包子    Thread.sleep(3000L);  baozidian = new Object();  synchronized (this) {  this.notifyAll();  System.out.println("3、通知消费者");  }  }

/** 会导致程序永久等待的wait/notify */  public void waitNotifyDeadLockTest() throws Exception {  // 启动线程    new Thread(  () -> {  if (baozidian == null) { // 如果没包子，则进入等待                try {  Thread.sleep(5000L);  } catch (InterruptedException e1) {  e1.printStackTrace();  }  synchronized (this) {  try {  System.out.println("1、进入等待");  this.wait();  } catch (InterruptedException e) {  e.printStackTrace();  }  }  }  System.out.println("2、买到包子，回家");  })  .start();  // 3秒之后，生产一个包子    Thread.sleep(3000L);  baozidian = new Object();  synchronized (this) {  this.notifyAll();  System.out.println("3、通知消费者");  }  }

park/unpark机制

线程调用park则等待“许可”， unpark方法为指定线程提供“许可”。不要求park和unpark方法的调用顺序。多次调用unpark后再调用park，线程会直接运行，但不会叠加，也就是说，连续多次调用park方法，第一次会拿到“许可”直接运行，后续调用会进入等待。 注意： park/unpark 对调用顺序没有要求，但是并不会释放锁代码示例：

/** 正常的park/unpark */  public void parkUnparkTest() throws Exception {  // 启动线程    Thread consumerThread =  new Thread(  () -> {  if (baozidian == null) { // 如果没包子，则进入等待                System.out.println("1、进入等待");  LockSupport.park();  }  System.out.println("2、买到包子，回家");  });  consumerThread.start();  // 3秒之后，生产一个包子    Thread.sleep(3000L);  baozidian = new Object();  LockSupport.unpark(consumerThread);  System.out.println("3、通知消费者");  }

 /** 死锁的park/unpark */  public void parkUnparkDeadLockTest() throws Exception {  // 启动线程    Thread consumerThread =  new Thread(  () -> {  if (baozidian == null) { // 如果没包子，则进入等待                System.out.println("1、进入等待");  // 当前线程拿到锁，然后挂起                synchronized (this) {  LockSupport.park();  }  }  System.out.println("2、买到包子，回家");  });  consumerThread.start();  // 3秒之后，生产一个包子    Thread.sleep(3000L);  baozidian = new Object();  // 争取到锁以后，再恢复consumerThread  synchronized (this) {  LockSupport.unpark(consumerThread);  }  System.out.println("3、通知消费者");  }

伪唤醒

之前代码中用if语句来判断是否进入等待是错误的 官方建议应该在循环中检查条件，原因是处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出 伪唤醒：指线程并非因为notify, notifyAll, unpark等API调用而唤醒，是更底层的原因导致的。

线程封闭

多线程访问共享可变数据时，并不是所有的时候，都要用到共享数据，所以线程封闭的概念就提了出来。所谓线程封闭，就是指数据都封闭在各自的线程之中，不需要不需要同步。线程封闭的具体的实现主要有ThreadLocal和局部变量

ThreadLocal

ThreadLocal是Java里一种特殊的变量，一个线程级别的变量，每个线程都有一个自己独立的ThreadLocal变量。它的竞争条件被彻底消除，在并发模式下是绝对安全的。用法：ThreadLocal<T> var = new ThreadLocal<T>(); 会自动在每个线程上创建一个T的副本，副本之间彼此独立，互不影响。可以用ThreadLocal存储一些参数，以便在线程中多个方法中使用，用来代替方法传参的的做法代码示例：

/** 线程封闭示例 */  public class Demo6 {  /** threadLocal变量，每个线程都有一个副本，互不干扰 */  public static ThreadLocal<String> value = new ThreadLocal<>();  /**  * threadlocal测试   *  * @throws Exception  */  public void threadLocalTest() throws Exception {  // threadlocal线程封闭示例    value.set("这是主线程设置的123"); // 主线程设置值    String v = value.get();  System.out.println("线程1执行之前，主线程取到的值：" + v);  new Thread(  new Runnable() {  @Override  public void run() {  String v = value.get();  System.out.println("线程1取到的值：" + v);  // 设置 threadLocal  value.set("这是线程1设置的456");  v = value.get();  System.out.println("重新设置之后，线程1取到的值：" + v);  System.out.println("线程1执行结束");  }  })  .start();  Thread.sleep(5000L); // 等待所有线程执行结束    v = value.get();  System.out.println("线程1执行之后，主线程取到的值：" + v);  }  public static void main(String[] args) throws Exception {  new Demo6().threadLocalTest();  }  }

输出结果：

线程1执行之前，主线程取到的值：这是主线程设置的123  线程1取到的值：null  重新设置之后，线程1取到的值：这是线程1设置的456  线程1执行结束  线程1执行之后，主线程取到的值：这是主线程设置的123

栈封闭

局部变量的固有属性之一就是封闭在线程中它们位于执行线程的栈中，其他线程无法访问这个栈