面试题:用 wait-notify 写一段代码来解决生产者-消费者问题

public class ProductTest {

    public static void main(String[] args)   
    {  
        Clerk clerk = new Clerk();  
        Thread producerThread = new Thread(new Producer(clerk));  
        Thread consumerThread = new Thread(new Consumer(clerk));  

        producerThread.start();  
        consumerThread.start();  
    }  
    static class Clerk {
        private static final int MAX_PRODUCT = 20;
        private static final int MIN_PRODUCT = 0;

        private int PRODUCT = 0;

        public synchronized void addProduct() {
            if (this.PRODUCT >= MAX_PRODUCT) {
                try {
                    wait();
                    System.out.println("产品已满,请稍候再生产");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                return;
            }
            this.PRODUCT++;
            System.out.println("生产者生产了第"+this.PRODUCT+"个产品");
            notifyAll();
        }

        public synchronized void getProduct() {
            if(this.PRODUCT <= MIN_PRODUCT) {
                try {
                    wait();
                    System.out.println("产品处于缺货状态");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                return;
            }
            System.out.println("消费者消费了第" + this.PRODUCT + "个产品");  
            this.PRODUCT--;
            notifyAll();
        }
    }

    static class Producer implements Runnable{
        private Clerk clerk;
        public Producer(Clerk clerk)
        {
            this.clerk=clerk;
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println("生产者开始生产产品");
            while(true)
            {
                try {
                  Thread.sleep(1000);
                } catch (Exception e) {
                    // TODO: handle exception
                }
                clerk.addProduct();
            }

        }

    }

    static class Consumer implements Runnable{
        private Clerk clerk;
        public Consumer(Clerk clerk)
        {
            this.clerk=clerk;
        }
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println("消费者开始消费产品");
            while(true)
            {
                try {
                  Thread.sleep(1000);
                } catch (Exception e) {
                    // TODO: handle exception
                }
                clerk.getProduct();
            }

        }

    }
}

这里写图片描述

  • 2
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,以下是一个基本的生产者-消费者模型的 C++ 代码: ```c++ #include <iostream> #include <queue> #include <thread> #include <mutex> #include <condition_variable> #include <chrono> using namespace std; // 生产者-消费者模型中的缓冲区 queue<int> buffer; // 互斥锁,用于保护缓冲区 mutex mtx; // 条件变量,用于控制生产者消费者的同步 condition_variable produce_cv, consume_cv; // 生产者线程函数 void producer(int id) { while (true) { // 生成一个新的数据项 int item = rand() % 100; // 获取互斥锁 unique_lock<mutex> lck(mtx); // 如果缓冲区已满,则等待消费者消费数据 while (buffer.size() >= 10) { cout << "Producer " << id << " waiting..." << endl; produce_cv.wait(lck); } // 将数据项加入缓冲区 buffer.push(item); cout << "Producer " << id << " produced item " << item << endl; // 通知消费者有新的数据可供消费 consume_cv.notify_one(); // 释放互斥锁 lck.unlock(); // 生产者线程休眠一段时间,模拟生产过程 this_thread::sleep_for(chrono::milliseconds(rand() % 1000)); } } // 消费者线程函数 void consumer(int id) { while (true) { // 获取互斥锁 unique_lock<mutex> lck(mtx); // 如果缓冲区为空,则等待生产者生产数据 while (buffer.empty()) { cout << "Consumer " << id << " waiting..." << endl; consume_cv.wait(lck); } // 从缓冲区中取出一项数据 int item = buffer.front(); buffer.pop(); cout << "Consumer " << id << " consumed item " << item << endl; // 通知生产者有新的空闲空间可供生产 produce_cv.notify_one(); // 释放互斥锁 lck.unlock(); // 消费者线程休眠一段时间,模拟消费过程 this_thread::sleep_for(chrono::milliseconds(rand() % 1000)); } } int main() { // 创建两个生产者线程和两个消费者线程 thread p1(producer, 1); thread p2(producer, 2); thread c1(consumer, 1); thread c2(consumer, 2); // 等待所有线程执行完毕 p1.join(); p2.join(); c1.join(); c2.join(); return 0; } ``` 上述代码中,生产者消费者线程都是通过无限循环来模拟实际生产和消费的过程。当缓冲区已满时,生产者线程会等待消费者线程消费数据;当缓冲区为空时,消费者线程会等待生产者线程生产数据。 注意,在生产者消费者线程中,我们都使用了一个 `unique_lock` 对象来获取互斥锁,并在必要时释放锁。当生产者线程将新的数据项加入缓冲区之后,它会通过条件变量 `consume_cv` 通知消费者线程有新的数据可供消费;而当消费者线程从缓冲区中取出一项数据之后,它会通过条件变量 `produce_cv` 通知生产者线程有新的空闲空间可供生产。这样,生产者消费者线程之间就可以实现同步。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值