qt生产者消费者队列

在Qt中，可以使用QSemaphore和QMutex来实现生产者消费者队列。具体实现步骤如下：

1.定义一个缓冲区类，该类包含一个缓冲区数组和两个指针，分别指向缓冲区的头和尾。缓冲区类还包含一个QSemaphore对象和一个QMutex对象，用于实现线程同步。

2.在缓冲区类中定义两个方法：一个用于向缓冲区中添加数据的生产者方法，另一个用于从缓冲区中取出数据的消费者方法。这两个方法都使用QSemaphore对象来控制缓冲区的大小。

3.在主函数中创建一个缓冲区对象和两个线程对象，一个用于生产者，另一个用于消费者。将缓冲区对象传递给这两个线程对象。

4.在生产者线程中，调用缓冲区对象的生产者方法，向缓冲区中添加数据。

5.在消费者线程中，调用缓冲区对象的消费者方法，从缓冲区中取出数据。

下面是一个简单的Qt生产者消费者队列的示例代码：

#include <QCoreApplication>
#include <QThread>
#include <QDebug>
#include <QSemaphore>
#include <QMutex>

const int BufferSize = 10;

class Buffer
{
public:
    Buffer()
    {
        m_head = 0;
        m_tail = 0;
        m_freeBytes = BufferSize;
        m_usedBytes = 0;
    }

    void produce(int data)
    {
        m_freeSpace.acquire();
        m_mutex.lock();
        m_buffer[m_tail] = data;
        m_tail = (m_tail + 1) % BufferSize;
        m_freeBytes--;
        m_usedBytes++;
        m_mutex.unlock();
        m_usedSpace.release();
    }

    int consume()
    {
        m_usedSpace.acquire();
        m_mutex.lock();
        int data = m_buffer[m_head];
        m_head = (m_head + 1) % BufferSize;
        m_freeBytes++;
        m_usedBytes--;
        m_mutex.unlock();
        m_freeSpace.release();
        return data;
    }

private:
    int m_buffer[BufferSize];
    int m_head;
    int m_tail;
    int m_freeBytes;
    int m_usedBytes;
    QSemaphore m_freeSpace{BufferSize};
    QSemaphore m_usedSpace{0};
    QMutex m_mutex;
};

class Producer : public QThread
{
public:
    Producer(Buffer* buffer)
    {
        m_buffer = buffer;
    }

    void run() override
    {
        for (int i = 0; i < 100; i++)
        {
            m_buffer->produce(i);
            qDebug() << "Produced:" << i;
            msleep(10);
        }
    }

private:
    Buffer* m_buffer;
};

class Consumer : public QThread
{
public:
    Consumer(Buffer* buffer)
    {
        m_buffer = buffer;
    }

    void run() override
    {
        for (int i = 0; i < 100; i++)
        {
            int data = m_buffer->consume();
            qDebug() << "Consumed:" << data;
            msleep(50);
        }
    }

private:
    Buffer* m_buffer;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Buffer buffer;
    Producer producer(&buffer);
    Consumer consumer(&buffer);

    producer.start();
    consumer.start();

    producer.wait();
    consumer.wait();

    return a.exec();
}