生产者与消费者模型

一、商品类

import javax.swing.*;
import java.util.LinkedList;
import java.util.Queue;
public class Goods {
    private String id;
    private  String name;
    private double price;
    public Goods(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

二、生产者

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.UUID;
public class producer implements Runnable {
    private final Queue <Goods> queue;
    public producer(Queue <Goods> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep ( 1000 );
            } catch (InterruptedException e) {
                e.printStackTrace ( );
            }
            synchronized (this.queue) {
                if (queue.size ( ) > 10) {
                    System.out.println ( "容器已满,请加快消费!" );
                    try {
                        this.queue.wait ( );
                    } catch (InterruptedException e) {
                        e.printStackTrace ( );
                    }
                } else {
                    String id =String.valueOf ( UUID.randomUUID ( ) );
                    Goods goods = new Goods ( id, "包子", new Random ( ).nextDouble ( ) );
                    this.queue.add ( goods );
                }
            }
        }
    }
}

三、消费者

import java.util.Queue;
public class Consumer implements Runnable {
    private final Queue <Goods> queue;
    public Consumer(Queue <Goods> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep ( 1000 );
            } catch (InterruptedException e) {
                e.printStackTrace ( );
            }
            synchronized (this.queue) {
                if (this.queue.isEmpty ( )) {
                    System.out.println ( Thread.currentThread ( ).getName ( ) + "容器已空,停止消息,加速生产" );
                    this.queue.notify ( );
                } else {
                    Goods goods = this.queue.poll ( );
                    System.out.println ( Thread.currentThread ( ).getName ( ) + "消费商品" + goods );
                }
            }
        }
    }
}

四、运用命令行输入进行测试类测试

import java.util.LinkedList;
import java.util.Queue;
public final class ProducerConsumerLauncher {
    private  ProducerConsumerLauncher(){}
    public static  void run(int producers,int consumers){
        System.out.println("生产者:" + producers + " 消费者:" + consumers);
        Queue<Goods> queue=new LinkedList<> ( );
        Runnable produce=new producer ( queue );
        Runnable consumer=new Consumer ( queue );
        for(int i=0;i<producers;i++){
            new Thread ( produce,"生产者-"+i ).start ();
        }
        for(int i=0;i<consumers;i++){
            new Thread ( consumer,"消费者-"+i ).start ();
        }
    }
}

五、测试

import java.util.LinkedList;
import java.util.Queue;
public class TestProducerConsumer {
    public static void main(String[] args) {
        //方法一:不灵活
       /* Queue<Goods> queue=new LinkedList <> ( );
        Runnable produce=new producer ( queue );
        Runnable consumer=new Consumer ( queue );
        for(int i=0;i<5;i++){
            new Thread ( produce,"生产者-"+i ).start ();
        }
        for(int i=0;i<2;i++){
            new Thread ( consumer,"消费者-"+i ).start ();
        }*/
       //方法二:输命令行参数测试
      int defaultProducers=5;
      int defaultConsumers=5;
      int producers=defaultProducers;
      int consumers=defaultConsumers;
      if(args.length==1){
          producers=Integer.parseInt ( args[0] );
      }
      if(args.length==2){
          producers=Integer.parseInt ( args[0] );
          consumers=Integer.parseInt ( args[1] );
      }
      if(producers<0){
          producers=defaultProducers;
      }
      if(consumers<0){
          consumers=defaultConsumers;
      }
      ProducerConsumerLauncher.run ( producers,consumers );

    }
}

 

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 下面是一个使用 Qt 线程池实现生产者消费者模型的简单示例: ```cpp #include <QtCore> #include <iostream> class Producer : public QObject { Q_OBJECT public: Producer(QThreadPool *pool, QMutex *mutex, QWaitCondition *cond, QList<int> *data) : m_pool(pool), m_mutex(mutex), m_cond(cond), m_data(data) { m_count = 0; } public slots: void produce() { int num = qrand() % 100; QRunnable *task = new Task(num, m_mutex, m_cond, m_data); m_pool->start(task); m_count++; std::cout << "Produced " << num << std::endl; m_cond->wakeAll(); } int count() const { return m_count; } private: QThreadPool *m_pool; QMutex *m_mutex; QWaitCondition *m_cond; QList<int> *m_data; int m_count; }; class Consumer : public QObject { Q_OBJECT public: Consumer(QMutex *mutex, QWaitCondition *cond, QList<int> *data) : m_mutex(mutex), m_cond(cond), m_data(data) { } public slots: void consume() { m_mutex->lock(); while (m_data->isEmpty()) { m_cond->wait(m_mutex); } int num = m_data->takeFirst(); std::cout << "Consumed " << num << std::endl; m_mutex->unlock(); } private: QMutex *m_mutex; QWaitCondition *m_cond; QList<int> *m_data; }; class Task : public QRunnable { public: Task(int num, QMutex *mutex, QWaitCondition *cond, QList<int> *data) : m_num(num), m_mutex(mutex), m_cond(cond), m_data(data) { } void run() { m_mutex->lock(); while (m_data->size() >= 10) { m_cond->wait(m_mutex); } m_data->append(m_num); m_mutex->unlock(); } private: int m_num; QMutex *m_mutex; QWaitCondition *m_cond; QList<int> *m_data; }; int main(int argc, char *argv[]) { QCoreApplication app(argc, argv); qsrand(QTime::currentTime().msec()); QThreadPool pool; pool.setMaxThreadCount(5); QMutex mutex; QWaitCondition cond; QList<int> data; Producer producer(&pool, &mutex, &cond, &data); Consumer consumer(&mutex, &cond, &data); QObject::connect(&producer, &Producer::produce, &consumer, &Consumer::consume); QTimer timer; QObject::connect(&timer, &QTimer::timeout, &producer, &Producer::produce); timer.start(1000); QTimer countTimer; QObject::connect(&countTimer, &QTimer::timeout, [&producer]() { std::cout << "Produced " << producer.count() << " items" << std::endl; }); countTimer.start(5000); return app.exec(); } ``` 在上面的示例中,`Producer` 和 `Consumer` 类继承自 `QObject`,并使用 Qt 信号和槽机制进行通信。`Producer` 类的 `produce()` ### 回答2: Qt线程池可以很好地实现生产者消费者模型生产者消费者模型主要是通过一个共享的缓冲区来实现生产者生产数据,消费者消费数据的过程。下面是一个使用Qt线程池实现生产者消费者模型的示例: 1. 定义一个数据结构,用于存储生产者消费者共享的数据。这个数据结构可以是一个队列或者一个列表。 2. 创建一个Qt线程池,并设置线程池的最大线程数。 3. 创建生产者线程和消费者线程,并将它们添加到线程池中。 4. 在生产者线程中,生产数据并将数据添加到共享的数据结构中。可以使用Qt的信号槽机制,在生产者线程中发送信号,将数据发送给消费者线程。 5. 在消费者线程中,从共享的数据结构中获取数据并进行消费。可以使用Qt的信号槽机制,在消费者线程中接收信号,并处理收到的数据。 6. 在主线程中,等待生产者线程和消费者线程完成工作,并关闭线程池。 通过使用Qt线程池,可以方便地管理多个线程,避免手动管理线程的创建和销毁,从而简化了生产者消费者模型实现。此外,Qt的信号槽机制可以方便地实现线程间的通信,从而实现生产者消费者之间的数据传递。 ### 回答3: Qt是一个跨平台的C++应用程序开发框架,它提供了丰富的类库和工具,其中也包括线程池的实现。在Qt中,可以使用QThreadPool类来创建和管理线程池。 生产者消费者模型是一种常见的多线程编程模型,其中有一组线程作为生产者,负责生成数据,另一组线程作为消费者,负责处理这些数据。线程池可以很好地支持这种模型,并提供了以下步骤来实现: 1. 创建一个线程池对象:使用QThreadPool类创建一个线程池对象,设置最大线程数、线程闲置时间等属性。 2. 创建生产者线程:通过继承QRunnable类,实现自己的生产者线程类。在类中重写run()函数,在其中完成需要生产的数据的生成。 3. 创建消费者线程:同样通过继承QRunnable类,实现自己的消费者线程类。在类中重写run()函数,在其中完成对生产者生成的数据的处理。 4. 将任务添加到线程池:使用QThreadPool的start()函数将生产者消费者线程对象添加到线程池中,线程池会自动分配线程去运行这些任务。 5. 等待线程池完成任务:可以使用QThreadPool的waitForDone()函数来等待线程池中的所有任务完成,确保所有生产者消费者线程都执行完毕。 通过以上步骤,我们可以在Qt中实现简单的生产者消费者模型。线程池可以很好地管理线程的创建和销毁,提高线程利用率和系统的性能。同时,Qt的线程池也提供了一些其他的功能,比如任务优先级和取消线程等,可以根据实际需求来灵活调整。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值