1. C++ queue 队列基本用法
在C++中，queue是一个模板类，用于实现队列数据结构，遵循先进先出的原则。
♦ 常用方法： ·
queue<int> Q; //定义一个int型队列
Q.empty(); //返回队列是否为空
Q.size(); //返回当前队列长度
Q.front(); //返回当前队列的第一个元素
Q.back(); //返回当前队列的最后一个元素
Q.push(); //在队列后面插入一个元素, 比如插入数字5: Q.push(5)
Q.pop(); //从当前队列里,移出第一个元素
♦ 简单使用： ·
#include <iostream>
#include <queue>
using namespace std;
int main()
{
// 创建一个queue对象
queue<int> Q;
// 向队列中添加元素
Q.push(1);
Q.push(2);
Q.push(3);
cout<<"queue empty? "<<Q.empty()<<endl;
cout<<"queue size: "<<Q.size()<<endl;
// 从队列中移除元素，并输出
while (!Q.empty()) {
int value = Q.front();
Q.pop();
cout << "Dequeued:" << value << endl;
}
return 0;
}
♦ 打印： ·
2. Qt QQueue 队列基本用法
QQueue 继承与 QList
♦ 常用方法： ·
QQueue<int> QQ; //定义一个int型队列
QQ.isEmpty(); //返回队列是否为空
QQ.size(); //返回队列元素个数
QQ.clear(); //清空队列
QQ.enqueue(); //在队列尾部添加一个元素, 比如插入数字5: QQ.enqueue(5)
/* 相当于
Q.push();
*/
QQ.dequeue(); //删除当前队列第一个元素,并返回这个元素
/* 相当于
Q.front(); //返回当前队列的第一个元素
Q.pop(); //从当前队列里,移出第一个元素
*/
QQ.head(); //返回当前队列第一个元素
/* 相当于
Q.front();
*/
QQ.last(); //返回当前队列尾部的元素
/* 相当于
Q.back();
*/
T & operator[]( int i ); //以数组形式访问队列元素
♦ 实例： ·
#include <QCoreApplication>
#include <QQueue>
#include <QDebug>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
// 创建一个QQueue对象
QQueue<int> QQ;
// 向队列中添加元素
QQ.enqueue(1);
QQ.enqueue(2);
QQ.enqueue(3);
qDebug()<<"queue empty: "<<QQ.isEmpty();
qDebug()<<"queue size: " <<QQ.size();
qDebug()<<"queue head: " <<QQ.head() ;
qDebug()<<"queue last: " <<QQ.last() << "\n";
// 从队列中移除元素，并输出
while (!QQ.isEmpty()) {
int value = QQ.dequeue();
qDebug() << "Dequeued:" << value;
}
return a.exec();
}
♦ 打印： ·
3. Qt QQueue 多线程队列
在多线程编程中，由于QQueue并不是线程安全的，因此我们需要先使用互斥锁（QMutex）来保护队列。在读写队列时，我们需要获取互斥锁的锁定，以避免多个线程同时访问队列导致的数据竞争问题。
然后通过经典的生产者和消费者来看一个简单的示例程序，演示如何使用QQueue实现线程安全队列：
#include <QCoreApplication>
#include <QQueue>
#include <QMutex>
#include <QThread>
#include <QDebug>
// 定义线程安全队列类
template<typename T>
class ThreadSafeQueue
{
public:
// 添加元素到队列尾部
void enqueue(const T& value) {
QMutexLocker locker(&m_mutex);
m_queue.enqueue(value);
}
// 从队列头部移除一个元素，并返回它
T dequeue() {
QMutexLocker locker(&m_mutex);
if (m_queue.isEmpty()) {
return T();
}
return m_queue.dequeue();
}
// 返回队列是否为空
bool isEmpty() const {
QMutexLocker locker(&m_mutex);
return m_queue.isEmpty();
}
private:
QQueue<T> m_queue;
mutable QMutex m_mutex;
};
// 定义生产者线程类
class ProducerThread : public QThread
{
public:
ProducerThread(ThreadSafeQueue<int>& queue)
: m_queue(queue)
{
}
protected:
void run() override {
for (int i = 1; i <= 10; i++) {
m_queue.enqueue(i);
qDebug() << "Enqueued:" << i;
msleep(500);
}
}
private:
ThreadSafeQueue<int>& m_queue;
};
// 定义消费者线程类
class ConsumerThread : public QThread
{
public:
ConsumerThread(ThreadSafeQueue<int>& queue)
: m_queue(queue)
{
}
protected:
void run() override {
while (!isInterruptionRequested()) {
if (!m_queue.isEmpty()) {
int value = m_queue.dequeue();
qDebug() << "Dequeued:" << value;
}
msleep(500);
}
}
private:
ThreadSafeQueue<int>& m_queue;
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
// 创建线程安全队列对象
ThreadSafeQueue<int> queue;
// 创建生产者线程对象和消费者线程对象
ProducerThread producer(queue);
ConsumerThread consumer(queue);
// 启动线程
producer.start();
consumer.start();
qDebug() << "F1";
// 等待线程结束
//在producer等待期间， consumer run()也会运行 直到producer 运行完毕，main才能往下执行
producer.wait();
qDebug() << "F2";
consumer.requestInterruption(); //相当于 ctrl + c 结束 consumer 线程
qDebug() << "F3";
consumer.wait();
qDebug() << "F4";
return a.exec();
}
♦ 运行结果：
在上面的示例程序中，我们首先定义了一个模板类ThreadSafeQueue，用于实现线程安全队列。该类使用QMutex来保护QQueue对象，以实现线程安全。
接下来，我们定义了两个线程类ProducerThread和ConsumerThread，用于生产和
消费数据。
在ProducerThread中，我们循环向队列中添加元素，每隔500毫秒添加一个元素。在ConsumerThread中，我们循环从队列中取出元素，每隔500毫秒取出一个元素。在取出元素时，我们需要判断队列是否为空，避免出现异常情况。
其中：执行 producer.wait() 时， mian 中主线程将会被阻塞； 等到 producer 生产者运行完毕，才会唤醒；而 consumer 线程不受影响；
万一发生数据处理速度不匹配的情况呢？
- 生产者休眠 500ms 消费者休眠500ms， 就是如上情况
- 生产者休眠时间 < 消费者休眠时间， 那么生产者执行完毕后，消费者还未消费完就退出线程了，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕
- 生产者休眠时间 > 消费者休眠时间， 那么生产者执行完毕后，消费者也执行完毕了
真实的大数据情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。
在 java 中有 BlockingQueue 阻塞队列，但是Qt 中似乎没有相关的阻塞队列，需要我们自己去自己控制这些细节
4. Qt BlockingQueue 自定义线程安全的阻塞队列
以下定义一个简单的阻塞队列：
#include <QCoreApplication>
#include <QWaitCondition>
#include <QQueue>
#include <QMutex>
#include <QThread>
#include <QDebug>
template <typename T>
class BlockingQueue
{
public:
BlockingQueue() {
}
void put(const T& value)
{
QMutexLocker locker(&m_mutex);
m_queue.enqueue(value);
m_condition.wakeOne(); //唤醒等待队列中的一个线程(来自wait)
}
T take()
{
QMutexLocker locker(&m_mutex);
while (m_queue.isEmpty()) {
m_condition.wait(&m_mutex);
}
return m_queue.dequeue();
}
bool isEmpty() const
{
QMutexLocker locker(&m_mutex);
return m_queue.isEmpty();
}
int size() const
{
QMutexLocker locker(&m_mutex);
return m_queue.size();
}
private:
QQueue<T> m_queue;
mutable QMutex m_mutex;
QWaitCondition m_condition;
};
这个 BlockingQueue类使用QMutex和QWaitCondition来保证线程安全，并实现了put、take、isEmpty和size等方法。其中，put方法用于往队列中插入元素，take方法用于从队列中取出元素，isEmpty方法用于判断队列是否为空，size方法用于获取队列中元素的数量。
在put方法中，我们首先获取了互斥锁，然后将元素插入到队列中，并通过QWaitCondition的wakeOne()方法唤醒一个等待线程（调用take()中的线程）。在take方法中，我们首先获取了互斥锁，然后在队列为空时调用QWaitCondition的wait()方法等待，直到有其他线程往队列中插入了元素并唤醒了当前线程。
mutable的作用是允许在const成员函数中修改BlockingQueue类的m_mutex和m_notEmpty成员变量。这是因为，生产者和消费者线程在往阻塞队列中添加或删除元素时，都需要对这两个成员变量进行修改。但是，由于take()和tryTake()方法都是const成员函数，因此如果不将m_mutex和m_notEmpty声明为mutable类型，编译器就会报错。
♦ 使用： ·
static BlockingQueue<int> queue;
class Producer : public QThread
{
public:
void run() override
{
for (int i = 0; i < 10; ++i) {
queue.put(i);
qDebug() << "Producer thread: " << QThread::currentThreadId() << ", value: " << i;
msleep(500); // sleep for 0.5 second
}
}
};
class Consumer : public QThread
{
public:
void run() override
{
int value = 0;
while (true) {
value = queue.take();
qDebug() << "Consumer thread: " << QThread::currentThreadId() << ", value: " << value;
}
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Producer producer;
Consumer consumer1, consumer2;
producer.start();
consumer1.start();
consumer2.start();
return a.exec();
}
♦ 运行结果：
上述包含一个生产者线程和两个消费者线程，生产者线程往队列中插入10个整数，每插入一个元素后暂停0.5秒。两个消费者线程不断从队列中取出元素，并输出当前线程的ID和取出的元素值。 当队列为空时，消费者线程会进入等待状态，直到有其他线程往队列中插入元素。