qt 线程互斥

1.qt 线程互斥

在 Qt 中，线程互斥（Thread Mutual Exclusion）通常通过QMutex类来实现，用于保护共享资源，防止多个线程同时访问导致数据竞争（race condition）。

一、基本概念

• 互斥锁（Mutex）：一次只允许一个线程进入临界区（critical section），其他线程必须等待。
• 临界区：访问共享资源的代码段。

二、Qt 中的互斥相关类

三、示例：使用 QMutex 和 QMutexLocker

场景：多个线程向同一个 QList 添加数据

#include <QThread> #include <QMutex> #include <QMutexLocker> #include <QList> #include <QDebug> QList<int> sharedList; QMutex mutex; class Worker : public QThread { public: void run() override { for (int i = 0; i < 100; ++i) { // 使用 QMutexLocker 自动管理锁 QMutexLocker locker(&mutex); sharedList.append(i); qDebug() << "Thread" << currentThreadId() << "added" << i; } } }; int main(int argc, char *argv[]) { QCoreApplication app(argc, argv); Worker w1, w2; w1.start(); w2.start(); w1.wait(); w2.wait(); qDebug() << "Final list size:" << sharedList.size(); // 应为 200 return 0; }

✅ 使用QMutexLocker可以避免忘记调用unlock()，即使发生异常也能自动释放锁。

四、注意事项

1. 不要在持有锁时做耗时操作（如 I/O、sleep），否则会阻塞其他线程。
2. 避免死锁：
   • 多个锁时，始终按相同顺序加锁。
   • 不要在持有锁时调用可能再次加锁的函数。
3. QMutex 是不可重入的（默认情况下）：
   • 同一线程重复 lock 会导致死锁。
   • 如需可重入，使用QRecursiveMutex（Qt 5.14+）或自己封装。

五、高级用法：条件变量配合互斥

若需线程间通信（如生产者-消费者），可结合QWaitCondition：

QMutex mutex; QWaitCondition bufferNotEmpty; bool dataReady = false; // 生产者 { QMutexLocker locker(&mutex); produceData(); dataReady = true; bufferNotEmpty.wakeAll(); // 唤醒等待的消费者 } // 消费者 { QMutexLocker locker(&mutex); while (!dataReady) { bufferNotEmpty.wait(&mutex); // 自动 unlock，被唤醒后重新 lock } consumeData(); }

六、总结

• 用QMutex保护共享数据。
• 优先使用QMutexLocker实现 RAII。
• 注意死锁和性能问题。
• 复杂同步场景可结合QWaitCondition或使用 Qt 的信号槽机制（跨线程自动排队）。

2.qt 线程互斥的手段有多少种方法

在 Qt 中，实现**线程互斥（Thread Mutual Exclusion）**以保护共享资源、避免数据竞争的手段有多种。这些方法既包括 Qt 封装的同步原语，也兼容 C++11 标准库中的工具（因为 Qt 可与标准库共用）。以下是Qt 中常用的线程互斥手段分类和具体方法：

✅ 一、Qt 原生提供的互斥机制（推荐用于 Qt 项目）

1.QMutex + QMutexLocker

• 用途：最基本的互斥锁。
• 特点：
  • 非递归（默认），同一线程重复加锁会死锁。
  • QMutexLocker提供 RAII 自动加锁/解锁。
• 适用场景：保护临界区，如修改共享变量、容器等。

QMutex mutex; { QMutexLocker lock(&mutex); // 临界区 }

🔸 Qt 5.14+ 引入QRecursiveMutex（可重入版本）。

2.QReadWriteLock + QReadLocker / QWriteLocker

• 用途：读多写少场景的高性能互斥。
• 特点：
  • 多个读线程可同时访问。
  • 写操作独占（阻塞所有读和其他写）。
• 适用场景：缓存、配置数据等频繁读、偶尔更新的结构。

QReadWriteLock rwLock; // 读 { QReadLocker locker(&rwLock); // 安全读取 } // 写 { QWriteLocker locker(&rwLock); // 安全写入 }

3.QSemaphore（信号量）

• 用途：控制对有限数量资源的并发访问（不只是 0/1）。
• 注意：严格来说不是“互斥锁”，但可用于实现互斥（设为 1）。
• 适用场景：连接池、缓冲区槽位控制等。

QSemaphore sem(1); // 相当于二值信号量（互斥） sem.acquire(); // 进入临界区 // ... sem.release(); // 离开

⚠️ 不如QMutex直观，一般不用于简单互斥。

4.QWaitCondition + QMutex（条件变量）

• 用途：线程等待某个条件成立（如队列非空）。
• 本质：配合互斥锁使用，实现“等待-通知”机制。
• 不是直接互斥手段，但依赖互斥锁来保护条件判断。

QMutex mutex; QWaitCondition notEmpty; // 消费者 mutex.lock(); while (queue.isEmpty()) notEmpty.wait(&mutex); // 自动 unlock，唤醒后 relock item = queue.dequeue(); mutex.unlock();

✅ 二、C++11 标准库互斥机制（Qt 项目中也可用）

Qt 支持 C++11 及以上，因此以下标准库工具同样有效：

5.std::mutex / std::recursive_mutex + std::lock_guard / std::unique_lock

• 功能与QMutex类似。
• 在纯 C++ 或混合项目中常用。
• Qt 官方建议：若项目已重度使用 Qt，优先用 Qt 的类（风格统一、调试支持更好）。

#include <mutex> std::mutex mtx; { std::lock_guard<std::mutex> lock(mtx); // 临界区 }

6.std::shared_mutex（C++17） + shared_lock / unique_lock

• 对应 Qt 的QReadWriteLock。
• 读写锁的标准库实现。

✅ 三、Qt 特色：信号与槽的线程安全机制（间接互斥）

7.跨线程信号槽（Queued Connection）

• 虽然不是传统“互斥锁”，但通过事件队列串行化操作，天然避免并发。
• 适用场景：UI 更新、对象间通信。

// Worker 在子线程 emit signal // Main thread 的 slot 自动排队执行，无需手动加锁 connect(worker, &Worker::resultReady, this, &MainWindow::updateUI, Qt::QueuedConnection);

✅ 优势：无锁、安全、符合 Qt 设计哲学。
❌ 局限：仅适用于 QObject 之间的通信，不能保护任意共享数据。

✅ 四、原子操作（适用于简单变量）

8.QAtomicInteger / std::atomic

• 用途：对单个整型、指针等进行无锁线程安全操作。
• 不是互斥锁，但可避免对简单变量加锁。

QAtomicInt counter; counter.fetchAndAddRelaxed(1); // 线程安全自增 // 或 C++11 std::atomic<int> count{0}; count++;

✅ 适用于计数器、标志位等。
❌ 无法保护复杂数据结构（如 QList、自定义对象）。

📊 总结：Qt 中线程互斥的主要手段（按使用频率排序）

✅ 最佳实践建议

1. 优先使用QMutex+QMutexLocker—— 简单、安全、Qt 风格。
2. 读多写少？用QReadWriteLock。
3. 能用信号槽通信就别共享数据—— 避免锁。
4. 简单计数用原子操作，避免锁开销。
5. 避免混合使用 Qt 和 std 的同步原语，除非必要。