信号与槽的连接方式

最新推荐文章于 2024-08-31 14:36:12 发布

洋葱汪

最新推荐文章于 2024-08-31 14:36:12 发布

阅读量1w

点赞数 20

分类专栏： QT【笔记】

课程笔记内容整理于狄泰软件

本文链接：https://blog.csdn.net/qq_39654127/article/details/81988281

版权

QT【笔记】专栏收录该内容

23 篇文章 23 订阅

订阅专栏

信号与槽的连接方式

－Qt:: DirectConnection (立即调用）

－Qt::QueuedConnection (异步调用）

－Qt::BlockingQueuedConnection (同步调用）

－Qt: :AutoConnection (默认连接）

－Qt:: UniqueConnection (单一连接）

QObject::connect(const QObject *sender, 
                 const char *signal, 
                 const QObject *receiver, 
                 const char *method, 
                 Qt::ConnectionType type = Qt::AutoConnection)

// 信号与槽的连接方式决定槽函数调用时候的相关行为！

每一个线程都有自己的事件队列，线程通过事件队列接收信号，信号在事件循环中被处理

Qt:: DirectConnection (立即调用）

－直接在发送信号的线程中调用槽函数，等价于槽函数的实时调用！

Qt:: QueuedConnection (异步调用）

－信号发送至目标线程的事件队列，由目标线程处理；当前线程继续向下执行！

Qt:: BlockingQueuedConnection (同步调用）

－信号发送至目标线程的事件队列，由目标线程处理；当前线程等待槽函数返回，之后继续向下执行！

Qt::AutoConnection (默认连接）

Qt::UniqueConnection (单一连接）

－描述

• 功能与AutoConnection相同，自动确定连接类型

• 同一个信号与同一个槽函数之间只有一个连接（默认情况下，同一个信号可以多次连接到同一个槽函数，多次连接意味着同一个槽函数的多次调用）

MyObject.h

#ifndef MYOBJECT_H
#define MYOBJECT_H

#include <QObject>

class MyObject : public QObject
{
    Q_OBJECT
public:
    explicit MyObject(QObject *parent = 0);
    
signals:
    
protected slots:
    void testSlot();
};

#endif // MYOBJECT_H

MyObject.cpp

#include "MyObject.h"
#include <QThread>
#include <QDebug>

MyObject::MyObject(QObject *parent) :
    QObject(parent)
{
}

void MyObject::testSlot()
{
    qDebug() << "void MyObject::testSlot() tid = " << QThread::currentThreadId();
}

TestThread.h

#ifndef TESTTHREAD_H
#define TESTTHREAD_H

#include <QThread>

class TestThread : public QThread
{
    Q_OBJECT

protected:
    void run();
public:
    explicit TestThread(QObject *parent = 0);
    
signals:
    void testSignal();

};

#endif // TESTTHREAD_H

TestThread.cpp

#include "TestThread.h"
#include <QDebug>

TestThread::TestThread(QObject *parent) :
    QThread(parent)
{

}

void TestThread::run()
{
    qDebug() << "void TestThread::run() -- begin tid = " << currentThreadId();

    for(int i=0; i<3; i++)
    {
        qDebug() << "void TestThread::run() i = " << i;

        sleep(1);
    }

    emit testSignal();

    exec();

    qDebug() << "void TestThread::run() -- end";
}

main.cpp

#include <QtCore/QCoreApplication>
#include <QDebug>
#include <QThread>
#include "TestThread.h"
#include "MyObject.h"

void direct_connection()
{
    static TestThread t;  // 依附于主线程
    static MyObject m;    // 依附于主线程

    QObject::connect(&t, SIGNAL(testSignal()), &m, SLOT(testSlot()), Qt::DirectConnection);

    t.start();           

    t.wait(5 * 1000);

    t.quit();
}

void queued_connection()
{
    static TestThread t; // 依附于主线程，发送的信号进入主线程事件队列
    static MyObject m;   // 依附于主线程，槽函数在主线程中调用

    QObject::connect(&t, SIGNAL(testSignal()), &m, SLOT(testSlot()), Qt::QueuedConnection);

    t.start();

    t.wait(5 * 1000);

    t.quit();
}

void blocking_queued_connection()
{
    static TestThread t;
    static MyObject m;

    QObject::connect(&t, SIGNAL(testSignal()), &m, SLOT(testSlot()), Qt::BlockingQueuedConnection);

    t.start();

    t.wait(5 * 1000);

    t.quit();
}

void auto_connection()
{
    static TestThread t;
    static MyObject m;

    QObject::connect(&t, SIGNAL(testSignal()), &m, SLOT(testSlot()));

    t.start();

    t.wait(5 * 1000);

    t.quit();
}

void unique_connection()
{
    static TestThread t;
    static MyObject m;

    QObject::connect(&t, SIGNAL(testSignal()), &m, SLOT(testSlot()), Qt::UniqueConnection);
    QObject::connect(&t, SIGNAL(testSignal()), &m, SLOT(testSlot()), Qt::UniqueConnection);

    t.start();

    t.wait(5 * 1000);

    t.quit();
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    qDebug() << "main() tid = " << QThread::currentThreadId();

    // direct_connection();
    // queued_connection();
    // blocking_queued_connection();
    // auto_connection();
    // unique_connection();

    return a.exec();
}

当调用direct_connection();