线程通信 / 四六文摘

线程通信的方式

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

文件共享
网络共享
变量共享
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调用而唤醒，是更底层的原因导致的。

线程通信

线程通信的方式

文件共享

变量共享

线程协作 - JDK API

wait/notify机制

park/unpark机制

伪唤醒

相关推荐