详解 Qt 线程间共享数据

最新推荐文章于 2024-03-20 08:57:03 发布
最新推荐文章于 2024-03-20 08:57:03 发布
阅读量2.4k 收藏 6
点赞数 1

http://www.cnblogs.com/bingcaihuang/archive/2011/07/14/2106885.html

使用共享内存。即使用一个两个线程都能够共享的变量（如全局变量），这样两个线程都能够访问和修改该变量，从而达到共享数据的目的。

Qt 线程间共享数据是本文介绍的内容，多的不说，先来啃内容。Qt线程间共享数据主要有两种方式：

使用共享内存。即使用一个两个线程都能够共享的变量（如全局变量），这样两个线程都能够访问和修改该变量，从而达到共享数据的目的；

使用singal/slot机制，把数据从一个线程传递到另外一个线程。

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

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

view plaincopy to clipboardprint?  
//TextDevice.h    
#ifndef TEXTDEVICE_H    
#define TEXTDEVICE_H    
#include <QThread>    
#include <QString>    
#include <QMutex>     
class TextDevice : public QThread {     
    Q_OBJECT     
public:     
    TextDevice();     
    void run();     
    void stop();     
public slots:     
    void write(const QString& text);     
private:     
    int m_count;     
    QMutex m_mutex;     
};    
#endif // TEXTDEVICE_H     
    
    
//TextDevice.cpp    
#include <QMutexLocker>    
#include <QDebug>    
#include <QString>    
#include "TextDevice.h"     
TextDevice::TextDevice() {     
    m_count = 0;     
}     
void TextDevice::run() {     
    exec();     
}     
void TextDevice::stop() {     
    quit();     
}     
void TextDevice::write(const QString& text) {     
    QMutexLocker locker(&m_mutex);     
    qDebug() << QString("Call %1: %2").arg(m_count++).arg(text);     
}     
    
//TextThread.h    
#ifndef TEXTTHREAD_H    
#define TEXTTHREAD_H    
#include <QThread>    
#include <QString>     
class TextThread : public QThread {     
    Q_OBJECT     
public:     
    TextThread(const QString& text);     
    void run();     
    void stop();     
signals:     
    void writeText(const QString&);     
private:     
    QString m_text;     
    bool m_stop;     
};    
#endif // TEXTTHREAD_H     
    
//TextThread.cpp    
#include "TextThread.h"     
TextThread::TextThread(const QString& text) : QThread() {     
    m_text = text;     
    m_stop = false;     
}     
void TextThread::stop() {     
    m_stop = true;     
}     
void TextThread::run() {     
    while(!m_stop) {     
        emit writeText(m_text);     
        sleep(1);     
    }     
}     
    
//main.cpp    
#include <QApplication>    
#include <QMessageBox>    
#include "TextDevice.h"    
#include "TextThread.h"     
    
int main(int argc, char** argv) {     
    QApplication app(argc, argv);     
    //启动线程     
    TextDevice device;     
    TextThread foo("foo"), bar("bar");     
    //把两个线程使用signal/slot连接起来     
    QObject::connect(&foo, SIGNAL(writeText(const QString&)), &device, SLOT(write(const QString&)));     
    QObject::connect(&bar, SIGNAL(writeText(const QString&)), &device, SLOT(write(const QString&)));     
    //启动线程     
    foo.start();     
    bar.start();     
    device.start();     
    QMessageBox::information(0, "Threading", "Close me to stop.");     
    //停止线程     
    foo.stop();     
    bar.stop();     
    device.stop();     
    //等待线程结束     
    device.wait();     
    foo.wait();     
    bar.wait();     
    return 0;     
}    
//TextDevice.h  
#ifndef TEXTDEVICE_H  
#define TEXTDEVICE_H  
#include <QThread> 
#include <QString> 
#include <QMutex> 
class TextDevice : public QThread {  
    Q_OBJECT  
public:  
    TextDevice();  
    void run();  
    void stop();  
public slots:  
    void write(const QString& text);  
private:  
    int m_count;  
    QMutex m_mutex;  
};  
#endif // TEXTDEVICE_H  
 
 
//TextDevice.cpp  
#include <QMutexLocker> 
#include <QDebug> 
#include <QString> 
#include "TextDevice.h"  
TextDevice::TextDevice() {  
    m_count = 0;  
}  
void TextDevice::run() {  
    exec();  
}  
void TextDevice::stop() {  
    quit();  
}  
void TextDevice::write(const QString& text) {  
    QMutexLocker locker(&m_mutex);  
    qDebug() << QString("Call %1: %2").arg(m_count++).arg(text);  
}  
 
//TextThread.h  
#ifndef TEXTTHREAD_H  
#define TEXTTHREAD_H  
#include <QThread> 
#include <QString> 
class TextThread : public QThread {  
    Q_OBJECT  
public:  
    TextThread(const QString& text);  
    void run();  
    void stop();  
signals:  
    void writeText(const QString&);  
private:  
    QString m_text;  
    bool m_stop;  
};  
#endif // TEXTTHREAD_H  
 
//TextThread.cpp  
#include "TextThread.h"  
TextThread::TextThread(const QString& text) : QThread() {  
    m_text = text;  
    m_stop = false;  
}  
void TextThread::stop() {  
    m_stop = true;  
}  
void TextThread::run() {  
    while(!m_stop) {  
        emit writeText(m_text);  
        sleep(1);  
    }  
}  
 
//main.cpp  
#include <QApplication> 
#include <QMessageBox> 
#include "TextDevice.h"  
#include "TextThread.h"  
int main(int argc, char** argv) {  
    QApplication app(argc, argv);  
    //启动线程  
    TextDevice device;  
    TextThread foo("foo"), bar("bar");  
    //把两个线程使用signal/slot连接起来  
    QObject::connect(&foo, SIGNAL(writeText(const QString&)), &device, SLOT(write(const QString&)));  
    QObject::connect(&bar, SIGNAL(writeText(const QString&)), &device, SLOT(write(const QString&)));  
    //启动线程  
    foo.start();  
    bar.start();  
    device.start();  
    QMessageBox::information(0, "Threading", "Close me to stop.");  
    //停止线程  
    foo.stop();  
    bar.stop();  
    device.stop();  
    //等待线程结束  
    device.wait();  
    foo.wait();  
    bar.wait();  
    return 0;  
}

上面例子代码可以看出两个线程之间传送了类型为QString的信息。像QString等这些QT本身定义的类型，直接传送即可。但如果是自己定义的类型如果想使用signal/slot来传递的话，则没有这么简单。直接使用的话，会产生下面这种错误：

1 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&");

原因：当一个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&");

view plaincopy to clipboardprint?  
//TextAndNumber.h     
#ifndef TEXTANDNUMBER_H     
#define TEXTANDNUMBER_H     
#include <QMetaType>     
//必须包含QMetaType，否则会出现下面错误：     
//error: expected constructor, destructor, or type conversion before ‘;’ token     
#include <QString>     
class TextAndNumber {     
public:     
    TextAndNumber();     
    TextAndNumber(int, QString);     
    int count();     
    QString text();     
private:     
    int m_count;     
    QString m_text;     
};     
Q_DECLARE_METATYPE(TextAndNumber);     
#endif // TEXTANDNUMBER_H     
    
//TextAndNumber.cpp     
#include "TextAndNumber.h"     
TextAndNumber::TextAndNumber() {     
}     
TextAndNumber::TextAndNumber(int count, QString text) {     
    m_count = count;     
    m_text = text;     
}     
int TextAndNumber::count() {     
    return m_count;     
}     
QString TextAndNumber::text() {     
    return m_text;     
}     
    
//TextDevice.h     
#ifndef TEXTDEVICE_H     
#define TEXTDEVICE_H     
#include <QThread>     
#include <QDebug>     
#include <QString>     
#include "TextAndNumber.h"     
class TextDevice : public QThread {     
    Q_OBJECT     
public:     
    TextDevice();     
    void run();     
    void stop();     
public slots:     
    void write(TextAndNumber& tran);     
private:     
    int m_count;     
};     
#endif // TEXTDEVICE_H     
    
//TextDevice.cpp     
#include "TextDevice.h"     
TextDevice::TextDevice() : QThread() {     
    m_count = 0;     
}     
void TextDevice::run() {     
    exec();     
}     
void TextDevice::stop() {     
    quit();     
}     
void TextDevice::write(TextAndNumber& tran) {     
    qDebug() << QString("Call %1 (%3): %2").arg(m_count++).arg(tran.text()).arg(tran.count());     
}     
    
//TextThread.h     
#ifndef TEXTTHREAD_H     
#define TEXTTHREAD_H     
#include <QThread>     
#include <QString>     
#include "TextAndNumber.h"     
class TextThread : public QThread {     
    Q_OBJECT     
public:     
    TextThread(const QString& text);     
    void run();     
    void stop();     
signals:     
    void writeText(TextAndNumber& tran);     
private:     
    QString m_text;     
    int m_count;     
    bool m_stop;     
};     
    
#endif // TEXTTHREAD_H     
    
//TextThread.cpp     
#include "TextThread.h"     
TextThread::TextThread(const QString& text) : QThread() {     
    m_text = text;     
    m_stop = false;     
    m_count = 0;     
}     
void TextThread::run() {     
    while(!m_stop) {     
        TextAndNumber tn(m_count++, m_text);     
        emit writeText(tn);     
        sleep(1);     
    }     
}     
void TextThread::stop() {     
    m_stop = true;     
}     
    
//main.cpp     
#include <QApplication>     
#include <QMessageBox>     
#include "TextThread.h"     
#include "TextDevice.h"     
#include "TextAndNumber.h"     
int main(int argc, char *argv[])     
{     
    QApplication app(argc, argv);     
    qRegisterMetaType<TextAndNumber>("TextAndNumber");     
    qRegisterMetaType<TextAndNumber>("TextAndNumber&");     
    TextDevice device;     
    TextThread foo("foo"), bar("bar");     
    QObject::connect(&foo, SIGNAL(writeText(TextAndNumber&)), &device, SLOT(write(TextAndNumber&)));     
    QObject::connect(&bar, SIGNAL(writeText(TextAndNumber&)), &device, SLOT(write(TextAndNumber&)));     
    device.start();     
    foo.start();     
    bar.start();     
    QMessageBox::information(0, "Threading", "Click me to close");     
    foo.stop();     
    bar.stop();     
    device.stop();     
    foo.wait();     
    bar.wait();     
    device.wait();     
    qDebug() << "Application end.";     
    return 0;     
}



金士顿
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
QT实现子线程调用主线程方法与变量（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-23 599
QT实现子线程调用主线程方法与变量（附完整源码）
Qt线程间共享数据
wu_wentao的博客
11-29 5694
Qt线程间共享数据1. 数据共享注意点像 QString 等这些 Qt 本身定义的类型，直接传送即可。但如果自定义的类型想使用 signal/slot 来传递的话，则不能直接使用。 typedef unsigned short u16;以 u16 为例： 步骤： - 在类型定义完之后，加入声明Q_DECLARE_METATYPE(U16) 在使用函数中注册这种类型： qRegisterMeta
QT实现多线程，以及子线程调用主线程方法与变量
胡乱学点东西
05-09 7715
实现思路：第一步需要将子线程声明为主线程的友元类，第二步是将主线程类对象的地址通过信号槽传递给子线程中创建的对象，使得子线程能访问主线程的数据的
QT新开线程中需要使用主线程的变量
平凡的人，平凡的路，平凡的人生
04-10 1477
线程创建 线程文件的创建与使用 添加一个资源，选中项目右击鼠标，选择Add New，选择C++，再选择第一项，点击下一步，填写class name (mSocketThread) ,base name选择QWidget，点击下一步，点击完成，等待生成文件。 mSocketThread.h文件和mSocketThread.cpp文件都要修改继承为QThread。 在主线程Widget.h文件中添加线程头文件 #include " mSocketThread.h"，然后定义线程指针变量，SocketThread
Qt--子线程访问主线程
qq_41931610的博客
11-15 1945
原文：Qt C++ 子线程访问主线程数据和方法 - lccsuse - 博客园 报错widgets must be creat in the GUI thread，子线程是不能访问GUI对象。 主要： Widget.cpp s_thread = new SaveThread(); connect(this,SIGNAL(preper_save(Widget *)),s_thread,SLOT(getaddress(Widget *))); emit preper_save(this); s_t
ipc.rar_qt进程间通信
09-23
在软件开发中，进程间通信（IPC，Inter-Process Communication）是一项关键的技术，它使得不同进程之间能够共享数据、协调工作。QT框架为开发者提供了丰富的进程间通信机制，使得在QT应用中实现高效且可靠的IPC变得...
Qt多线程服务器
03-24
**Qt多线程服务器详解** 在软件开发中，特别是在服务器端编程中，多线程技术是一种常见的优化手段，用于提高程序的并发处理能力。Qt是一个跨平台的C++图形用户界面应用程序开发框架，它提供了丰富的多线程支持，...
QT多线程编程
03-08
- **互斥访问**：为了实现多个线程对共享数据的互斥访问，**QT** 提供了 `QMutex` 类。一个线程在访问共享数据前需要锁定 `QMutex`，其他线程则无法同时锁定，直到前一个线程解锁。 - **条件变量**：`QWaitCondition...
Qt-MultiThread-code.zip-基于Qt5.14.2的多线程实例应用
11-08
**Qt5.14.2中的多线程技术详解** 在现代软件开发中，多线程已经成为提升程序性能和响应速度的重要手段。Qt作为一个强大的跨平台应用开发框架，提供了丰富的多线程支持，使得开发者可以方便地在Qt应用程序中实现并发...
Qt多线程编程
04-26
#### 二、Qt线程类简介 **1. QThread** - `QThread`是Qt提供的基本线程类，用于创建和管理线程。用户可以通过继承`QThread`类并重写其`run()`函数来定义线程的任务。 - 示例代码： ```cpp class MyThread : ...
[Qt学习笔记]Qt线程间数据通讯及数据共享
fengyaowuhui的博客
03-20 1569
第一种方法，使用全局变量或全局函数，在其他类或线程中调用，这是各种编程语言中都通用的方法，但全局变量长时间占用内存，影响程序空间使用率，且全局变量修改影响整个程序，程序的安全性无法保证，一般尽量少用全局变量或函数，这种方法不展开介绍了。
精通高并发与多线程，却不会用ThreadLocal？
Cbuc丶的博客
11-08 440
大家好，我是小菜，一个渴望在互联网行业做到蔡不菜的小菜。可柔可刚，点赞则柔，白嫖则刚！ 死鬼~看完记得给我来个三连哦！ 本文主要介绍 ThreadLocal 的使用 如有需要，可以参考 如有帮助，不忘 点赞 ❥ 微信公众号已开启，小菜良记，没关注的同学们记得关注哦！ 之前我们有在并发系列中提到 ThreadLocal 类和基本使用方法，那我们就来看下 ThreadLocal 究竟是如何使用的！ ThreadLocal 简介 概念 ThreadLocal 类是用来提供线程内部的局部变量。这种变量在多线程
子线程与主线程共同写入读取公共变量问题
qq_46314975的博客
08-28 198
需求： 子线程永远执行，每次执行完毕沉睡60s； 主线程中有一个点击事件； 主线程的点击事件和子线程的定时任务，需要调用同一份脚本进行文件写入（写入的文件相同），并需要提取出文件中部分内容，记录到sqlite中； 因此，想到定义一个公共变量 int status来表示这份脚本数据库资源是否正在被使用，从而让点击事件与定时任务互斥执行； 但是，无论是使用互斥锁还是原子变量，在子线程修改status状态为1后，主线程的点击事件获取到的值仍然是0，这会导致资源冲突，数据库文件损坏； 又想到可以用屏障（barrie
QT多线程操作同一个变量
exiagd的博客
04-30 2448
一.在不添加互斥锁的情况下，分别在两个线程对a变量进行累加。 1.计算量不是很大的话，最终的计算结果看似是满足预期结果的。 虽然代码顺序是先执行xianCheng_1的，但最终结果的输出顺序有可能是xianCheng_1先输出，也有可能先输出xianCheng_2的结果。 2.加大计算量，最终的计算结果就出现问题了。 出现这样的问题，主要是由于两个线程都是先从内存中取数，再执行累加，累加完之后，再把结果覆写回内存中的。 二.在添加互斥锁的情况下，分别在两个线程对a变量进行累加。 加上互斥锁后，最终的计算结果
Qt中Tree Widget控件的使用
晓琴儿
10-15 2298
0x00 使用Tree Widget控件制作树形菜单(效果图如下) 0x01 代码如下 #ifndef MAINWIDGET_H #define MAINWIDGET_H #include <QWidget> QT_BEGIN_NAMESPACE namespace Ui { class MainWidget; } QT_END_NAMESPACE class MainWidget : public QWidget { Q_OBJECT public: ...
QT教程：多线程&互斥锁（互斥锁有实例）
热门推荐
Mr_zhang1911116的博客
02-25 1万+
一、主线程 每个应用程序启动后，拥有的第一个线程称为主线程。QT中创建的第一个桌面应用程序（QDialog、QMainwindow or QWidget）开始运行，那么这个桌面应用程序就是主线程，也成为GUI线程。另外，子线程即工作线程，主要负责处理GUI线程的耗时工作（耗时工作例如，开启视频、打开图片的同时，通过window串口向GUI界面传输数据），QT中所有的组件类和几个相关的类只能工作在GUI线程，不能工作在子线程。 二、子线程 QThread线程类是Qt线程中一个公共的线程类，所有的线程类都是从Q
QT子线程中使用主线程的方法
weixin_43607300的博客
02-10 1138
Qt子线程中使用主线程的方法
qt线程间的变量共享
weixin_49817146的博客
01-13 1059
简单粗暴的线程间变量共享
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中.zip
最新发布
07-31
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值