Java多线程 - 线程间通信

Contents
  1. 等待/通知(wait/notify)机制
    1. 什么是等待/通知机制
    2. 等待/通知机制的实现
    3. 线程状态切换总结
    4. 生产者-消费者模型
      1. 一生产与一消费
      2. 多生产与多消费
      3. 解决“假死”的解决方案
    5. 通过管道进行线程间通信:字节流和字符流
  2. 方法join的使用
  3. 类ThreadLocal的使用
    1. 解决第一次取值为null的问题
    2. 类InheritableThreadLocal的使用

使线程间进行通信后,系统之间的交互性会更强大,在大大提高CPU利用率的同时,还会使程序员对各线程任务在处理的过程中进行有效的把控和监督。

技术点:

  • 使用wait/notify实现线程间通信;
  • 生产者/消费者模式的实现;
  • 方法join的使用;
  • ThreadLocal类的使用。

等待/通知(wait/notify)机制

线程与线程之间不是独立的个体,它们彼此之间可以互相通信和协作。

前面也说过多个线程之间可以实现通信,原因就是多个线程共同访问同一个变量,但那种通信机制不是wait/notify,两个线程完全是主动式地读取一个共享变量,在花费读取时间的基础上,读到的值是不是想要的,并不能完全确定。所以迫切的需要一种wait/notify的机制来满足上述要求。

什么是等待/通知机制

等待/通知机制在生活中比比皆是,比如就餐时会有几个问题:

wait_notify_dinner

  1. 厨师做完一道菜的时间不确定,所以厨师将菜品放到“菜品传递台”上的时间也不确定;
  2. 服务员取到菜的时间取决于厨师,所以服务员就有“等待”状态;
  3. 服务员如何才能取到菜呢?这又得取决于厨师,厨师将菜放到“菜品传递台”上,其实就相当于一种“通知”,这时服务员才可以拿到菜并交给就餐者

等待/通知机制的实现

wait():

  • 方法wait()的作用是使当前执行代码的线程进行等待,wait()方法时Object类的方法,该方法用来将当前线程置入“预执行队列”之中,并且在wait()所在的代码行处停止执行,直到接到通知或被中断为止;
  • 在调用wait()之前,线程必须获得该对象的对象级别锁,即只能在同步方法或同步块中调用wait()方法;
  • 在执行wait()方法后,当前线程释放锁;
  • 在从wait()返回前,线程与其他线程竞争重新获得锁
  • 如果调用wait()时没有持有适当的锁,则抛出IllegalMonitorStateException,它是RuntimeException的一个子类,因此,不需要try-catch语句进行捕获异常。

notify():

  • 方法notify()也要在同步方法或同步块中调用,即在调用前,必须获得该对象的对象级别锁,如果调用notify()时没有持有适当的锁,也会抛出IllegalMonitorStateException;
  • 该方法用来通知那些可能等待该对象的对象锁的其他线程;
  • 如果有多个线程等待,则由线程规划器挑选出其中一个呈wait状态的线程,对其发出通知notify,并使它等待获取该对象的对象锁。

需要说明的是,在执行notify()方法后,当前线程不会马上释放该对象锁,呈wait状态的线程也并不能马上获取该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出synchronized代码块后,当前线程才会释放锁,而呈wait状态的线程才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕之后,它会释放掉该对象锁,此时如果该对象没有再次使用notify语句,则即便该对象已经空闲,其他wait状态等待的线程由于没有接到该对象的通知,还会继续阻塞在wait状态,直到这个对象发出一个notify或notifyAll

总结:

  • wait()方法可以使调用该方法的线程释放共享资源的锁,然后从运行状态退出,进入等待队列,直到被再次唤醒;
  • notify()方法可以随机唤醒等待队列中等待同一共享资源的“一个”线程,并使该线程退出等待队列,进入可运行状态,当前线程继续运行至执行完,也就是notify()方法仅通知“一个”线程;
  • notifyAll()方法可以使所有正在等待队列中等待同一共享资源的“全部”线程从等待状态退出,进入可运行状态。此时,优先级最高的那个线程最先执行,但也有可能是随机执行,这取决于JVM的实现。

线程状态切换总结

前面已经介绍了与Thread有关的大部分API,这些API可以改变线程的状态,如下图所示:

thread_status_transform

1.新创建一个线程对象后,再调用它的start()方法,系统会为此线程分配CPU资源,使其处于Runnable(可运行)状态,这是一个准备运行的阶段。如果线程抢占到了CPU资源,此线程就处于Running状态。

2.Runnable状态和Running状态可以互相切换,因为有可能线程运行一段时间后,有其他高优先级的线程抢占了CPU资源,此时线程就从Running状态变为了Runnable状态。
线程进入Runnable状态大体分为以下5种情况:

  • 调用sleep()方法后经过的时间超过了指定的休眠时间;
  • 线程调用阻塞IO已经返回,阻塞方法执行完毕;
  • 线程成功获得了同步的监视器;
  • 线程正在等待某个通知,其他线程发出了通知;
  • 处于挂起状态的线程调用了resume方法。

3.Blocked是阻塞的意思,例如遇到了一个IO操作,此时CPU会处于空闲状态,可能会转而把CPU时间片分配给其他线程,这时可以成为“暂停”状态。Blocked状态结束后,进入Runnable状态,等待系统重新分配资源。
出现阻塞的情况大体分为5种:

  • 线程调用sleep()方法,主动放弃占用的CPU资源;
  • 线程调用了阻塞式IO方法,在该方法返回前,该线程被阻塞;
  • 线程试图获得一个同步监视器(锁),但该同步监视器正在被其他线程所占有;
  • 线程等待某个通知(处于wait);
  • 程序调用了suspend方法将该线程挂起,但此方法容易造成死锁,尽量避免使用此方法。

4.run()方法运行结束后进入销毁阶段,整个线程执行完毕。

每个锁对象都有两个队列,一个是就绪队列,一个是阻塞队列。就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程。一个线程被唤醒后,才会进入就绪队列,等待CPU的调度;反之,一个线程被wait后,就会进入阻塞队列,等待下一次被唤醒。

生产者-消费者模型

一生产与一消费

生产者类:

productor

消费者类:

consumer

1生产者和1消费者进行交互,结果是交替进行的。

多生产与多消费

多生产与多消费在运行过程中极有可能出现“假死”的情况,“假死”的现象其实就是线程进入WAITING状态。如果全部线程都进入WAITING状态,则程序就不再执行任何业务功能了,整个项目呈停止状态。

这是因为:在代码中确实通过wait/notify进行通信了,但不保证notify唤醒的是异类,也许是同类,比如“生产者”唤醒“生产者”,或“消费者”唤醒“消费者”这样的情况。如果按照这样的情况运行的比率增多,就会导致所有的线程都不能继续运行下去,大家都在等待,呈WAITING状态,程序最后也就呈“假死”状态,不能运行下去了。

解决“假死”的解决方案

解决“假死”的情况很简单,就是将所有的notify()改成notifyAll()方法即可,它的原理就是不光通知同类线程,也包括异类。这样就不会出现“假死”状态了。

通过管道进行线程间通信:字节流和字符流

在Java语言中提供了各种各样的输入/输出流Stream,使我们能够很方便地对数据进行操作,其中管道流(pipeStream)是一种特殊的流,用于在不同线程间直接传送数据。一个线程发送数据到输出管道,另一个线程从输入管道中读数据。通过使用管道,实现不同线程间的通信,而无须借助于类似临时文件之类的东西。

JDK中提供了4个类来使线程间可以进行通信:

  1. PipedInputStream和PipedOutputStream
  2. PipedReader和PipedWriter

方法join的使用

在很多情况下,主线程创建并启动子线程,如果子线程中要进行大量的耗时运算,主线程往往早于子线程结束之前结束。这时,如果主线程想等待子线程执行完成之后再结束,比如子线程处理一个数据,主线程要获得这个数据中的值,就要用到join()方法了。方法join()的作用是等待线程对象销毁。

方法join()的作用是使所属的线程对象x正常执行run方法中的任务,而使当前线程z进行无限期的阻塞,等待线程x销毁后再继续执行线程z后面的代码。具有使线程排队运行的作用,有些类似同步的运行效果。

join与synchronized的区别是:join在内部使用wait()方法进行等待,而synchronized关键字使用的是“对象监视器”原理做同步

join(long)与sleep(long)的区别是:

  • join(long)的功能在内部是使用wait(long)方法来实现的,所以join(long)方法具有释放锁的特点;
  • sleep(long)方法不释放锁

类ThreadLocal的使用

变量值的共享可以使用public static的方式,所有的线程都使用一个public static变量。ThreadLocal类实现每一个线程都有自己的共享变量,这些共享变量具有隔离性

类ThreadLocal主要解决的就是每个线程绑定自己的值,可以将ThreadLocal类比喻成全局存放数据的盒子,盒子中可以存储每个线程的私有数据。

解决第一次取值为null的问题

复写initialValue()方法具有初始值。

类InheritableThreadLocal的使用

使用类InheritableThreadLocal可以在子线程中取得父线程继承下来的值(值继承)。

值继承再修改:复写childValue()方法。

但在使用InheritableThreadLocal类需要注意的一点是:如果子线程在取得值的同时,主线程将InheritableThreadLocal中的值进行更改,那么子线程取到的值还是旧值(按照子线程set为准)。