[转]Qt多线程编程总结（二）——QMutex

最新推荐文章于 2024-08-05 22:50:54 发布
最新推荐文章于 2024-08-05 22:50:54 发布
阅读量2.7k 收藏
点赞数
分类专栏： QT

QMutex类提供的是线程之间的访问顺序化。

QMutex的目的是保护一个对象、数据结构或者代码段，所以同一时间只有一个线程可以访问它。（在Java术语中，它和同步关键字“synchronized”很相似）。例如，这里有一个方法打印给用户两条消息：

[cpp] view plain copy
  1. void someMethod()  
  2. {  
  3.    qDebug("Hello");  
  4.    qDebug("World");  
  5. }  

如果同时在两个线程中调用这个方法，结果的顺序将是：

  Hello
  Hello
  World
  World

如果你使用了一个互斥量：

[cpp] view plain copy
  1. QMutex mutex;  
  2.   
  3. void someMethod()  
  4. {  
  5.    mutex.lock();  
  6.    qDebug("Hello");  
  7.    qDebug("World");  
  8.    mutex.unlock();  
  9. }  

用Java的术语，这段代码应该是：

[cpp] view plain copy
  1. void someMethod()  
  2. {  
  3.    synchronized {  
  4.      qDebug("Hello");  
  5.      qDebug("World");  
  6.    }  
  7. }  

然后同一时间只有一个线程可以运行someMethod并且消息的顺序也一直是正确的。当然，这只是一个很简单的例子，但是它适用于任何需要按特定频率发生的情况。

但你在一个线程中调用lock()，其它线程将会在同一地点试图调用lock()来阻塞，知道这个线程调用unlock()之后其它线程才会获得这个锁。lock()的一种非阻塞选择是tryLock()。

实验部分：

情形一：

[cpp] view plain copy
  1. #include <QtCore/QCoreApplication>  
  2. #include <Qthread>  
  3. #include <QTextStream>  
  4. class MyThreadA : public QThread {    
  5. public:      
  6. virtual void run();    
  7. };    
  8. class MyThreadB: public QThread {    
  9. public:      
  10. virtual void run();    
  11. };  
  12. int number=6;  
  13. void MyThreadA::run(){    
  14. number *= 5;  
  15. number /= 4;  
  16. }    
  17. void MyThreadB::run(){  
  18. number *= 3;  
  19. number /= 2;  
  20. }   
  21. int main(int argc, char *argv[])  
  22. {     
  23. QCoreApplication app(argc, argv);  
  24. MyThreadA a;    
  25. MyThreadB b;    
  26. a.run();  
  27. b.run();  
  28.  a.terminate();  
  29. b.terminate();  
  30. QTextStream out(stdout);  
  31. out<<number;  
  32. return app.exec();  
  33. }   

上述代码，很简单，写了两个线程，覆盖了QThread的纯虚函数run()，这两个重构的run方法都是对全局变量number的操作，

主函数中顺序调用这两个方法，a.run()执行后number为7,b.run()执行后为10。

情形二：

[cpp] view plain copy
  1. #include <QtCore/QCoreApplication>  
  2. #include <Qthread>  
  3. #include <QTextStream>  
  4. class MyThreadA : public QThread {    
  5. public:      
  6. virtual void run();    
  7. };    
  8. class MyThreadB: public QThread {    
  9. public:      
  10. virtual void run();    
  11. };  
  12. int number=6;  
  13. void MyThreadA::run(){    
  14. number *= 5;  
  15. sleep(1);  
  16. number /= 4;  
  17. }    
  18. void MyThreadB::run(){  
  19. number *= 3;  
  20. sleep(1);  
  21. number /= 2;  
  22. }   
  23. int main(int argc, char *argv[])  
  24. {     
  25. QCoreApplication app(argc, argv);  
  26. MyThreadA a;    
  27. MyThreadB b;    
  28. a.start();  
  29. b.start();    
  30. a.wait();    
  31. b.wait();   
  32. QTextStream out(stdout);  
  33. out<<number；  
  34. return app.exec();  
  35. }   

运行结果：

number=11;

利用QThread的方法start()同是开启两个线程，值得注意的是wait()函数，不能等待自己，这个是用来多个线程交互的，所以不能当sleep()用。这个函数是在主线程中被调用的时候阻塞了主线程。如果想在外部让子线程暂停，最好的办法是在子线程中设置一个标志，在主线程中更改这个标志，并在子线程的run函数中判断，通过调用其保护函数sleep()来达到暂停的目的了。

查看源代码，即可有清楚的概念：

[cpp] view plain copy
  1. bool QThread::wait(unsigned long time)  
  2. {  
  3.     Q_D(QThread);  
  4.     QMutexLocker locker(&d->mutex);   
  5.     if (d->id == GetCurrentThreadId()) {  
  6.         qWarning("QThread::wait: Thread tried to wait on itself");     //当是自身时，直接返回false  
  7.         return false;  
  8.     }  
  9.     if (d->finished || !d->running) //与这个线程对象关联的线程已经结束执行（例如从run函数返回）。如果线程结束返回真值。如果线程还没有开始也返回真值。  
  10.         return true;  
  11.     ++d->waiters;  
  12.     locker.mutex()->unlock();  
  13.   
  14.   
  15.     bool ret = false;  
  16.     switch (WaitForSingleObject(d->handle, time)) {   //调用win的对象处理函数  
  17.     case WAIT_OBJECT_0:    //核心对象被激活，等待成功  
  18.         ret = true;  
  19.         break;  
  20.     case WAIT_FAILED:  
  21.         qErrnoWarning("QThread::wait: Thread wait failure");       
  22.         break;  
  23.     case WAIT_ABANDONED:  
  24.     case WAIT_TIMEOUT:  
  25.     default:  
  26.         break;  
  27.     }  
  28.     locker.mutex()->lock();  
  29.     --d->waiters;  
  30.     if (ret && !d->finished) {                                  //虽然响应成功，但关联对象未结束执行  
  31.         // thread was terminated by someone else  
  32.         d->terminated = true;              
  33.         QThreadPrivate::finish(this, false);  
  34.     }  
  35.     if (d->finished && !d->waiters) {    //关联对象执行结束，并且等待数为零时，关闭句柄。  
  36.         CloseHandle(d->handle);  
  37.         d->handle = 0;  
  38.     }  
  39.     return ret;  
  40. }  


情形三：（Mutex 作用）

[cpp] view plain copy
  1. #include <QtCore/QCoreApplication>  
  2. #include <Qthread>  
  3. #include <QTextStream>  
  4. #include <QMutex>  
  5. class MyThreadA : public QThread {    
  6. public:      
  7. virtual void run();    
  8. };    
  9. class MyThreadB: public QThread {    
  10. public:      
  11. virtual void run();    
  12. };  
  13. QMutex mutex;  
  14. int number=6;  
  15. void MyThreadA::run(){    
  16. mutex.lock();  
  17. number *= 5;  
  18. sleep(1);  
  19. number /= 4;  
  20. mutex.unlock();  
  21. }    
  22. void MyThreadB::run(){  
  23. mutex.lock();  
  24. number *= 3;  
  25. sleep(1);  
  26. number /= 2;  
  27. mutex.unlock();  
  28. }   
  29. int main(int argc, char *argv[])  
  30. {     
  31. QCoreApplication app(argc, argv);  
  32. MyThreadA a;    
  33. MyThreadB b;    
  34. a.start();  
  35. b.start();    
  36. a.wait();    
  37. b.wait();    
  38. QTextStream out(stdout);  
  39. out<<number;  
  40. return app.exec();  
  41. }   

运行结果：

number=10;

通过实验结果可以看出，QMutex保护了全局变量，同一时间只有一个线程可以访问它。

只得一提的是tryLock()的使用，若以上代码换为mutex.tryLock();那么执行结果可能为11，因为是试图锁定互斥量。如果锁被得到，这个函数返回真。如果另一个进程已经锁定了这个互斥量，这个函数返回假，而不是一直等到这个锁可用为止。

且不能添上sleep()函数，否则提示 "A mutex must be unlocked in the same thread that locked it."的运行错误。
Emdfans
关注
专栏目录
Qt开发总结（27）——多线程
学习雷锋好榜样
03-14 1026
多线程编程炙手可热，尤其是当代多核处理器的硬件条件下，多线程可以更好的利用系统硬件资源。Qt对多线程的支持也非常好，本篇笔记总结下Qt的多线程技术。 概述 Qt对多线程的支持优点在于：跨平台的多线程类，线程安全的事件投递以及跨线程的信号-槽连接。Qt中涉及的主要线程类有： 类名 描述 QAtomicInteger 独立于...
Qt多线程编程总结（二）——QMutex
wangxiaohigh
11-13 851
QMutex类提供的是线程之间的访问顺序化。 QMutex的目的是保护一个对象、数据结构或者代码段，所以同一时间只有一个线程可以访问它。（在Java术语中，它和同步关键字“synchronized”很相似）。例如，这里有一个方法打印给用户两条消息： void someMethod() { qDebug("Hello"); qDebug("World"); ...
QThread::wait: Thread tried to wait on itself
最新发布
宏笋的博客
08-05 360
由于使用的是MyObjec::deleteLater()函数，MyObjectt的析构函数是在子线程中执行的，子线程的退出也是在子线程中执行的，因而报警，且线程退出失败（没有执行。由此可见，子线程的退出操作是在主线程中完成的，不仅没有报错，而且线程也成功退出了（执行了线程退出槽函数）由此可见，主线程的线程ID为0x43f4，子线程的线程ID为0x2790。解决方法：在线程外的其他线程中，调用线程的wait()方法。原因：在自己的线程中调用线程的wait()方法。
QMutex
红娃子
08-20 4619
QMutex提供了线程间的顺序访问。 QMutex的目的是保护一个对象、数据结构或者代码段，所以同一时间只有一个线程可以访问它。（类似java的"synchronized”关键字）。互斥量最好和QMutexLocker搭配使用，因为它使得互斥量的解锁和锁定变得相当一致。 比如:  int number = 6;  void method1()  {      number *= 5;
Qt多线程之QMutex
YBAdiam的博客
08-16 1081
QMutex类提供的是线程之间的访问顺序化。   QMutex的目的是保护一个对象、数据结构或者代码段，所以同一时间只有一个线程可以访问它。（在Java术语中，它和同步关键字“synchronized”很相似）,(在Objective-C术语中，它和同步关键字“dispatch_sync”很相似)。例如，这里有一个方法打印给用户两条消息： void someMethod() { qD...
【Qt学习】08 Qt多线程之QMutex
sunriver2000的专栏
07-25 664
概述 学习内容：QMutex在多线程中的使用。 环境 IDE：Qt creator 4.11.0 编译器：MinGW 5.3.0 32bit for C++ 代码 1、mythreada.h #ifndef MYTHREADA_H #define MYTHREADA_H #include <QThread> #include <QMutex> #include <QDebug> class MyThreadA : public QThrea..
Qt5开发从入门到精通——第十二篇二节（Qt5 事件处理及实例——多线程控制(1)
2401_84182793的博客
04-28 676
本章节会给大家带来Qt5 事件处理及实例——多线程控制、互斥量、信号量、线程等待与唤醒详解。介绍 Qt 线程同步、互斥控制的基本方法。线程之间存在着互相制约的关系，具体可分为互斥和同步这两种关系。实现线程的互斥与同步常使用的类有 QMutex 、 QMutexLocker 、 QReadWriteLocker 、QReadLocker 、 QWriteLocker 、 QSemaphore 和 QWaitCondition。
Qt开发总结（24）——串口编程
学习雷锋好榜样
01-11 2030
本篇将总结Qt的串口编程。Qt4中并没有串口模块支持，但自Qt5.1开始，官方加入了serialport模块，使得我们可以轻松使用该模块实现跨平台串口操作。 概述 Qt Serial Port提供了基本的串口操作接口函数。包括配置，I/O操作，获取和设置RS-232控制管脚信号等。使用时需要添加模块支持并在调用相关接口的文件中添加头文件支持： QT += serialport #inclu...
【Qt 5】Qt中QMutex的一点理解
墨小鱼
12-18 1万+
在Qt的多线程控制中，互斥量的访问最简单的控制是添加一个mutex锁，对一个函数或者变量锁定。 一直不理解QMutex中的锁是如何运行的，或者说如何利用这个锁将变量进行锁定。官方实例是这样的： 1 QMutex mutex; 2 int number = 6; 3 4 void method1() 5 { 6 mutex.lock(); 7 number *=...
QMutex 的使用
thanklife的专栏
09-26 1183
2，在一个函数里面使用 QMutexLocker。3,结合使用QWaitCondition使用。首先说引用头文件，建立该成员变量；1，使用lock和unlock；函数结束则m_mutex解锁；
qt 线程同步-互斥量(Qmutex)
alex1801
10-20 1万+
在多线程应用程序中，由于多个线程的存在，线程之间可能需要访问同一个变量，或一个线程需要等待另外一个线程完成某个操作后才产生相应的动作，这时候就需要做线程同步。所以，需要线程同步情况： 1）多个线程之间访问同一个变量； 2）一个线程需要等待另外一个线程完成某个操作后才产生相应的动作。 问题引入： 示例1，使用了信号与槽机制，在产生新的骰子之后使用信号通知主线程读取新数据。如果不使用信号与槽，就需要主线程进行查询。 1、基于互斥量的线程同...
Qt之QMutex
ydd3625的博客
08-19 968
Qt之QMutex 概述 QMutex 类使得线程之间可序列化，文档中的描述为provides access serialization between threads 它被设计的初衷是用来保护一个对象、数据结构、代码段、使得它们在同一一时刻，只有一个线程有访问权限（这有点跟java中的synchronized关键字类似）。 场景 比如我们有如下的代码片段：
PyQt5中的QMutex
xy_optics的博客
05-19 1529
在PyQt5中，QMutex（互斥锁）用于在线程之间保护共享资源，确保同一时间只有一个线程能够访问某个特定的资源。这是通过锁定和解锁机制实现的。以下是QMutex在PyQt5中的作用与用途作用用途防止数据竞争避免多个线程同时访问和修改共享数据，确保数据一致性。保证线程安全保护多线程应用中的关键代码段，防止并发访问导致的不可预见行为。同步线程操作确保线程按照预期的顺序执行，避免操作混乱。基本使用创建QMutex对象锁定互斥锁# 访问共享资源的代码尝试锁定互斥锁# 访问共享资源的代码。
Qt互斥锁(QMutex)的使用、QMutexLocker的使用（含源码+注释）
热门推荐
lw的博客
03-18 3万+
一、QMutex和QMutexLocker的关系（个人理解） 互斥锁（QMutex）在使用时需要在进入和结束的时候使用对应的函数锁定和解锁。在简单的程序中还好，但是在结构复杂的程序中因为需要手动锁定和解锁，很容易忽略细节而出现问题，于是为了应对这种情况QMutexLocker便诞生了（为了简化简化互斥锁的锁定和解锁）。 QMutexLocker通常创建为局部变量，QMutexLocker在创建时传入一个并未锁定（若是锁定可用relock重新锁定或unlock解锁）的QMutex指针变量，并且会将QMutex
【QT小记】QT中互斥锁QMutex的简单使用
林柒Sevenlin随记
04-23 5587
意图 保护共享资源（对象、数据结构、代码段） 保证在同一时刻只有一个线程在使用共享资源 QMutex // 阻塞加锁 void lock() // 非阻塞加锁 bool tryLock(int timeout = 0) // 解锁 void unlock() QMutexLocker 对QMutex进行了RAII的封装 方便对锁的操作，避免忘记unlock 建议使用这种方式操作互斥锁 QMutex mutex; QMutexLocker mutexLocker(&mutex); 使用
QMutex 与 QMutexLocker
maonianlove的博客
08-08 1024
如果您的程式只是一個單執行緒，單一流程的程式，那麼通常您只要注意到程式邏輯的正確，您的程式通常就可以正確的執行您想要的功能，但當您的程式是多執行緒程式，多流程同時執行時，那麼您就要注意到更多的細節，例如在多執行緒共用同一物件的資料時。 如果一個物件所持有的資料可以被多執行緒同時共享存取時，您必須考慮到「資料同步」的 問題，所謂資料同步指的是兩份資料的整體性一致，例如物件A有 name與id兩個屬性...
Qt多线程编程详解：C++实现与线程同步
在Qt多线程编程中，开发者可以利用丰富的线程支持来优化并发执行，提高程序性能。首先，我们了解Qt提供的核心线程类： 1. **QThread**：这是Qt中用于创建新线程的基本工具，它继承自QObject。开发人员可以通过派生...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值