Qt QThread与QObject的关系

Posted 一杯清酒邀明月

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Qt QThread与QObject的关系相关的知识,希望对你有一定的参考价值。

Threads and QObjects

QThread 继承 QObject.。它可以发送started和finished信号,也提供了一些slot函数。

QObject.可以用于多线程,可以发送信号调用存在于其他线程的slot函数,也可以postevent给其他线程中的对象。之所以可以这样做,是因为每个线程都有自己的事件循环。

在进行下面的讲解之前,应该了解的重要的一点是:QThread 对象所在的线程,和QThread 创建的线程,也就是run()函数执行的线程不是同一个线程。QThread 对象所在的线程,就是创建对象的线程。我们通过一个例子说明更能清楚一点:

 1 MyThread::MyThread(QObject *parent /* = NULL */):QThread(parent)
 2 
 3 {
 4        qDebug()<<"MyThreadobject currentThreadId :"<<QThread::currentThreadId();
 5 
 6 }
 7 
 8  
 9 
10 void MyThread::run()
11 
12 {
13        qDebug()<<"run()  currentThreadId : "<<QThread::currentThreadId();
14 
15 }
16 
17  
18 
19 int main(int argc, char *argv[])
20 
21 {
22        QApplication a(argc, argv);
23 
24        MyThread thread;
25 
26        qDebug()<<"mainThread : "<<QThread::currentThreadId();
27 
28        thread.start();
29 
30        returna.exec();
31 
32 }

输出结果:MyThread所在的线程就是主线程,run()函数是新开的线程。

QObject Reentrancy
QObject.是可重入的,它的大多数非GUI子类,例如QTimer, QTcpSocket, QUdpSocket and QProcess都是可重入的,使得这些类可以同时用于多线程。需要注意的是,这些类设计为从一个单一的线程创建和使用的,在一个线程创建对象,而从另外一个线程调用对象的函数并不能保证行得通。有三个限制需要注意:

1.    QObject的子对象必须在创建其parent的线程中创建。这意味着,你不能把QThread对象作为parent传递给创建在线程中的对象,因为QThread 对象本身在另外一个线程中创建。

2.    事件驱动对象只能用于单线程。尤其是在定时器机制和网络模块。例如,你不能在不是对象所处的线程start一个计时器或者链接一个secket。简单的说就是,你不能在线程A创建了一个计时器timer,然后在线程B从启动timer。

我们可以验证一下:

 1 class MyThread : publicQThread
 2 
 3 {
 4        Q_OBJECT
 5 
 6 public:
 7 
 8        MyThread(QObject *parent = NULL);
 9 
10        ~MyThread();
11 
12  
13 
14 public slots:
15 
16        voidtimeOutSlot();
17 
18 protected:
19 
20        voidrun();
21 
22        QTimer *m_pTimer;
23 
24  
25 
26 };
27 
28  
29 
30 MyThread::MyThread(QObject*parent /* = NULL */):QThread(parent)
31 
32 {
33        m_pTimer = newQTimer(this);
34 
35        qDebug()<<"MyThreadobject currentThreadId :"<<QThread::currentThreadId();
36 
37        connect(m_pTimer,SIGNAL(timeout()),this,SLOT(timeOutSlot()));
38 
39 }
40 
41  
42 
43 void MyThread::timeOutSlot()
44 
45 {
46        qDebug()<<"timer  timeout ";
47 
48 }
49 
50  
51 
52 MyThread::~MyThread()
53 
54 {
55  
56 
57 }
58 
59  
60 
61 void MyThread::run()
62 
63 {
64        m_pTimer->start(500);
65 
66        qDebug()<<"run()  currentThreadId : "<<QThread::currentThreadId();
67 
68        qDebug( "finish!");
69 
70 }
71 
72  
73 
74  
75 
76  
77 
78  intmain(int argc, char*argv[])
79 
80 {
81        QApplication a(argc, argv);
82 
83        MyThread thread;
84 
85        qDebug()<<"mainThread : "<<QThread::currentThreadId();
86 
87        thread.start();
88 
89        returna.exec();
90 
91 }

Timeout函数并没有被调用。我们还发现有多了一行输出:QObject::startTimer: timers cannot be startedfrom another thread

跟踪timer的start源码,我们发现:

 1 void QEventDispatcherWin32::registerTimer(int timerId, intinterval, QObject *object)
 2 
 3 {
 4     if (timerId< 1 || interval < 0 || !object) {
 5         qWarning("QEventDispatcherWin32::registerTimer:invalid arguments");
 6 
 7         return;
 8 
 9 }
10 
11  else if(object->thread() != thread() || thread() != QThread::currentThread())
12 
13 {
14 //判断object的thread,也就是object所在的thread,不等于当前的线程就返回了
15 
16         qWarning("QObject::startTimer:timers cannot be started from another thread");
17 
18         return;
19 
20     }
21 
22  
23 
24   。。。。。
25 
26  
27 
28 }

3.    你必须保证在线程中创建的对象要在线程销毁前delete。这很容易做到,只要是在run()函数栈里创建的对象就行。

尽管 QObject 是可重入的,但是GUI类,特别是QWidget 和它的子类都是不可重入的。它们只能在主线程中用。就如前面提到的, QCoreApplication::exec()必须从主线程进行调用。

Per-Thread Event Loop
每个线程都有自己的事件循环。起始的线程用QCoreApplication::exec()开启事件循环。其他的线程用QThread::exec()开始事件循环。与 QCoreApplication一样, QThread也提供了 exit(int) 函数 和 quit() 槽函数。

线程里的事件循环,使得可以在线程里使用需要事件循环的非GUI类,例如(QTimer, QTcpSocket, and QProcess).。也可以把任意的线程的信号连接到特定线程的槽。

QObject实例存在于创建实例的线程中,发送给实例事件也是有线程的事件循环实现的。可以用 QObject::thread().获取对象存活于哪个线程。

 1 MyThread::MyThread(QObject*parent /* = NULL */):QThread(parent)
 2 
 3 {
 4        m_pTimer = newQTimer(this);
 5 
 6        qDebug()<<"MyThreadobject currentThreadId :"<<QThread::currentThread();
 7 
 8        QObject obj1;
 9 
10        obj1.thread();
11 
12        qDebug()<<"obj1live in the thread  :"<<obj1.thread();
13 
14        connect(m_pTimer,SIGNAL(timeout()),this,SLOT(timeOutSlot()));
15 
16        //QThread::start();
17 
18 }
19 
20  
21 
22  
23 
24 void MyThread::run()
25 
26 {
27        QObject obj2;
28 
29        obj2.thread();
30 
31        qDebug()<<"button2live in the thread  :"<<obj2.thread();
32 
33        //m_pTimer->start(500);
34 
35        qDebug()<<"run()  currentThreadId : "<<QThread::currentThread();
36 
37        qDebug( "finish!");
38 
39 }

这个再一次说明了,对象所处的线程就是创建它的线程。

注意:对于那些在QApplication之前创建的对象,QObject::thread() 返回0。这意味着,主线程只处理发送给那些对象的事件,那些没有thread的对象是不做任何的事件处理的。使用QObject::moveToThread()函数可以改变对象及其子对象的线程关联度,说白了就是把对象从当前的线程移到另外的线程里。但是如果一个对象已经有了parent,那是不能move了。

调用delete删除处于另外一个线程的QObject对象是不安全的。除非你能保证对象当前不是在进行事件处理。应该用QObject::deleteLater()替代,并且将发出一个DeferredDelete事件,这个事件会最终会被对象的线程的时间循环所捕获。

如果没有时间循环,就不会有事件传递给对象。例如,如果你在一个线程中创建了一个QTimer对象,但是不调用exec(),,那么QTimer永远不会发出timeout()信号,调用eleteLater() 也不起作用。

 1 void MyThread::run()
 2 
 3 {
 4        m_pTimer = newQTimer();
 5 
 6        m_pTimer->start(500);
 7 
 8       
 9 
10        connect(m_pTimer,SIGNAL(timeout()),this,SLOT(timeOutSlot()));
11 
12        qDebug()<<"run()  currentThreadId : "<<QThread::currentThread();
13 
14        this->exec();
15 
16        //qDebug("finish!" );
17 
18 }
19 
20 void MyThread::timeOutSlot()
21 
22 {
23        qDebug()<<"timer  timeout ";
24 
25        //m_pTimer->stop();
26 
27 }

这时候是可以调用timeOutSlot()的。

 1 void MyThread::run()
 2 
 3 {
 4        m_pTimer = newQTimer();
 5 
 6        m_pTimer->start(500);
 7 
 8       
 9 
10        connect(m_pTimer,SIGNAL(timeout()),this,SLOT(timeOutSlot()));
11 
12        qDebug()<<"run()  currentThreadId : "<<QThread::currentThread();
13 
14        //this->exec();
15 
16        //qDebug("finish!" );
17 
18 }

如果注释//this->exec();,timeOutSlot()将不会被调用。

还有一点要注意的:QTimer对象也不能在另外的线程stop的。如果把timeOutSlot里的m_pTimer->stop();取消注释。会看到一行输出:QObject::killTimer: timers cannot be stopped fromanother thread

源码中:

 1 bool QEventDispatcherWin32::unregisterTimer(int timerId)
 2 
 3 {
 4     if (timerId< 1) {
 5         qWarning("QEventDispatcherWin32::unregisterTimer:invalid argument");
 6 
 7         return false;
 8 
 9     }
10 
11 QThread *currentThread = QThread::currentThread();
12 
13 //判断timer所处的线程与当前的线程是否一致。
14 
15 if(thread() != currentThread)
16 
17  {
18         qWarning("QObject::killTimer:timers cannot be stopped from another thread");
19 
20         return false;
21 
22     }
23 
24  
25 
26   。。。。
27 
28 }

你可以用QCoreApplication::postEvent()函数在任意时间给任意线程中的任意对象发送事件。事件自动被创建object的线程的事件循环分发。所以的线程都支持事件过滤器,唯一的限制就是,监视对象必须与被监视对象处于同一个线程。同样的,QCoreApplication::sendEvent() 只能用来给与调用QCoreApplication::sendEvent() 函数处于同一个线程的对象发送事件。说白了就是,QCoreApplication::sendEvent() 不能给处于另外线程的对象发送事件。

Accessing QObjectSubclasses from Other Threads
QObject 和它所有的子类都不是线程安全的。这包含了整个事件发送系统,需要记住的很重要的一点是:事件循环可能正在给一个对象发送一个事件,同时你可能从别的线程访问该对象。

如果你调用了一个不是出于当前线程QObject 子类对象的一个函数,而此时对象可能接收一个事件,你必须用一个mutex保护对象的内在的数据。否则,可能引起程序崩溃或者未定义的行为。

与其他的对象一样,QThread对象存活于创建对象的线程中,而不是存在于QThread::run() 线程。这点在前面讲到了。在自定义 QThread子类中提供slot函数是不安全的,除非你用一个mutex保护了成员变量。然而,你可以在实现的 QThread::run() 里发出信号,因为信号发送是线程安全的。

Signals and Slots AcrossThreads
Qt支持了几种信号--槽的连接方式:

1.     Auto Connection (默认):如果如果信号的发送方与接收方是处于同一个线程,这个连接就是 Direct Connection,否则就跟 Queued Connection一样。

2.    Direct Connection :当信号发出之后,槽会立即被调用。槽函数是在信号发送方的线程中运行的,不需要接收方的线程。

3.    Queued Connection:当控制权回到接收方线程时调用槽函数。槽函数是在接收方的线程中运行的。

4.    Blocking Queued Connection :调用方式跟 Queued Connection一样,区别在于,当前线程会被阻塞直到槽函数返回。

5.    Unique Connection :这种方式跟 Auto Connection一样,但是只有当不存在一个相同的连接时才会创建一个连接。如果已经存在相同的连接,则不会创建连接,connect()返回false。

可以在connect()添加参数指定连接类型。需要注意的一点是:如果信号发送方和接收方处于不同的线程,而且接收方线程运行着一个事件循环,此时用Direct Connection是不安全,原因跟调用一个对象的函数,而这个对象处于另外的线程,那样的调用是不安全。

QObject::connect() 本身是线程安全的。

下面通过结果例子验证一下:

 1 class Receiver:publicQObject
 2 
 3 {
 4        Q_OBJECT
 5 
 6 public:
 7 
 8  
 9 
10        voidsendmes()
11 
12        {
13               emitemitSignal("emit message from A  To B");
14 
15        }
16 
17        Receiver()
18 
19        {
20  
21 
22        }
23 
24 protected slots:
25 
26        voidmessageSlot(QString mes)
27 
28        {
29               qDebug()<<mes;
30 
31        }
32 
33 signals:
34 
35        voidemitSignal(QString mes);
36 
37  
38 
39 private:
40 
41 };
42 
43 int main(int argc, char *argv[])
44 
45 {
46        QApplication a(argc, argv);
47 
48        Receiver objA,objB;
49 
50       
51 
52        QObject::connect(&objA,SIGNAL(emitSignal(QString)),&objB,SLOT(messageSlot(QString)));
53 
54        qDebug()<<"beforeemitsignal ";
55 
56        objA.sendmes();
57 
58        qDebug()<<"afteremitsignal ";
59 
60        returna.exec();
61 
62 }

objA,objB;出于同一个线程,所以connect的连接类型是Direct Connection

由输出我们可以看出执行顺序,

 

 如果我们写了两句连接:

1 QObject::connect(&objA,SIGNAL(emitSignal(QString)),&objB,SLOT(messageSlot(QString)));
2 QObject::connect(&objA,SIGNAL(emitSignal(QString)),&objB,SLOT(messageSlot(QString)));

就会相应的有两句消息输出:

如果指定了连接类型Qt::UniqueConnection ,就会只有一句消息输出了。

1 QObject::connect(&objA,SIGNAL(emitSignal(QString)),&objB,SLOT(messageSlot(QString)),Qt::UniqueConnection );
2 QObject::connect(&objA,SIGNAL(emitSignal(QString)),&objB,SLOT(messageSlot(QString)),Qt::UniqueConnection);

 1 int main(int argc, char *argv[])
 2 
 3 {
 4        QApplication a(argc, argv);
 5 
 6        QThread *thread = new QThread;
 7 
 8        thread->start();
 9 
10        Receiver objA,objB;
11 
12        objB.moveToThread(thread);
13 
14        QObject::connect(&objA,SIGNAL(emitSignal(QString)),&objB,SLOT(messageSlot(QString)) );
15 
16        qDebug()<<"beforeemitsignal ";
17 
18        objA.sendmes();
19 
20        qDebug()<<"afteremitsignal ";
21 
22        returna.exec();
23 
24 }

如果我们把objB放到另外的线程,connect的连接类型应该是Queued Connection 。

 

 1 int main(int argc, char *argv[])
 2 
 3 {
 4        QApplication a(argc, argv);
 5 
 6        QThread *thread = new QThread;
 7 
 8        thread->start();
 9 
10        Receiver objA,objB;
11 
12        objB.moveToThread(thread);
13 
14 QObject::connect(&objA,SIGNAL(emitSignal(QString)),&objB,SLOT(messageSlot(QString)) ,Qt::BlockingQueuedConnection);
15 
16        qDebug()<<"beforeemitsignal ";
17 
18        objA.sendmes();
19 
20        qDebug()<<"afteremitsignal ";
21 
22        returna.exec();
23 
24 }

显示的指定连接类型为Qt::BlockingQueuedConnection,则输出为:

 

以上是关于Qt QThread与QObject的关系的主要内容,如果未能解决你的问题,请参考以下文章

QThread 与 QObject的关系(QObject可以用于多线程,可以发送信号调用存在于其他线程的slot函数,但GUI类不可重入)

重点:怎样正确的使用QThread类(注:包括推荐使用QThread线程的新方法QObject::moveToThread)

Qt线程间的信号与槽 以及 QThread

QT多线程操作

QT中的线程与事件循环理解

qt中通过重写run方法创建线程与通过movetothread方法有啥区别