精华内容
下载资源
问答
  • Qt多线程通信

    2019-04-23 15:34:28
    1 Qt线程间共享数据主要有两种方式: 1)使用共享内存。即使用一个两个线程都能够共享的变量(如全局变量),这样两个线程都能够访问和修改该变量,从而达到共享数据的目的。 2)使用singal/slot机制,把数据从一...

    前言

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

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

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

    第一种方法在各个编程语言都普遍使用,而第二种方法是QT的特有的,本文主要介绍第二种。

     2 槽参数类型

    1) 在线程间使用信号槽进行通信时,槽参数必须使用元数据类型的参数;

    2) Qt内生的元数据类型,如int double QString等;

    3) 如果要用自定义的数据类型,需要在connect之前将其注册(qRegisterMetaType)为元数据类型。

    4) 线程间用“信号与槽”传递引用参数的话,要加const,因为const文字常量存在常量区中,生命周期与程序一样的长。这样可以避免slot调用的时候参数的运行期已过而使引用无效。

    connect(m_thread, SIGNAL(MsgSignal(const QString&)),
                  this, SLOT(OnMsgSignal(const QString&)));

    3 Q_DECLARE_METATYPE与qRegisterMetaType  

    (1)Q_DECLARE_METATYPE

    如果要使自定义类型或其他非QMetaType内置类型在QVaiant中使用,必须使用该宏。

    该类型必须有公有的 构造、析构、复制构造函数。

    (2)qRegisterMetaType 

    必须使用该函数的两种情况:

    如果非QMetaType内置类型要在Qt的属性系统中使用。

    如果非QMetaType内置类型要在queued 信号与槽中使用。

    两者的关系:

    Q_DECLARE_METATYPE展开后是一个特化后的类QMetaTypeId<TYPE>

    qRegisterMetaType将某类型注册到MetaType系统中。

    QMetaTypeId<TYPE>的类中成员包含对qRegisterMetaType的调用。

    一、传递int参数(主线程与子线程)

    testthread.h 文件

    #ifndef TESTTHREAD_H
    #define TESTTHREAD_H
    #include <QThread>
    #include "msg.h"
    
    class TestThread : public QThread
    {
       Q_OBJECT
    public:
       explicit TestThread(QObject *parent = 0);
    
    protected:
       void run();
    
    signals:
       void TestSignal(int);
    
    private:
       Msg msg;
    };
    
    #endif // TESTTHREAD_H

    testthread.cpp文件 

    #include "testthread.h"  
      
    TestThread::TestThread(QObject *parent) :  
        QThread(parent)  
    {  
    }  
      
    void TestThread::run()  
    {  
        //触发信号  
        emit TestSignal(123);  
    } 
    

    自定义的类继承了QThread类,重写run函数,然后触发TestSignal信号。

    mainwindow.h

    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    #include "testthread.h"
    
    namespace Ui {
    
       class MainWindow;
    
    }
    
    class MainWindow : public QMainWindow
    {
       Q_OBJECT
    
    public:
       explicit MainWindow(QWidget *parent = 0);
       ~MainWindow();
    
    private slots:
       void DisplayMsg(int);
    
    private:
       Ui::MainWindow *ui;
       TestThread *t;
    
    };
    
    #endif // MAINWINDOW_H

    mainwindow.cpp

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    MainWindow::MainWindow(QWidget *parent) :
       QMainWindow(parent),
       ui(new Ui::MainWindow)
    {
       ui->setupUi(this);
    
       //进行connect前必须实例化
       t = new TestThread();
    
       connect(t, SIGNAL(TestSignal(int)), this, SLOT(DisplayMsg(int)));
    
       //执行子线程
       t->start();
    }
    
    void MainWindow::DisplayMsg(int a)
    {
       ui->textBrowser->append(QString::number(a));
    }
    
    MainWindow::~MainWindow()
    {
       delete ui;
    } 

    Mainwindow里面连接信号槽,并且将收到的int参数显示在界面上。
    运行效果:

     

    2、传递自定义参数(主线程与子线程)

    对以上程序进行简单的修改,使它传递自定义消息。

    testthread.h 文件

    #ifndef TESTTHREAD_H
    #define TESTTHREAD_H
    
    #include <QThread>
    #include "msg.h"
    
    class TestThread : public QThread
    {
       Q_OBJECT
    public:
       explicit TestThread(QObject *parent = 0);
       Msg msg;
    
    protected:
       void run();
    
    signals:
       void TestSignal(Msg); //自定义消息Msg!!!
    };
    
    #endif // TESTTHREAD_H

    testthread.cpp文件 

    #include "testthread.h"
    
    TestThread::TestThread(QObject *parent) :
    QThread(parent)
    {
    
    }
    
    void TestThread::run()
    {
       msg.int_info = 999;
       msg.str_info = "Hello Main Thread!";
       //触发信号
       emit TestSignal(msg);
    }

    mainwindow.h

     

    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    
    #include "testthread.h"
    #include "msg.h"
    
    namespace Ui {
       class MainWindow;
    }
    
    class MainWindow : public QMainWindow
    {
       Q_OBJECT
    
    public:
       explicit MainWindow(QWidget *parent = 0);
       ~MainWindow();
    
    private slots:
       void DisplayMsg(Msg); //Msg!!!
    
    private:
       Ui::MainWindow *ui;
       TestThread *t;
    
    };
    
    #endif // MAINWINDOW_H

    mainwindow.cpp 

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    MainWindow::MainWindow(QWidget *parent) :
       QMainWindow(parent),
       ui(new Ui::MainWindow)
    {
       ui->setupUi(this);
    
       //进行connect前必须实例化
       t = new TestThread();
    
       //Msg!!!
       connect(t, SIGNAL(TestSignal(Msg)), this, SLOT(DisplayMsg(Msg)));
    
       //执行子线程
       t->start();
    }
    
    void MainWindow::DisplayMsg(Msg msg)
    {
       ui->textBrowser->append(QString::number(msg.int_info));
       ui->textBrowser->append(msg.str_info);
    }
    
    MainWindow::~MainWindow()
    {
       delete ui;
    }

    此时再进行编译,编译通过,但Qt Creator会有提示: 

    QObject::connect: Cannot queue arguments of type 'Msg'
    (Make sure 'Msg' is registered using qRegisterMetaType().)

    并且运行程序时会发现,信号发送了,槽函数始终不调用。

     

    如果将槽参数注册为元数据类型,即mainwindow.cpp文件改动一下:

     

    ui->setupUi(this);
    
    qRegisterMetaType<Msg>("Msg");


    此时便可正常运行:

     

     ​​​​

     

    3、传递自定义参数(子线程与子线程)

     

     

    原理同上,然后把connect函数中的第三参数this(主线程)改成要监听的另一个线程对象就好了(QT多么健壮、友好、强大)。

     

    connect(t, SIGNAL(TestSignal(Msg)), this, SLOT(DisplayMsg(Msg)));  

    前提是全部的线程都要在主线程里面实例化(new)。

    4、传递自定义结构体参数(子线程与子线程)

     

    实现子线程与GUI子线程的参数进行传递。

    线程

    头文件 ABFThread.h

    public:
    
    struct G_ABFTableSrcUnit
    {
       int a;
       int b;
       int c;
       float d;
       float e;
       unsigned int f;
       float Gg;
    
       QString waveformTypel;
    };
    
    public slots:
    
       void parameterPassing(abfThread::G_ABFTableSrcUnit); //线程自己调用自己的结构体。。。必须这么写不然主线程会报错的 错误是参数内容不一样
    
    


    ABFThread.cpp

    void abfThread::parameterPassing(abfThread::G_ABFTableSrcUnit)
    {
    
    }

    GUI线程 

    radarControl.h

    #include "abfThread"  
      
    private:  
        Ui::radarControl *ui;  
      
        abfThread::G_ABFTableSrcUnit mst_abfSrcUnit;  
      
      
    signals:  
        void sendString(abfThread::G_ABFTableSrcUnit);
    

    radarControl.cpp
    按下按钮就发射信号

    void radarControl::on_pushButton_clicked()
    {
       emit sendString(mst_abfSrcUnit);
    }

     

    mainwindow.h
    
    #include "abfThread.h"
    
    #include "radarControl.h"

    mainwindow.cpp

    radarInterface = new radarControl();
    m_ABFThread = new QThread();
    m_ABF = new abfThread();
    m_ABF->moveToThread(m_ABFThread);
    m_ABFThread->start();
    
    qRegisterMetaType<abfThread::G_ABFTableSrcUnit>("abfThread::G_ABFTableSrcUnit");
    connect(radarInterface,SIGNAL(sendString(abfThread::G_ABFTableSrcUnit)),m_ABF,SLOT(parameterPassing(abfThread::G_ABFTableSrcUnit)));
    //除了注册结构体外 还要保证传递的参数写法要一样 这就是为什么 前面线程自己定义的结构体自己调用自己的原因了

     

    小结:

     

    1 > Qt的信号槽函数只默认支持Qt的类型和C++提供的内建的基本类型,比如int double float等,根本不支持C++的std::string std::vector 自定义的struct类型。所以需要用Qt提供的Q_DECLARE_METATYPE和qRegisterMetaType来声明和注册自定义的类型和C++的其他类型。
    2 > 多线程间的信号槽传递,在connect的时候需要以Qt::QueuedConnection的方式,不然以Qt::DirectConnection的方式接收者UI线程会很长时间收不到后台线程发出的信号,或者信号直接丢失都是有可能的

    展开全文
  • qt 多线程通信

    2014-10-24 15:24:29
    qt 多线程通信,UI中有2个按钮,一个启动,线程去读数据,返回信号,UI显示数据,另一个停止,停止当前的线程,请问如何停止当前正在运行的线程,求大神;mainwindos new 出来server, server中new出thread, thread发...
  • Qt多线程通信样例

    热门讨论 2013-01-20 14:08:02
    本工程是做的一个Demo,演示了在一个Qt程序下,开启两个线程,这两个线程和主UI线程通过信号机制,实现线程之间的通迅。 给大家解答了Qt线程中如何使用信号槽的问题。 本工程在vs2010 + Qt 4.8.4下已经测试通过...
  • Qt线程间共享数据主要有两种方式: 1)使用共享内存。即使用一个两个线程都能够共享的变量(如全局变量),这样两个线程都能够访问和修改该变量,从而达到共享数据的目的。 2)使用singal/slot机制,把数据从一个...
  • Qt多线程通信条件变量

    千次阅读 2018-04-27 14:17:03
    #ifndef TESTTHREAD_H #define TESTTHREAD_H #include &lt;QThread&gt; #include &lt;QWaitCondition&gt; #include &lt;QMutex&gt; class TestThread : public QThread ... explicit Test...
    #ifndef TESTTHREAD_H
    #define TESTTHREAD_H
    
    #include <QThread>
    #include <QWaitCondition>
    #include <QMutex>
    
    class TestThread : public QThread
    {
        Q_OBJECT
    
    public:
        explicit TestThread(QObject *parent = 0);
    
    private:
        void run();
    
    private:
        QWaitCondition continueTestingCond;
        QMutex testLock;
        bool continueTesting;
    
    signals:
        void isContinuTesting(QMutex *testLock, QWaitCondition *waitCTN);
    
    public:
        void continuTest(bool go);
    };
    
    #endif // TESTTHREAD_H
    
    #include <QDebug>
    #include "testthread.h"
    
    TestThread::TestThread(QObject *parent):QThread(parent)
    {
        continueTesting = false;
    }
    
    void TestThread::run()
    {
        testLock.lock();
    
        emit isContinuTesting(&testLock, &continueTestingCond);
    
        continueTestingCond.wait(&testLock);
    
        testLock.unlock();
    
        if(continueTesting)
        {
            qDebug() << "contine";
        }
        else
        {
            qDebug()  << "break";
        }
    }
    
    void TestThread::continuTest(bool go)
    {
        continueTesting = go;
    }
    

    #ifndef WIDGET_H
    #define WIDGET_H
    
    #include <QWidget>
    #include "testthread.h"
    
    namespace Ui {
    class Widget;
    }
    
    class Widget : public QWidget
    {
        Q_OBJECT
    
    public:
        explicit Widget(QWidget *parent = 0);
        ~Widget();
    
    private:
        Ui::Widget *ui;
    
    private:
        TestThread *testThread;
    
    private slots:
        void processTestState(QMutex *testLock, QWaitCondition *waitCTN);
        void on_pushButton_released();
    };
    
    #endif // WIDGET_H
    

    #include "widget.h"
    #include "ui_widget.h"
    #include "dialog.h"
    
    Widget::Widget(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::Widget)
    {
        ui->setupUi(this);
    
        testThread = new TestThread(this);
        connect(testThread, SIGNAL(isContinuTesting(QMutex*,QWaitCondition *)),
                this,SLOT(processTestState(QMutex*,QWaitCondition *)));
    }
    
    Widget::~Widget()
    {
        delete ui;
    }
    
    void Widget::processTestState(QMutex *testLock, QWaitCondition *waitCTN)
    {
        testLock->lock();
    
        Dialog dialog;
        if(dialog.exec() == QDialog::Accepted)
        {
           testThread->continuTest(true);
        }
        else
        {
            testThread->continuTest(false);
        }
    
        testLock->unlock();
    
    
        testLock->lock();
    
        waitCTN->wakeOne();
    
        testLock->unlock();
    }
    
    void Widget::on_pushButton_released()
    {
        testThread->start();
    }
    


    展开全文
  • Qt多线程通信 (附demo)

    千次阅读 2019-03-15 14:45:45
    Qt线程间共享数据主要有两种方式: 1)使用共享内存。即使用一个两个线程都能够共享的变量(如全局变量),这样两个线程都能够访问和修改该变量,从而达到共享数据的目的。 2)使用singal/slot机制,把数据从...

    本人复数代码源码下载地址:https://download.csdn.net/download/flowerspring/11022121

    简述:

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

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

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

    第一种方法在各个编程语言都普遍使用,而第二种方法是QT的特有的,本文主要介绍第二种。

    2 > 槽参数类型

    1) 在线程间使用信号槽进行通信时,槽参数必须使用元数据类型的参数;

    2) Qt内生的元数据类型,如int double QString等;

    3) 如果要用自定义的数据类型,需要在connect之前将其注册(qRegisterMetaType)为元数据类型。

    4) 线程间用“信号与槽”传递引用参数的话,要加const,因为const文字常量存在常量区中,生命周期与程序一样的长。这样可以避免slot调用的时候参数的运行期已过而使引用无效。

    connect(m_thread, SIGNAL(MsgSignal(const QString&)),
                  this, SLOT(OnMsgSignal(const QString&)));

    3 > Q_DECLARE_METATYPE与qRegisterMetaType 
    Q_DECLARE_METATYPE

    如果要使自定义类型或其他非QMetaType内置类型在QVaiant中使用,必须使用该宏。

    该类型必须有公有的 构造、析构、复制构造函数。

    qRegisterMetaType 

    必须使用该函数的两种情况:

    如果非QMetaType内置类型要在Qt的属性系统中使用。

    如果非QMetaType内置类型要在queued 信号与槽中使用。

    两者的关系:

    Q_DECLARE_METATYPE展开后是一个特化后的类QMetaTypeId<TYPE>

    qRegisterMetaType将某类型注册到MetaType系统中。

    QMetaTypeId<TYPE>的类中成员包含对qRegisterMetaType的调用。

    1、传递int参数(主线程与子线程)

     

    testthread.h 文件

     

     
    1. #ifndef TESTTHREAD_H

    2. #define TESTTHREAD_H

    3.  
    4. #include <QThread>

    5.  
    6. #include "msg.h"

    7.  
    8. class TestThread : public QThread

    9. {

    10. Q_OBJECT

    11. public:

    12. explicit TestThread(QObject *parent = 0);

    13.  
    14. protected:

    15. void run();

    16.  
    17. signals:

    18. void TestSignal(int);

    19.  
    20. private:

    21. Msg msg;

    22. };

    23.  
    24. #endif // TESTTHREAD_H

     

    testthread.cpp文件

     

     
    1. #include "testthread.h"

    2.  
    3. TestThread::TestThread(QObject *parent) :

    4. QThread(parent)

    5. {

    6. }

    7.  
    8. void TestThread::run()

    9. {

    10. //触发信号

    11. emit TestSignal(123);

    12. }


    自定义的类继承了QThread类,重写run函数,然后触发TestSignal信号。

    mainwindow.h

     
    1. #ifndef MAINWINDOW_H

    2. #define MAINWINDOW_H

    3.  
    4. #include <QMainWindow>

    5.  
    6. #include "testthread.h"

    7.  
    8. namespace Ui {

    9. class MainWindow;

    10. }

    11.  
    12. class MainWindow : public QMainWindow

    13. {

    14. Q_OBJECT

    15.  
    16. public:

    17. explicit MainWindow(QWidget *parent = 0);

    18. ~MainWindow();

    19.  
    20. private slots:

    21. void DisplayMsg(int);

    22.  
    23. private:

    24. Ui::MainWindow *ui;

    25. TestThread *t;

    26. };

    27.  
    28. #endif // MAINWINDOW_H

     

    mainwindow.cpp

     

     
    1. #include "mainwindow.h"

    2. #include "ui_mainwindow.h"

    3.  
    4. MainWindow::MainWindow(QWidget *parent) :

    5. QMainWindow(parent),

    6. ui(new Ui::MainWindow)

    7. {

    8. ui->setupUi(this);

    9.  
    10. //进行connect前必须实例化

    11. t = new TestThread();

    12.  
    13. connect(t, SIGNAL(TestSignal(int)), this, SLOT(DisplayMsg(int)));

    14.  
    15. //执行子线程

    16. t->start();

    17. }

    18.  
    19. void MainWindow::DisplayMsg(int a)

    20. {

    21. ui->textBrowser->append(QString::number(a));

    22. }

    23.  
    24. MainWindow::~MainWindow()

    25. {

    26. delete ui;

    27. }


    Mainwindow里面连接信号槽,并且将收到的int参数显示在 界面上。
    运行效果:

     

     

    2、传递自定义参数(主线程与子线程)

     

    对以上程序进行简单的修改,使它传递自定义消息。

    testthread.h 文件

     

     
    1. #ifndef TESTTHREAD_H

    2. #define TESTTHREAD_H

    3.  
    4. #include <QThread>

    5.  
    6. #include "msg.h"

    7.  
    8. class TestThread : public QThread

    9. {

    10. Q_OBJECT

    11. public:

    12. explicit TestThread(QObject *parent = 0);

    13. Msg msg;

    14.  
    15. protected:

    16. void run();

    17.  
    18. signals:

    19. void TestSignal(Msg); //自定义消息Msg!!!

    20. };

    21.  
    22. #endif // TESTTHREAD_H


    testthread.cpp文件

     

     
    1. #include "testthread.h"

    2.  
    3. TestThread::TestThread(QObject *parent) :

    4. QThread(parent)

    5. {

    6. }

    7.  
    8. void TestThread::run()

    9. {

    10. msg.int_info = 999;

    11. msg.str_info = "Hello Main Thread!";

    12. //触发信号

    13. emit TestSignal(msg);

    14. }


    mainwindow.h

     

     
    1. #ifndef MAINWINDOW_H

    2. #define MAINWINDOW_H

    3.  
    4. #include <QMainWindow>

    5.  
    6. #include "testthread.h"

    7. #include "msg.h"

    8.  
    9. namespace Ui {

    10. class MainWindow;

    11. }

    12.  
    13. class MainWindow : public QMainWindow

    14. {

    15. Q_OBJECT

    16.  
    17. public:

    18. explicit MainWindow(QWidget *parent = 0);

    19. ~MainWindow();

    20.  
    21. private slots:

    22. void DisplayMsg(Msg); //Msg!!!

    23.  
    24. private:

    25. Ui::MainWindow *ui;

    26. TestThread *t;

    27. };

    28.  
    29. #endif // MAINWINDOW_H

     

    mainwindow.cpp

     

     
    1. #include "mainwindow.h"

    2. #include "ui_mainwindow.h"

    3.  
    4. MainWindow::MainWindow(QWidget *parent) :

    5. QMainWindow(parent),

    6. ui(new Ui::MainWindow)

    7. {

    8. ui->setupUi(this);

    9.  
    10. //进行connect前必须实例化

    11. t = new TestThread();

    12.  
    13. //Msg!!!

    14. connect(t, SIGNAL(TestSignal(Msg)), this, SLOT(DisplayMsg(Msg)));

    15.  
    16. //执行子线程

    17. t->start();

    18. }

    19.  
    20. void MainWindow::DisplayMsg(Msg msg)

    21. {

    22. ui->textBrowser->append(QString::number(msg.int_info));

    23. ui->textBrowser->append(msg.str_info);

    24. }

    25.  
    26. MainWindow::~MainWindow()

    27. {

    28. delete ui;

    29. }


    此时再进行编译,编译通过,但Qt Creator会有提示:

     

     

     
    1. QObject::connect: Cannot queue arguments of type 'Msg'

    2. (Make sure 'Msg' is registered using qRegisterMetaType().)


    并且运行程序时会发现,信号发送了,槽函数始终不调用。

     

    如果将槽参数注册为元数据类型,即mainwindow.cpp文件改动一下:

     

     
    1. ui->setupUi(this);

    2.  
    3. qRegisterMetaType<Msg>("Msg");


    此时便可正常运行:

     

     

     

    3、传递自定义参数(子线程与子线程)

     

     

    原理同上,然后把connect函数中的第三参数this(主线程)改成要监听的另一个线程对象就好了(QT多么健壮、友好、强大)。

     

    connect(t, SIGNAL(TestSignal(Msg)), this, SLOT(DisplayMsg(Msg)));  

    前提是全部的线程都要在主线程里面实例化(new)。

     

     

    4、传递自定义结构体参数(子线程与子线程)

     

    实现子线程与GUI子线程的参数进行传递。

    线程

    头文件 ABFThread.h

     

     
    1. public:

    2.  
    3. struct G_ABFTableSrcUnit

    4. {

    5. int a;

    6. int b;

    7. int c;

    8. float d;

    9. float e;

    10. unsigned int f;

    11. float Gg;

    12.  
    13. QString waveformTypel;

    14. };

    15.  
    16. public slots:

    17.  
    18. void parameterPassing(abfThread::G_ABFTableSrcUnit); //线程自己调用自己的结构体。。。必须这么写不然主线程会报错的 错误是参数内容不一样


    ABFThread.cpp

     

     

     
    1. void abfThread::parameterPassing(abfThread::G_ABFTableSrcUnit)

    2. {

    3.  
    4. }


    GUI线程 

    radarControl.h

     

     
    1. #include "abfThread"

    2.  
    3. private:

    4. Ui::radarControl *ui;

    5.  
    6. abfThread::G_ABFTableSrcUnit mst_abfSrcUnit;

    7.  
    8.  
    9. signals:

    10. void sendString(abfThread::G_ABFTableSrcUnit);

    radarControl.cpp
    按下按钮就发射信号

     

     
    1. void radarControl::on_pushButton_clicked()

    2. {

    3. emit sendString(mst_abfSrcUnit);

    4. }

    mainwindow.h
     
    1. #include "abfThread.h"

    2. #include "radarControl.h"

    mainwindow.cpp
     
    1. radarInterface = new radarControl();

    2. m_ABFThread = new QThread();

    3. m_ABF = new abfThread();

    4. m_ABF->moveToThread(m_ABFThread);

    5. m_ABFThread->start();

    6.  
    7. qRegisterMetaType<abfThread::G_ABFTableSrcUnit>("abfThread::G_ABFTableSrcUnit");

    8. connect(radarInterface,SIGNAL(sendString(abfThread::G_ABFTableSrcUnit)),m_ABF,SLOT(parameterPassing(abfThread::G_ABFTableSrcUnit)));

    9. //除了注册结构体外 还要保证传递的参数写法要一样 这就是为什么 前面线程自己定义的结构体自己调用自己的原因了

     

     

    小结:

     

    1 > Qt的信号槽函数只默认支持Qt的类型和C++提供的内建的基本类型,比如int double float等,根本不支持C++的std::string std::vector 自定义的struct类型。所以需要用Qt提供的Q_DECLARE_METATYPE和qRegisterMetaType来声明和注册自定义的类型和C++的其他类型。
    2 > 多线程间的信号槽传递,在connect的时候需要以Qt::QueuedConnection的方式,不然以Qt::DirectConnection的方式接收者UI线程会很长时间收不到后台线程发出的信号,或者信号直接丢失都是有可能的

    展开全文
  • Qt多线程串口通信源码

    热门讨论 2010-08-14 00:18:47
    采用Qt4.6.2编写的linux系统下的开源串口通信程序。使用开源的posix_qextserialport类
  • qt多线程通信

    2015-09-11 15:21:00
    //Qt多线程同步 QMutex g_mutex; QWaitCondition g_waitobj;//回调函数 int __cdecl CMediaServerCallBack::requestAuthorizeCallback(const char* a_device_uuid, AuthorizedCode* a_auth_code, void* a_c...
    //Qt多线程同步
    QMutex g_mutex;
    QWaitCondition g_waitobj;

    //回调函数
    int __cdecl CMediaServerCallBack::requestAuthorizeCallback(const char* a_device_uuid
    , AuthorizedCode* a_auth_code, void* a_context)
    {
    //由于需要界面来作相应操作(主线程),所以只能用信号槽来处理
    emit MS_CALLBACK->signalRequestAuthor(a_device_uuid, a_auth_code);

    //由于需要等待界面的处理结果,所以需要阻塞该线程
    //之前直接用while来做死循环

    QMutexLocker mutexLocker(&g_mutex);
    g_waitobj.wait(&g_mutex);

    return 0;
    }


    //槽函数,响应回调函数中的 MS_CALLBACK->signalRequestAuthor(a_device_uuid, a_auth_code)

    void CGUIMediaCenter::onRequestAuthor(const char* a_device_uuid
    , AuthorizedCode* a_auth_code)
    {
    //修改 a_auth_code, 修改完成后,唤醒之前阻塞的线程
    QMutexLocker mutexLocker(&g_mutex);
    g_waitobj.wakeOne();
    }

    转载于:https://www.cnblogs.com/jiushishuai/p/9452127.html

    展开全文
  • 最近接了一个单子,QT写的多线程Socket服务器+多客户端,虽然用qt做socket服务器不太合适,但是毕竟客户要求就做了,本以为很简单,后来才发现QT的QTcpServer真的不太好用,参考了好多网上的教程才弄明白,顺便记录...
  • Qt多线程源码

    2018-04-16 16:31:37
    Qt多线程
  • bool QTcpServer::isListening() const //判断当前对象是否在监听,是返回true,否返回false
  • QT C++ 多线程支持多串口通信,实现了串口的基本功能,和多线程框架,C++编写,全部工程文件已压缩
  • Qt 多线程同步与通信

    2017-11-11 20:24:00
    Qt 多线程同步与通信 1 多线程同步 Qt提供了以下几个类来完成这一点:QMutex、QMutexLocker、QSemphore、QWaitCondition。 当然可能还包含QReadWriteLocker、QReadLocker、QWriteLocker,但线程同步是应用很少...
  • 【转】Qt 多线程串口通信问题?

    千次阅读 2019-03-19 10:41:19
    现在我的项目关于线程和串口通信这里出了很问题。思路现在就是我首先自己封装了QSerialport的open、read、write函数,然后在通信层中开了 一个线程,在这个线程的构造函数中new了我封的serialport,并且就在这里...
  • QT多线程编程详解

    万次阅读 多人点赞 2019-04-24 22:08:20
    一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程,即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程,不能工作在次...二、QT多线程简介 QT通过三种形式提供了对线程...
  • Qt多线程同步与通信

    2018-12-03 14:31:09
    1 多线程同步 Qt提供了以下几个类来完成这一点:QMutex、QMutexLocker、QSemphore、QWaitCondition。 当然可能还包含QReadWriteLocker、QReadLocker、QWriteLocker,但线程同步是应用很少,这里只做简单的讲解! ...
  • qt多线程socket通信

    2013-12-16 16:56:42
    我在一个类中新建了一个线程,在线程的run函数中如何对创建线程的这个类的UI组件进行操作。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,835
精华内容 3,934
关键字:

qt多线程通信