Java 线程间通信

⭐写在前面⭐

? 内容回顾
Java 多线程介绍及线程创建
Java 多线程七大状态
Java 多线程方法详解
Java synchronized关键字实现线程同步
?今天我们进行 JDBC 获取数据库连接的5种方式 的学习，感谢你的阅读，内容若有不当之处，希望大家多多指正，一起进步?！！！
♨️如果觉得博主文章还不错，可以?三连支持⭐一下哦?

☘️Java 线程间通信

?线程通信方法

在Java的Object类中提供了wait、notify、notifyAll等方法，这些方法可以实现线程间的通信，因为Object类是所有类的基类，因此所有的对象都具有线程间通信的方法。

void wait():调用一个对象的wait方法，会导致当前持有该对象的锁的线程等待，直到该对象的另一个持有锁的线程调用notify或者notifyAll唤醒。

void wait(long timeout):除了和wait相似，还具有超过定时的超时时间，时间到后或自动唤醒。

void wait(long timeout,int nanou):与 void wait(long timeout) 相同，不过提供了纳秒级别的更精确的超时控制。

void notify():调用一个对象的notify方法，会导致当前持有该锁的所有线程中的随机某一个线程被唤醒。

void notifyAll():调用一个对象的notifyAll方法，会导致当前持有该锁的所有线程被唤醒。

?线程间通信案例

通信是在不同线程间的通信，一个线程处于wait状态阻塞等待被唤醒，另一个线程通过notify或者notifyAll唤醒，当前的唤醒操作必须是作用与同一个对象，注意在进行唤醒和阻塞时必须要加锁的，加锁需要使用synchronized关键字。

WaitDemo类

public class WaitDemo extends Thread{ 
    private Object obj; public WaitDemo(Object obj) { 
    this.obj = obj; } @Override public void run() { 
    synchronized (obj) { 
    System.out.println(Thread.currentThread().getName() + "WaitDemo执行开始~~~"); try { 
    obj.wait(); //调用wait方法阻塞线程执行 } catch (InterruptedException e) { 
    e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "WaitDemo执行结束~~~"); } } } 

NotifyDemo类

public class NotifyDemo extends Thread{ 
    private Object obj; public NotifyDemo(Object obj) { 
    this.obj = obj; } @Override public void run() { 
    synchronized (obj) { 
    System.out.println(Thread.currentThread().getName() + "NotifyDemo执行开始~~~"); try { 
    Thread.sleep(1000); } catch (InterruptedException e) { 
    e.printStackTrace(); } obj.notify(); //调用notify方法唤醒阻塞线程 System.out.println(Thread.currentThread().getName() + "NotifyDemo执行结束~~~"); } } } 

TestWaitAndNotify测试类

public class TestWaitAndNotify { 
    public static void main(String[] args) { 
    Object object = new Object(); WaitDemo waitDemo = new WaitDemo(object); NotifyDemo notifyDemo = new NotifyDemo(object); waitDemo.setName("WaitDemo线程"); notifyDemo.setName("NotifyDemo线程"); waitDemo.start(); notifyDemo.start(); } } 

?执行结果：

?使用注意点

?调用notify和wait方法必须是作用于同一个对象，如果不是通一个对象则无法完成通信。
?对于wait、nitify、notifyAll的调用，必须在该对象的同步方法或者代码块中，锁作用的对象和wait等方法必须是作用于同一个对象。
?wait方法在调用后进入阻塞之前会释放锁，而sleep和join是不会释放锁的。
?线程状态转换时，当wait被唤醒或者超时时，线程并不是直接进入就绪状态，而是先进入阻塞状态，抢锁成功后才能进入到可运行状态。

?注意点详解

注意点1 当锁的对象和调用wait、notify的对象不是同一个对象时，会抛出IllegalMonitorStateException异常。

注意点2 wait方法在调用进入阻塞之前会释放锁

基于以上分析，一旦wait线程先调用则线程因为锁无法继续执行而阻塞下来，实际上notify依然可以获取锁进行执行，这是因为wait方法在调用进入阻塞之前释放锁，则调用notify操作的线程就可以抢到Object对象的锁，进而调用notify。

注意点3 锁池和等待池

锁池：假设线程A已经拥有了某个对象的锁，而其他的线程想要调用这个对象的某个synchronized方法，由于这些线程在进入对象的synchronized方法之前必须先获取该对象的锁的拥有权，但是该对象的锁目前被线程A拥有，所以这些线程就回去进入到该对象的锁池
等待池：假设一个线程A调用某个对象的wait方法，线程A就会释放该对象的锁后，进入到该对象的等待池

?小试牛刀

?有三个线程，分别为ABC线程，需要线程交替打印：ABCABC…打印10遍
? 分析：需要使用线程间的通信，A给B通信，A进行notifyB进行wait；B给C通信，B进行notifyC进行Wait；同理C给A通信，C进行notifyA进行wait。

? 思路分析：给每个线程给定编号，表明是第几个进程，再给定一个共享对象，共享对象进行notify、wait等操作，共享对象本身需要携带信息表明下一个执行的线程编号，如果当前线程的编号与共享对象中的信息比较，如果相等就执行，否则就阻塞。

?代码示例

NextOpt类：共享对象，携带下一个要执行的线程编号信息

//共享对象，携带下一个要执行的线程编号信息 public class NextOpt { 
    //下一个执行线程编号 private Integer nextValue; public Integer getNextValue() { 
    return nextValue; } public void setNextValue(Integer nextValue) { 
    this.nextValue = nextValue; } } 

ThreadABC类

public class ThreadABC extends Thread { 
    //线程间通信对象 private NextOpt opt; //打印名称通过数组获取 private String[] abc = { 
   "A", "B", "C"}; //线程编号 private int index; //执行次数 int count = 0; public ThreadABC(NextOpt opt, int index) { 
    this.opt = opt; this.index = index; } @Override public void run() { 
    while (true) { 
    //如果当前线程编号与下一个要执行的序号不一致就阻塞 synchronized (opt) { 
    while (opt.getNextValue() != index) { 
    try { 
    opt.wait(); } catch (InterruptedException e) { 
    e.printStackTrace(); } } //打印 System.out.print(abc[index]); //设置下一个要执行的线程的编号 opt.setNextValue((index + 1) % 3); //唤醒所有的阻塞线程 opt.notifyAll(); if (count++ > 9) { 
    break; } } } } } 

TestThreadABC测试类

public class TestThreadABC { 
    public static void main(String[] args) { 
    NextOpt opt = new NextOpt(); opt.setNextValue(0); //设置第一个要执行的线程编号 ThreadABC thread1 = new ThreadABC(opt,0); ThreadABC thread2 = new ThreadABC(opt,1); ThreadABC thread3 = new ThreadABC(opt,2); thread1.start(); thread2.start(); thread3.start(); } } 

运行结果：

?生产者消费者模型

线程间通信典型案例：生产者消费者模型

编写一个生产者、消费者模型，给定要求：一个生产者、一个消费者、仓库是三个

生产者

public class Producer extends Thread{ 
    private LinkedList<Integer> cap;//共享仓库 private Random random = new Random(); public Producer(LinkedList<Integer> cap) { 
    this.cap = cap; } @Override public void run() { 
    while (true) { 
    synchronized (cap){ 
    if (cap.size() == 3) { 
   //缓冲区满 生产者进行阻塞 try { 
    cap.wait(); } catch (InterruptedException e) { 
    e.printStackTrace(); } } //生产产品 int i = random.nextInt(1000); System.out.println("生产者生产了" + i); cap.add(i); //通知消费者消费产品 cap.notify(); } } } } 

消费者

public class Consumer extends Thread{ 
    private LinkedList<Integer> cap; public Consumer(LinkedList<Integer> cap) { 
    this.cap = cap; } @Override public void run() { 
    while (true) { 
    synchronized (cap) { 
    if (cap.size() == 0) { 
    //如果缓冲区为0，消费者阻塞 try { 
    cap.wait(); } catch (InterruptedException e) { 
    e.printStackTrace(); } } //消费者消费产品 Integer i = cap.remove(); System.out.println("消费者消费了" + i); //通知生产者生产 cap.notify(); } } } } 

测试类

public class Test { 
    public static void main(String[] args) { 
    LinkedList<Integer> cap = new LinkedList<>(); Producer producer = new Producer(cap); Consumer consumer = new Consumer(cap); producer.start(); consumer.start(); } } 

运行结果