【Java】—— 多线程：线程间的通信机制与生产者消费者案例

星星法术嗲人

于 2024-09-26 03:16:28 发布

阅读量1k

点赞数 28

分类专栏： JAVA 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_63106307/article/details/142536476

版权

JAVA 专栏收录该内容

67 篇文章 0 订阅

订阅专栏

7.4 调用wait和notify需注意的细节

7.5 生产者与消费者问题

7. 线程的通信

7.1 线程间通信

为什么要处理线程间通信：

当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—— 等待唤醒机制。

7.2 等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。

在一个线程满足某个条件时，就进入等待状态（wait() / wait(time)），等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
notify：则选取所通知对象的 wait set 中的一个线程释放；
notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：

被通知的线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下：

如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行）状态；

否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁）状态

7.3 举例

例题：使用两个线程打印 1-100。线程1, 线程2 交替打印

package exer2;

/**
 * ClassName:IntelliJ IDEA
 * Description:
 *          案例：使用两个线程打印 1-100。线程1, 线程2 交替打印
 * @Author zyjstart
 * @Create:2024/9/26 1:31
 */

class PrintNumber implements Runnable{
    //共享数据
    private int number = 1;

    @Override
    public void run() {

        while (true){
            synchronized (this){
                notify();   // 唤醒被wait()的线程
                if (number <= 100){
                    System.out.println(Thread.currentThread().getName() + " : " + number);
                    number++;

                    try {
                        wait();     // 使线程进入等待状态，释放对同步监视器的调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }

        }
    }
}
public class PrintNumberTest {
    public static void main(String[] args) {

        PrintNumber p = new PrintNumber();

        Thread t1 = new Thread(p, "线程1");
        Thread t2 = new Thread(p, "线程2");

        t1.start();
        t2.start();

    }
}

运行结果：

7.4 调用wait和notify需注意的细节

wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。否则会报java.lang.IllegalMonitorStateException异常。

7.5 生产者与消费者问题

等待唤醒机制可以解决经典的“生产者与消费者”的问题。生产者与消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个（多个）共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。

生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

举例：

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

类似的场景，比如厨师和服务员等。

生产者与消费者问题中其实隐含了两个问题：

线程安全问题：因为生产者与消费者共享数据缓冲区，产生安全问题。不过这个问题可以使用同步解决。
线程的协调工作问题：
- 要解决该问题，就必须让生产者线程在缓冲区满时等待(wait)，暂停进入阻塞状态，等到下次消费者消耗了缓冲区中的数据的时候，通知(notify)正在等待的线程恢复到就绪状态，重新开始往缓冲区添加数据。同样，也可以让消费者线程在缓冲区空时进入等待(wait)，暂停进入阻塞状态，等到生产者往缓冲区添加数据之后，再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。

代码实现：

package exer2;

/**
 * ClassName:IntelliJ IDEA
 * Description:
 *      案例：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
 *      店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，
 *      店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；
 *      如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
 * @Author zyjstart
 * @Create:2024/9/26 2:33
 */

/**
 * 店员类
 */
class Clerk{
    private int productNum = 0;// 产品的数量


    // 增加产品数量的方法
    public synchronized void addProduct(){
        if (productNum >= 20){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            productNum++;
            System.out.println(Thread.currentThread().getName() + "生产了第" + productNum + "个产品");

            // 唤醒
            notifyAll();
        }


    }


    // 减少产品数量的方法
    public synchronized void minusProduct(){
        if (productNum <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }else {
            System.out.println(Thread.currentThread().getName() + "消费了第" + productNum + "个产品");
            productNum--;

            // 唤醒
            notifyAll();
        }


    }
}

/**
 * 生产者类
 */
class Producer extends Thread{

    private Clerk clerk;
    public Producer(Clerk clerk){
        this.clerk = clerk;
    }
    @Override
    public void run() {

        while (true){
            System.out.println("生产者开始生产产品.....");
            // 让他生产的慢一点
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.addProduct();

        }
    }

}

/**
 * 消费者类
 */
class Consumer extends Thread{

    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }
    @Override
    public void run() {

        while (true){
            System.out.println("消费者开始消费产品.....");
            // 让他消费的慢一点
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.minusProduct();
        }
    }
}

public class ProducerConsumerTest {
    public static void main(String[] args) {

        Clerk clerk = new Clerk();

        Producer pro1 = new Producer(clerk);
        Consumer con1 = new Consumer(clerk);

        pro1.setName("生产者1");
        con1.setName("消费者1");

        pro1.start();
        con1.start();

    }
}

运行如下：