关闭

Qt学习:线程间共享数据

633人阅读 评论(0) 收藏 举报
分类:

Qt线程间共享数据主要有两种方式:

  • 使用共享内存。即使用一个两个线程都能够共享的变量(如全局变量),这样两个线程都能够访问和修改该变量,从而达到共享数据的目的;
  • 使用singal/slot机制,把数据从一个线程传递到另外一个线程。

第一种办法在各个编程语言都使用普遍,而第二种方式倒是QT的特有方式,下面主要学习一下这种方式:

        在线程之间传递signal与在一个线程内传递signal是不一样的。在一个线程内传递signal时,emit语句会直接调用所有连接的slot并等待到所有slot被处理完;在线程之间传递signal时,slot会被放到队列中(queue),而emit这个signal后会马上返回;默认情况,线程之间使用queue机制,而线程内使用direct机制,但在connect中可以改变这些默认的机制。

[c-sharp] view plaincopy
  1. //TextDevice.h  
  2. #ifndef TEXTDEVICE_H  
  3. #define TEXTDEVICE_H  
  4. #include <QThread>  
  5. #include <QString>  
  6. #include <QMutex>  
  7. class TextDevice : public QThread {  
  8.     Q_OBJECT  
  9. public:  
  10.     TextDevice();  
  11.     void run();  
  12.     void stop();  
  13. public slots:  
  14.     void write(const QString& text);  
  15. private:  
  16.     int m_count;  
  17.     QMutex m_mutex;  
  18. };  
  19. #endif // TEXTDEVICE_H  
  20.   
  21.   
  22. //TextDevice.cpp  
  23. #include <QMutexLocker>  
  24. #include <QDebug>  
  25. #include <QString>  
  26. #include "TextDevice.h"  
  27. TextDevice::TextDevice() {  
  28.     m_count = 0;  
  29. }  
  30. void TextDevice::run() {  
  31.     exec();  
  32. }  
  33. void TextDevice::stop() {  
  34.     quit();  
  35. }  
  36. void TextDevice::write(const QString& text) {  
  37.     QMutexLocker locker(&m_mutex);  
  38.     qDebug() << QString("Call %1: %2").arg(m_count++).arg(text);  
  39. }  
  40.   
  41. //TextThread.h  
  42. #ifndef TEXTTHREAD_H  
  43. #define TEXTTHREAD_H  
  44. #include <QThread>  
  45. #include <QString>  
  46. class TextThread : public QThread {  
  47.     Q_OBJECT  
  48. public:  
  49.     TextThread(const QString& text);  
  50.     void run();  
  51.     void stop();  
  52. signals:  
  53.     void writeText(const QString&);  
  54. private:  
  55.     QString m_text;  
  56.     bool m_stop;  
  57. };  
  58. #endif // TEXTTHREAD_H  
  59.   
  60. //TextThread.cpp  
  61. #include "TextThread.h"  
  62. TextThread::TextThread(const QString& text) : QThread() {  
  63.     m_text = text;  
  64.     m_stop = false;  
  65. }  
  66. void TextThread::stop() {  
  67.     m_stop = true;  
  68. }  
  69. void TextThread::run() {  
  70.     while(!m_stop) {  
  71.         emit writeText(m_text);  
  72.         sleep(1);  
  73.     }  
  74. }  
  75.   
  76. //main.cpp  
  77. #include <QApplication>  
  78. #include <QMessageBox>  
  79. #include "TextDevice.h"  
  80. #include "TextThread.h"  
  81.   
  82. int main(int argc, char** argv) {  
  83.     QApplication app(argc, argv);  
  84.     //启动线程  
  85.     TextDevice device;  
  86.     TextThread foo("foo"), bar("bar");  
  87.     //把两个线程使用signal/slot连接起来  
  88.     QObject::connect(&foo, SIGNAL(writeText(const QString&)), &device, SLOT(write(const QString&)));  
  89.     QObject::connect(&bar, SIGNAL(writeText(const QString&)), &device, SLOT(write(const QString&)));  
  90.     //启动线程  
  91.     foo.start();  
  92.     bar.start();  
  93.     device.start();  
  94.     QMessageBox::information(0, "Threading""Close me to stop.");  
  95.     //停止线程  
  96.     foo.stop();  
  97.     bar.stop();  
  98.     device.stop();  
  99.     //等待线程结束  
  100.     device.wait();  
  101.     foo.wait();  
  102.     bar.wait();  
  103.     return 0;  
  104. }  

 

上面例子代码可以看出两个线程之间传送了类型为QString的信息。像QString等这些QT本身定义的类型,直接传送即可。但如果是自己定义的类型如果想使用signal/slot来传递的话,则没有这么简单。直接使用的话,会产生下面这种错误:
          QObject::connect: Cannot queue arguments of type 'TextAndNumber' (Make sure 'TextAndNumber' is registed using qRegisterMetaType().)
         原因:当一个signal被放到队列中(queued)时,它的参数(arguments)也会被一起一起放到队列中(queued起来),这就意味着参数在被传送到slot之前需要被拷贝、存储在队列中(queue)中;为了能够在队列中存储这些参数(argument),Qt需要去construct、destruct、copy这些对象,而为了让Qt知道怎样去作这些事情,参数的类型需要使用qRegisterMetaType来注册(如错误提示中的说明)

        步骤:(以自定义TextAndNumber类型为例)

  • 自定一种类型,在这个类型的顶部包含:#include <QMetaType>
  • 在类型定义完成后,加入声明:Q_DECLARE_METATYPE(TextAndNumber);
  • 在main()函数中注册这种类型:qRegisterMetaType<TextAndNumber>("TextAndNumber");
  • 如果还希望使用这种类型的引用,可同样要注册:qRegisterMetaType<TextAndNumber>("TextAndNumber&");

  1. //TextAndNumber.h  
  2. #ifndef TEXTANDNUMBER_H  
  3. #define TEXTANDNUMBER_H  
  4. #include <QMetaType>  
  5. //必须包含QMetaType,否则会出现下面错误:  
  6. //error: expected constructor, destructor, or type conversion before ‘;’ token  
  7. #include <QString>  
  8. class TextAndNumber {  
  9. public:  
  10.     TextAndNumber();  
  11.     TextAndNumber(int, QString);  
  12.     int count();  
  13.     QString text();  
  14. private:  
  15.     int m_count;  
  16.     QString m_text;  
  17. };  
  18. Q_DECLARE_METATYPE(TextAndNumber);  
  19. #endif // TEXTANDNUMBER_H  
  20.   
  21. //TextAndNumber.cpp  
  22. #include "TextAndNumber.h"  
  23. TextAndNumber::TextAndNumber() {  
  24. }  
  25. TextAndNumber::TextAndNumber(int count, QString text) {  
  26.     m_count = count;  
  27.     m_text = text;  
  28. }  
  29. int TextAndNumber::count() {  
  30.     return m_count;  
  31. }  
  32. QString TextAndNumber::text() {  
  33.     return m_text;  
  34. }  
  35.   
  36. //TextDevice.h  
  37. #ifndef TEXTDEVICE_H  
  38. #define TEXTDEVICE_H  
  39. #include <QThread>  
  40. #include <QDebug>  
  41. #include <QString>  
  42. #include "TextAndNumber.h"  
  43. class TextDevice : public QThread {  
  44.     Q_OBJECT  
  45. public:  
  46.     TextDevice();  
  47.     void run();  
  48.     void stop();  
  49. public slots:  
  50.     void write(TextAndNumber& tran);  
  51. private:  
  52.     int m_count;  
  53. };  
  54.   
  55. #endif // TEXTDEVICE_H  
  56.   
  57. //TextDevice.cpp  
  58. #include "TextDevice.h"  
  59. TextDevice::TextDevice() : QThread() {  
  60.     m_count = 0;  
  61. }  
  62. void TextDevice::run() {  
  63.     exec();  
  64. }  
  65. void TextDevice::stop() {  
  66.     quit();  
  67. }  
  68. void TextDevice::write(TextAndNumber& tran) {  
  69.     qDebug() << QString("Call %1 (%3): %2").arg(m_count++).arg(tran.text()).arg(tran.count());  
  70. }  
  71.   
  72. //TextThread.h  
  73. #ifndef TEXTTHREAD_H  
  74. #define TEXTTHREAD_H  
  75. #include <QThread>  
  76. #include <QString>  
  77. #include "TextAndNumber.h"  
  78. class TextThread : public QThread {  
  79.     Q_OBJECT  
  80. public:  
  81.     TextThread(const QString& text);  
  82.     void run();  
  83.     void stop();  
  84. signals:  
  85.     void writeText(TextAndNumber& tran);  
  86. private:  
  87.     QString m_text;  
  88.     int m_count;  
  89.     bool m_stop;  
  90. };  
  91.   
  92. #endif // TEXTTHREAD_H  
  93.   
  94. //TextThread.cpp  
  95. #include "TextThread.h"  
  96. TextThread::TextThread(const QString& text) : QThread() {  
  97.     m_text = text;  
  98.     m_stop = false;  
  99.     m_count = 0;  
  100. }  
  101. void TextThread::run() {  
  102.     while(!m_stop) {  
  103.         TextAndNumber tn(m_count++, m_text);  
  104.         emit writeText(tn);  
  105.         sleep(1);  
  106.     }  
  107. }  
  108. void TextThread::stop() {  
  109.     m_stop = true;  
  110. }  
  111.   
  112. //main.cpp  
  113. #include <QApplication>  
  114. #include <QMessageBox>  
  115. #include "TextThread.h"  
  116. #include "TextDevice.h"  
  117. #include "TextAndNumber.h"  
  118. int main(int argc, char *argv[])  
  119. {  
  120.     QApplication app(argc, argv);  
  121.     qRegisterMetaType<TextAndNumber>("TextAndNumber");  
  122.     qRegisterMetaType<TextAndNumber>("TextAndNumber&");  
  123.     TextDevice device;  
  124.     TextThread foo("foo"), bar("bar");  
  125.     QObject::connect(&foo, SIGNAL(writeText(TextAndNumber&)), &device, SLOT(write(TextAndNumber&)));  
  126.     QObject::connect(&bar, SIGNAL(writeText(TextAndNumber&)), &device, SLOT(write(TextAndNumber&)));  
  127.     device.start();  
  128.     foo.start();  
  129.     bar.start();  
  130.     QMessageBox::information(0, "Threading""Click me to close");  
  131.   
  132.     foo.stop();  
  133.     bar.stop();  
  134.     device.stop();  
  135.     foo.wait();  
  136.     bar.wait();  
  137.     device.wait();  
  138.     qDebug() << "Application end.";  
  139.     return 0;  
  140. }  

 

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:112829次
    • 积分:1556
    • 等级:
    • 排名:千里之外
    • 原创:13篇
    • 转载:184篇
    • 译文:0篇
    • 评论:6条
    最新评论