java 中 wait 和 notify 线程通信举例说明

测试账号 2021-01-19 17:13 484阅读 0赞

# 前言： #

等待/通知机制主要由Object类中的wait()、notify() 和 notifyAll()三个方法来实现，这三个方法均非Thread类中所声明的方法，而是Object类中声明的方法；原因是每个对象都拥有monitor（锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作，而不是用当前线程来操作

**wait()——让当前线程释放对象锁并进入等待（阻塞）状态，在调用wait方法之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait方法。**

**notify()——唤醒一个正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行，和wait方法一样，线程也必须获得该对象的对象级别锁，也只能在同步方法或同步块中调用。**

**notifyAll()——唤醒所有正在等待相应对象锁的所有线程，其它和notify一样。**

## 一、举例说明 ##

这里举一个生产面包和销售面包的例子，代码如下

1. 声明一个面包类

public class Bread {
        public String name;
        public int num;
    
        Bread(String name, int num) {
            System.out.println("面包名称：" + name + ", 初始化数量：" + num);
            this.name = name;
            this.num = num;
        }
    }

2. 声明一个生产面包的类，produce() 方法每次调用会生产一个面包，其调用受run()方法控制。

3. 声明一个售卖面包的类，sale() 方法每次调用会销售一个面包，其调用受run()控制

public class BreadSale implements Runnable {
        private final Bread bread;
    
        BreadSale(Bread bread) {
            this.bread = bread;
        }
    
        private void sale() {
    
            bread.num = bread.num - 1;
            System.out.println("面包售卖一个，当前剩余：" + bread.num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void run() {
    
            synchronized (bread) {
                if (bread.num <= 0) {
                    System.out.println("面包已卖完，等待生产");
                    try {
                        bread.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                } else {
                    sale();
                    bread.notifyAll();   // 调用销售方法以后会唤醒wait等待的线程
                }
            }
        }
    }

4. 写一个测试方法

package thread.wait;
    
    public class Main {
        public static void main(String[] args) throws InterruptedException {
            Bread bread = new Bread("土司", 1);
            BreadProducer breadProducer = new BreadProducer(bread, 2);
            BreadSale breadSale = new BreadSale(bread);
            Thread tp = new Thread(breadProducer);
            Thread ts = new Thread(breadSale);
    
            ts.start();
            tp.start();
        }
    }

结果（两个线程启动顺序不同结果不同）：

面包名称：土司, 初始化数量：1
    面包售卖一个，当前剩余：0
    ---------------
    面包生产1个,当前数量：1

根据上面的输出，可以判断：

1). 线程ts先启动执行，调用 BreadSale 中的run()方法，run()方法调用 sale() 方法，而后唤醒所有等待bread锁的进程（看结果唤醒的是 tp 进程），而后该线程逐步结束

2). 线程tp启动后调用 BreadProducer 中的run()方法，run()方法调用 produce() 方法，而后唤醒所有等待bread锁的进程（这时候tp已经结束，没有线程等待，所以直接结束了）

## 二、举例延申 ##

考虑到上述是生产面包售卖面包是一个持续的变化过程（即通常描述的生产-消费模式），可以对两个多线程类稍加改造，加入while(true) 的循环，这样就能一直持续这种生产-销售过程。

public class BreadProducer implements Runnable {
        private final Bread bread;
        private int maxNum;
    
        BreadProducer(Bread bread, int maxNum) {
            this.bread = bread;
            this.maxNum = maxNum;
        }
    
        public void produce() {
            bread.num = bread.num + 1;
            System.out.println("面包生产1个,当前数量：" + bread.num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void run() {
    
            synchronized (bread) {
                while (true) {
                    if (bread.num >= maxNum) {
                        System.out.println("面包生产数量达到巅峰，停止生产，等待卖出");
                        try {
                            System.out.println("***************");
                            bread.wait();
    
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("---------------");
                        produce();
                        bread.notifyAll();
                    }
    
                }
            }
        }
    
    }
    
    
    
    
    
    
    public class BreadSale implements Runnable {
        private final Bread bread;
    
        BreadSale(Bread bread) {
            this.bread = bread;
        }
    
        private void sale() {
    
            bread.num = bread.num - 1;
            System.out.println("面包售卖一个，当前剩余：" + bread.num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void run() {
    
            synchronized (bread) {
                while (true) {
                    if (bread.num <= 0) {
                        System.out.println("面包已卖完，等待生产");
                        try {
                            bread.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                    } else {
                        sale();
                        bread.notifyAll();
                    }
                }
            }
        }
    }
    
    
    
    
    
    public class Main {
        public static void main(String[] args) throws InterruptedException {
            Bread bread = new Bread("土司", 3);
            BreadProducer breadProducer = new BreadProducer(bread, 5);
            BreadSale breadSale = new BreadSale(bread);
            Thread tp = new Thread(breadProducer);
            Thread ts = new Thread(breadSale);
    
            ts.start();
            tp.start();
        }
    }

启动 main() 函数以后，可以看到一个持续生产-售卖的过程，永不停息（**注意：慎用死循环**）