经典例题:生产者/消费者

简介: 经典例题:生产者/消费者

线程通信的应用:经典例题:生产者/消费者

package com.day0207_2;
/**
 * 线程通信的应用:经典例题:生产者/消费者
 *
 * 生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,
 * 店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员
 * 会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品
 * 了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。
 *
 * 分析:
 * 1.是否为多线程问题?是,生产者线程、消费者线程
 * 2.是否有各项数据?是,店员(或产品)
 * 3.如何解决线程的安全问题?同步机制,有三种方法
 * 4.是否涉及到线程的通信?是
 *
 *
 */
class Clerk{
    private int productCount=0;
    //生产产品
    public synchronized void produceProduct() {
        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            notify();
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct() {
        if(productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{//生产者
    private Clerk clerk;
    public Producer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        System.out.println(getName()+":开始生产产品...");
        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}
class Consumer extends Thread{//消费者
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        System.out.println(getName()+":开始消费产品...");
        while (true){
            try {
                Thread.sleep(22);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer p1=new Producer(clerk);
        p1.setName("生产者1");
        Consumer c1=new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2=new Consumer(clerk);
        c2.setName("消费者2");
        p1.start();
        c1.start();
        c2.start();
    }
}
相关文章
|
容器
多线程学习之生产者和消费者与阻塞队列的关系
多线程学习之生产者和消费者与阻塞队列的关系
49 0
|
1月前
|
消息中间件 NoSQL 关系型数据库
【多线程-从零开始-捌】阻塞队列,消费者生产者模型
【多线程-从零开始-捌】阻塞队列,消费者生产者模型
25 0
|
6月前
|
Java
用java实现生产者和消费者模式
用java实现生产者和消费者模式
57 1
|
6月前
|
Java
生产与消费(多线程练习题)
生产与消费(多线程练习题)
37 0
|
消息中间件 存储 RocketMQ
自顶向下学习 RocketMQ(四):顺序消息
顺序消息是消息队列 RocketMQ 提供的一种对消息发送和消费顺序有严格要求的消息。对于一个指定的 Topic,消息严格按照先进先出(FIFO)的原则进行消息发布和消费,即先发布的消息先消费,后发布的消息后消费。
自顶向下学习 RocketMQ(四):顺序消息
笔试题:请写出一个消费者生产者模型
“请写出一个生产者消费者模型。一个生产者,一个消费者,生产者生产一个,消费者消费一个”。
|
消息中间件 RocketMQ 开发者
顺序消息消费者|学习笔记
快速学习顺序消息消费者
|
消息中间件 存储 Kafka
保证严格的消息顺序消费究竟有多难?
我们都知道无论是 Kafka 还是 RocketMQ,每个主题下面都有若干分区(RocketMQ 叫队列),如果消息被分配到不同的分区中,那么 Kafka 是不能保证消息的消费顺序的,因为每个分区都分配到一个消费者,此时无法保证消费者的消费先后,因此如果需要进行消息具有消费顺序性,可以在生产端指定这一类消息的 key,这类消息都用相同的 key 进行消息发送,kafka 就会根据 key 哈希取模选取其中一个分区进行存储,由于一个分区只能由一个消费者进行监听消费,因此这时候消息就具有消息消费的顺序性了。
165 0
保证严格的消息顺序消费究竟有多难?
|
消息中间件 存储 监控
自顶向下学习 RocketMQ(五):顺序消息原理
在 MQ 的模型中,顺序需要由 3 个阶段去保障: 消息被发送时保持顺序 消息被存储时保持和发送的顺序一致 消息被消费时保持和存储的顺序一致
自顶向下学习 RocketMQ(五):顺序消息原理