Qt多线程编程总结（二）——QMutex .

最新推荐文章于 2023-05-22 19:00:00 发布
最新推荐文章于 2023-05-22 19:00:00 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： QT

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

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

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

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

  Hello
  Hello
  World
  World

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

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

  void someMethod()
  {
     mutex.lock();
     qDebug("Hello");
     qDebug("World");
     mutex.unlock();
  }

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

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

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

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

实验部分：

情形一：

[cpp] view plain copy print ?
  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. }   
#include <QtCore/QCoreApplication>
#include <Qthread>
#include <QTextStream>
class MyThreadA : public QThread {  
public:    
virtual void run();  
};  
class MyThreadB: public QThread {  
public:    
virtual void run();  
};
int number=6;
void MyThreadA::run(){  
number *= 5;
number /= 4;
}  
void MyThreadB::run(){
number *= 3;
number /= 2;
} 
int main(int argc, char *argv[])
{   
QCoreApplication app(argc, argv);
MyThreadA a;  
MyThreadB b;  
a.run();
b.run();
 a.terminate();
b.terminate();
QTextStream out(stdout);
out<<number;
return app.exec();
}

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

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

情形二：

[cpp] view plain copy print ?
  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. }   
#include <QtCore/QCoreApplication>
#include <Qthread>
#include <QTextStream>
class MyThreadA : public QThread {  
public:    
virtual void run();  
};  
class MyThreadB: public QThread {  
public:    
virtual void run();  
};
int number=6;
void MyThreadA::run(){  
number *= 5;
sleep(1);
number /= 4;
}  
void MyThreadB::run(){
number *= 3;
sleep(1);
number /= 2;
} 
int main(int argc, char *argv[])
{   
QCoreApplication app(argc, argv);
MyThreadA a;  
MyThreadB b;  
a.start();
b.start();  
a.wait();  
b.wait(); 
QTextStream out(stdout);
out<<number；
return app.exec();
}

运行结果：

number=11;

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

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

[cpp] view plain copy print ?
  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. }  
bool QThread::wait(unsigned long time)
{
    Q_D(QThread);
    QMutexLocker locker(&d->mutex); 
    if (d->id == GetCurrentThreadId()) {
        qWarning("QThread::wait: Thread tried to wait on itself");     //当是自身时，直接返回false
        return false;
    }
    if (d->finished || !d->running) //与这个线程对象关联的线程已经结束执行（例如从run函数返回）。如果线程结束返回真值。如果线程还没有开始也返回真值。
        return true;
    ++d->waiters;
    locker.mutex()->unlock();


    bool ret = false;
    switch (WaitForSingleObject(d->handle, time)) {   //调用win的对象处理函数
    case WAIT_OBJECT_0:    //核心对象被激活，等待成功
        ret = true;
        break;
    case WAIT_FAILED:
        qErrnoWarning("QThread::wait: Thread wait failure");     
        break;
    case WAIT_ABANDONED:
    case WAIT_TIMEOUT:
    default:
        break;
    }
    locker.mutex()->lock();
    --d->waiters;
    if (ret && !d->finished) {                                  //虽然响应成功，但关联对象未结束执行
        // thread was terminated by someone else
        d->terminated = true;            
        QThreadPrivate::finish(this, false);
    }
    if (d->finished && !d->waiters) {    //关联对象执行结束，并且等待数为零时，关闭句柄。
        CloseHandle(d->handle);
        d->handle = 0;
    }
    return ret;
}


情形三：（Mutex 作用）

[cpp] view plain copy print ?
  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. }   
#include <QtCore/QCoreApplication>
#include <Qthread>
#include <QTextStream>
#include <QMutex>
class MyThreadA : public QThread {  
public:    
virtual void run();  
};  
class MyThreadB: public QThread {  
public:    
virtual void run();  
};
QMutex mutex;
int number=6;
void MyThreadA::run(){  
mutex.lock();
number *= 5;
sleep(1);
number /= 4;
mutex.unlock();
}  
void MyThreadB::run(){
mutex.lock();
number *= 3;
sleep(1);
number /= 2;
mutex.unlock();
} 
int main(int argc, char *argv[])
{   
QCoreApplication app(argc, argv);
MyThreadA a;  
MyThreadB b;  
a.start();
b.start();  
a.wait();  
b.wait();  
QTextStream out(stdout);
out<<number;
return app.exec();
}

运行结果：

number=10;

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

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

且不能添上sleep()函数，否则提示 "A mutex must be unlocked in the same thread that locked it."的运行错误。

物联Bill
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt多线程开发时报错：QThread::wait: Thread tried to wait on itself 的解决方案，以及牵扯出来的一个重大注意事项
十三阿哥的博客
09-21 1151
【代码】Qt多线程开发时报错：QThread::wait: Thread tried to wait on itself 的解决方案，以及牵扯出来的一个重大注意事项。
Multi-thread in Qt
mr_cai2009的专栏
07-20 2182
目录 Qt 多线程概览 如何使用 创建线程 启动线程 终止线程 停止QThread 停止QRunnable 停止QtConcurrent::run() QThread 实现细节 QThread::start() QThreadPrivate::start() QThreadPrivate::finish() QThread::wait() QThreadPool 工作...
Qt源码分析--QThread(5)
exlink2012的专栏
04-13 1728
解析了QThread的setPriority、setStackSize、setTerminationEnabled、msleep、sleep、usleep、wait等函数。
Qt多线程编程总结（二）——QMutex
wangxiaohigh
11-13 817
QMutex类提供的是线程之间的访问顺序化。 QMutex的目的是保护一个对象、数据结构或者代码段，所以同一时间只有一个线程可以访问它。（在Java术语中，它和同步关键字“synchronized”很相似）。例如，这里有一个方法打印给用户两条消息： void someMethod() { qDebug("Hello"); qDebug("World"); ...
QThread之moveToThread实现方式
weixin_40425059的博客
04-14 1193
Qt提供了两种多线程的使用方法，下面针对这两种方法分别进行一下说明。 方法一 继承自QThread 该方法比较简单，只需定义自己的类，让该类继承自QThread，并重写QThread类的run函数，注意：所有耗时的操作请放在run函数中去执行，此多线程的方法有且只有run中的程序是在新的子线程中运行的，其他代码仍在创建该线程所在的线程中执行。调用start函数开始线程的执行，stop结束线程的执行...
Qt多线程.zip 有几篇关于QT多线程编程的文章
02-05
这个文档是提供给那些对多线程编程有丰富的知识和经验的听众的。推荐阅读： Threads Primer: A Guide to Multithreaded Programming Thread Time: The Multithreaded Programming Guide Pthreads ...
Qt两种方法实现多线程并安全结束线程及QMutex加锁Qt单例化实现
11-07
Qt两种方法实现多线程的开启，及子线程的安全结束线程，及QMutex加锁，Qt单例化实现
QT 利用继承Qobject实现多线程
06-01
QT 利用继承Qobject实现多线程 利用moveToThread（）函数将所需在新线程中处理的内容转移到开辟的新线程中 此外还利用了<QMutex>对不同线程进行加锁
QtThread.rar
05-04
QtThread 多线程DEMO程序 ，程序使用了qThread类编程，包括使用 QMutex ，QMutexLocker做线程同步
多线程锁的使用规范
02-09
多线程锁使用规范： 【规则1】定义的锁及保护的对象要放在一起声明，同时注明该锁要保护的对象。例如在类的声明中，声明一个m_objA成员变量，和保护此变量的锁m_mutexObjA.....
从pthread 到QThread
weixin_34397291的博客
07-01 439
该文出自：http://www.civilnet.cn/bbs/topicno/78430   使用线程技术进行应用编程的意义在gemfield的文章《从进程到线程》中已经介绍过了，我们就直奔主题：Linux上的线程开发以及Qt对线程的封装(Linux平台部分)。Linux上的线程API使用的是pthread库，我们来粗略认识下pthread。 要在程序中使用pthread线程，究竟会用到哪...
子类化QThread实现多线程
weixin_45032957的博客
11-09 360
二、不使用事件循环实例# InheritQThread.hpp Copy class InheritQThread:public QThread { Q_OBJECT public: InheritQThread(QObject *parent = Q_NULLPTR):QThread(parent){ } void StopThread(){ QMutexLocker lock(&m_lock); m_flag = false; } protected: //线程执行函数 vo
七、Qt多线程之QThread
Newmamahaha的博客
10-31 676
关于多线程这个话题，相信大部分人都比较熟悉，但是要想深入理解多线程本质的话，多半得借助MCU以及RTOS这样的片上系统，今天就不深入展开，我们放在下一篇分析。从使用的角度，线程真的很棒很好用，特别是Qt库对多线程的封装，使得线程使用起来更加优雅，更少的代码和更简单的使用方式，今天就来详细分析qt的线程的使用方式以及应用场景等等。
QThread学习笔记
培培哥的专栏
11-13 1714
1、QThread用到的函数 start()函数：会在新的线程中执行run()函数的内容。 terminate()函数：可以终止线程。线程有可能马上终止，也有可能不会马上终止，这取决于操作系统的调度策略。在使用terminate()函数后使用wait()函数可保证线程终止（备注：在调用terminate()函数时，线程可能正在修改数据，这可能会让线程没有机会释放一些资源，包括自身使用的空间、互...
QT编程之——使用全局变量
在代码身上，用心去飞翔
05-19 1万+
在Qt中使用全局变量的实例 1.首先需要在一个头文件中对全局了变量使用exern方法进行定义。 //g.h extern char *testStr; 2.只能在cpp文件中对其是实例化，并且实例化只能在函数的外部进行。建议在包含main函数的cpp文件中进行实例化，这样可以确保在其他文件中使用时，它已经被实例化。 //a.h #include "g.h" char *testStr=
【Qt】Qt的线程（两种QThread类的详细使用方式）
热门推荐
Yngz_Miao的博客
11-26 5万+
Qt提供QThread类以进行多任务处理。与多任务处理一样，Qt提供的线程可以做到单个线程做不到的事情。例如，网络应用程序中，可以使用线程处理多种连接器。 QThread继承自QObject类，且提供QMutex类以实现同步。线程和进程共享全局变量，可以使用互斥体对改变后的全局变量值实现同步。因此，必须编辑全局数据时，使用互斥体实现同步，其它进程则不能改变或浏览全局变量值。 什么是互斥体？ ...
Spring @Async：SpringBoot 自定义线程池，修改springboot的默认线程池
z69183787的专栏
09-16 2626
1. 自定义线程池 1.1 修改application.properties task.pool.corePoolSize=20 task.pool.maxPoolSize=40 task.pool.keepAliveSeconds=300 task.pool.queueCapacity=50 1.2 线程池配置属性类TaskThreadPoolConfig .java import org.springframework.boot.context.properties.Configurat
pyqt5 QThread 子线程 出错记录和处理总结
m0_62073075的博客
05-22 729
Destroyed while thread is still running，这个错误可能是子线程的生命周期不足，也可能是在子线程中运行了控件。
Qt多线程编程的线程安全
最新发布
12-17
Qt多线程编程中的线程安全是指多个线程同时访问共享资源时，不会出现数据竞争和不一致的情况。Qt提供了多种线程安全的机制来保证多线程编程的正确性，包括但不限于以下几种： 1.互斥锁（QMutex）：用于保护共享资源，同一时间只允许一个线程访问共享资源。 2.读写锁（QReadWriteLock）：用于读多写少的场景，多个线程可以同时读取共享资源，但只允许一个线程写入共享资源。 3.信号槽机制（signals and slots）：用于线程间的通信，可以在不同线程之间发送信号和槽函数，保证线程安全。 4.事件机制（QEvent）：用于线程间的通信，可以在不同线程之间发送事件和事件处理函数，保证线程安全。 5.线程局部存储（QThreadStorage）：用于在线程内部存储线程私有数据，保证线程安全。 下面是一个使用互斥锁实现线程安全的例子： ```cpp class Counter : public QObject { Q_OBJECT public: Counter(QObject *parent = nullptr) : QObject(parent), m_value(0) {} public slots: void increment() { QMutexLocker locker(&m_mutex); ++m_value; } void decrement() { QMutexLocker locker(&m_mutex); --m_value; } signals: void valueChanged(int value); private: int m_value; QMutex m_mutex; }; ``` 在上面的例子中，Counter类中的increment()和decrement()函数都使用了互斥锁来保护m_value变量的访问，从而保证了线程安全。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值