c++11 与 qt 的生产者 消费者 加锁 两种实例

c+11的实例

#include <QCoreApplication>
#include<iostream>
#include <mutex>
#include <condition_variable>
#include <Windows.h>
#include <thread>

using namespace std;

static const int buffer_size = 10; // 缓存大小
static const int item_total = 100; //总共要生产 item_total个item

// 缓存结构体, 使用循环队列当做缓存
struct Buffer
{
    int buffer[buffer_size];
    size_t read_position=0; // 当前读位置
    size_t write_position=0; // 当前写位置
    mutex mtx; // 读写互斥
    //条件变量
    condition_variable not_full;
    condition_variable not_empty;
}buffer_res;

typedef struct Buffer Buffer;

//生产者任务
void producer() {
    for (int i = 1; i<= item_total;i++) {
        cout << "prodece the " << i << "^th item ..." << endl;
        unique_lock<mutex> lock(buffer_res.mtx);//设置互斥锁

        while(((buffer_res.write_position + 1) % buffer_size) == buffer_res.read_position) {
            //当前缓存已经满了
            cout << "buffer is full now, producer is wating....." << endl;
            (buffer_res.not_full).wait(lock); // 等待缓存非full
        }
        // 向缓存中添加item
        (buffer_res.buffer)[buffer_res.write_position] = i;
        (buffer_res.write_position)++;

        // 若到达最后一个, 写位置置位0
        if (buffer_res.write_position == buffer_size)
            buffer_res.write_position = 0;

        (buffer_res.not_empty).notify_all();
        lock.unlock();
    }
}

//消费者任务
void consumer()
{
    static int cnt = 0;
    while(1) {
        Sleep(1);
        int data;
        unique_lock <mutex> lock(buffer_res.mtx);
        while (buffer_res.write_position == buffer_res.read_position)
        {   // 当前buffer 为空
            cout << "buffer is empty , consumer is waiting....." << endl;
            (buffer_res.not_empty).wait(lock);
        }

        data = (buffer_res.buffer)[buffer_res.read_position];
        (buffer_res.read_position)++;

        if (buffer_res.read_position >= buffer_size)
            buffer_res.read_position = 0;

        (buffer_res.not_full).notify_all();
        lock.unlock();
        cout << "consume the " << data << "^th item" << endl;
        if (++cnt == item_total)
            break;
    }
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    thread prodece(producer);
    thread consume(consumer);
    prodece.join();
    consume.join();
    getchar();

    return a.exec();
}

qt的实例

#include <QCoreApplication>
#include <QThread>
#include <QWaitCondition>
#include <QMutex>
 
const qint32 DataSize=10;//能产生的最大数
const qint32 BufferSize=4;//最大存储的数目
 
int buffer[BufferSize];
QWaitCondition bufferIsNotFull;
QWaitCondition bufferIsNotEmpty;
QMutex mutex;
 
int usedSpace=0;
class threadProducer:public QThread{
public:
    void run(){
        for(int i=0;i<DataSize;++i){
            mutex.lock();//如果仓库满了，不生产，等待销费
            while (usedSpace==BufferSize) {
                bufferIsNotEmpty.wait(&mutex);
            }
            buffer[i%4]=i+1;
            qDebug("producer:%d",buffer[i%4]);
            ++usedSpace;
            bufferIsNotEmpty.wakeAll();
            mutex.unlock();
        }
    }
};
class threadConsumer:public QThread{
public:
    void run(){
       for(int i=0;i<DataSize;++i){
           mutex.lock();
           while (usedSpace==0) {
               bufferIsNotEmpty.wait(&mutex);
           }
           qDebug("consumer:%d",buffer[i%4]);
           --usedSpace;
           bufferIsNotFull.wakeAll();
           mutex.unlock();
       }
    }
};
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    threadConsumer consumer;
    threadProducer producer;
 
    consumer.start();
    producer.start();
 
    consumer.wait();
    producer.wait();
 
    return a.exec();
}