当前位置：首页 > news >正文

读多写少？别急着上 QReadWriteLock，项目里可能更慢

news 2026/6/10 0:11:25

做 Qt 多线程项目，很多人一看到“读多写少”这四个字，手就已经放到 QReadWriteLock 上了。

设备状态缓存？上读写锁。

全局配置表？上读写锁。

采集线程写数据，界面线程读数据？这不就是读多写少吗，安排。

我以前也这么干过，而且 Demo 里确实很舒服。一个线程写，一个线程读，数据不乱，界面也不卡，看起来比 QMutex 还“高级”。但真实项目不是 Demo，真实项目里最烦的地方是：读的人不止一个，读的地方也不干净。

比如一个工业上位机项目，采集线程每 200ms 更新一批设备状态，界面线程每秒刷新表格，报警线程扫状态，日志线程偶尔取一次快照。刚上线时没问题，设备数量一上来，现场就开始反馈：数据刷新慢半拍，报警偶尔延迟，界面看起来像没及时刷新。

一开始大家都怀疑通信，查串口、查 TCP、查设备响应时间，最后发现通信很正常。真正卡住的是写线程，它想更新缓存，但一直拿不到写锁。

问题不是读写锁，而是你把读锁拿太久了

QReadWriteLock 的基本规则很简单：多个线程可以同时拿读锁，但写锁必须独占。

也就是说，读线程之间可以一起进来，但只要有人在读，写线程就得等。这个设计本身没问题，问题在于项目里很多“读”根本不轻。

最常见的坑是这种：

voidMainWindow::refreshDeviceTable(){QReadLockerlocker(&m_lock);for(constauto&state:m_deviceStates){updateTableRow(state);checkAlarmText(state);emitdeviceStateShown(state.id);}}

这段代码看着没毛病，反正只是读m_deviceStates。但放到项目里就很危险，因为锁里面做了 UI 更新、报警文本判断，还发了信号。

读锁本来应该是“拿一下数据就走”，结果你拿着锁开始逛街。写线程在旁边等着更新数据，只能干瞪眼。

更坑的是emit。Qt 的信号槽在线程间通常是队列连接，但同线程里可能是直接调用。你在锁里发信号，槽函数里又干了什么，后面维护的人不一定知道。某天别人加了一段读缓存的代码，就可能把锁关系绕复杂。

我现在看到锁里发信号，基本会下意识皱眉。不是一定错，但这是高风险写法。

我后来一般这样写：锁里只拿快照

读写锁真正舒服的用法，不是把一大段业务包起来，而是把共享数据保护起来。锁只管数据，不管业务。

比如界面线程要刷新表格，我一般会先拷贝一份快照：

voidMainWindow::refreshDeviceTable(){QVector<DeviceState>snapshot;{QReadLockerlocker(&m_lock);snapshot=m_deviceStates;}for(constauto&state:snapshot){updateTableRow(state);checkAlarmText(state);}}

这段代码的重点不是QReadLocker怎么用，而是锁的边界变短了。读锁只负责从共享缓存里拿数据，拿完立刻释放。后面 UI 怎么刷、报警怎么算、日志怎么写，都跟这把锁没关系。

写线程也一样，写锁里面只更新共享数据，别在里面做耗时操作：

voidWorker::onPacketArrived(constQVector<DeviceState>&newStates){{QWriteLockerlocker(&m_lock);m_deviceStates=newStates;++m_version;}emitdeviceStatesUpdated();}

emit放在写锁外面，这个习惯很重要。因为通知别人“数据更新了”是一件事，保护共享数据是另一件事。把这两件事混在一起，项目后期很容易变成锁套锁。

线程越多，越别相信“读操作很快”

Demo 里的读操作一般就是value()一下，真实项目里的读操作往往会慢慢膨胀。

今天只是读状态，明天产品说表格要加颜色，后天现场说报警要加规则，大后天又要导出当前状态。于是原来 3 行的读锁，慢慢变成 30 行、100 行。

等你发现数据刷新慢的时候，代码里可能已经到处都是：

QReadLockerlocker(&m_lock);// 一堆看起来“只是读”的业务代码

这就是 QReadWriteLock 最容易坑人之处：它不会像死锁那样直接把程序干趴下，它只是让写线程变慢，让数据刷新延迟，让问题变得像通信慢、像界面卡、像设备不稳定。

这种问题最难查，因为系统还在跑，日志也正常刷，没有明显崩溃点。你只能抓线程栈、打耗时日志，最后才看到写线程一直堵在lockForWrite()。

写饥饿，很多项目真会遇到

写饥饿 = 写线程长期等不到写锁。

读写锁适合读多写少，但不代表读线程可以一直压着写线程。如果读请求非常密集，写线程就可能经常被挤在门口。Qt 的实现会尽量避免读线程无限插队，但它不是万能的。你把读锁拿得很久，它也救不了。

我一般会在写线程里加一点耗时监控，尤其是设备刷新、状态缓存这种关键路径：

voidWorker::updateCache(constQVector<DeviceState>&states){QElapsedTimer timer;timer.start();{QWriteLockerlocker(&m_lock);m_deviceStates=states;}constqint64 cost=timer.elapsed();if(cost>20){qWarning()<<"write lock cost too much:"<<cost<<"ms";}}

这个日志很土，但很有用。现场问题不是靠优雅解决的，很多时候就是靠这种关键路径耗时把锅揪出来。

如果你发现写锁经常几十毫秒甚至上百毫秒，那就别再怀疑设备了，先查谁拿着读锁不放。

QReadWriteLock 不是 QMutex 的高级替代品

还有个误区：觉得 QReadWriteLock 一定比 QMutex 快。

不一定。

如果数据很小，读写都很快，线程竞争也不复杂，QMutex 反而更省心。QReadWriteLock 适合的是“读很多、读很短、写不太频繁”的场景。真正关键不是“读多写少”，而是“读锁能不能足够短”。

比如这种场景适合用：

DeviceStateStateCache::state(intid)const{QReadLockerlocker(&m_lock);returnm_states.value(id);}voidStateCache::updateState(intid,constDeviceState&state){QWriteLockerlocker(&m_lock);m_states[id]=state;}

读一下就返回，写一下就结束，这种很干净。

但如果你的读逻辑里有数据库查询、网络请求、文件 IO、界面刷新、复杂遍历，那就别硬套。那已经不是“读共享数据”了，那是“拿着锁跑业务”。

我的经验：锁要小，数据要清，通知放外面

我现在在 Qt 多线程项目里用 QReadWriteLock，基本有几个固定习惯。

锁里只碰共享数据，不做 UI，不做 IO，不发信号，不调用外部对象的复杂函数。读线程尽量拿快照，写线程尽量批量更新。能用局部数据处理的，就别一直占着锁。

还有一点，别把一把锁传得到处都是。共享锁一旦散到多个类里，后期就很难判断谁在什么时机拿了读锁，谁又在等写锁。项目越大，这种锁越应该收口，最好封装到缓存类里，让外部只调用state()、updateState()、snapshot()这种接口。

比如：

classStateCache{public:QVector<DeviceState>snapshot()const{QReadLockerlocker(&m_lock);returnm_states;}voidupdate(constQVector<DeviceState>&states){QWriteLockerlocker(&m_lock);m_states=states;}private:mutableQReadWriteLock m_lock;QVector<DeviceState>m_states;};