首先,写个线程类,继承自QThread,该线程做的事情很简单:每两秒打印一次自己的线程id,由于我对Qt的console打印函数不太了解,这里还是使用c++的cout!
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
#include <iostream>
using namespace std;
class Mythread : public QThread
{
Q_OBJECT
public:
explicit Mythread(QObject *parent = 0);
signals:
public slots:
protected:
void run();
};
#endif // MYTHREAD_H
#include "mythread.h"
Mythread::Mythread(QObject *parent) :
QThread(parent)
{
}
void Mythread::run()
{
while(1)
{
cout << "thread id: " << QThread::currentThreadId() << endl;
sleep(2);
}
}
#include <QtCore/QCoreApplication>
#include "mythread.h"
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
cout << "main thread id:" << QThread::currentThreadId() << endl;
Mythread thread;
thread.start();
return a.exec();
}
这是一个Qt console进程,好了,运行一下,每隔两秒打印一次子线程id。
接下来,我们给线程设置定时器,来替换sleep
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
#include <QTimer>
#include <iostream>
using namespace std;
class Mythread : public QThread
{
Q_OBJECT
public:
explicit Mythread(QObject *parent = 0);
signals:
public slots:
void mytimedout();
protected:
void run();
QTimer _timer;
};
#endif // MYTHREAD_H
#include "mythread.h"
Mythread::Mythread(QObject *parent) :
QThread(parent)
{
}
void Mythread::run()
{
connect(&_timer, SIGNAL(timeout()), this, SLOT(mytimedout()));
cout << "child thread id: " << QThread::currentThreadId() << endl;
_timer.start(2000);
exec();
}
void Mythread::mytimedout()
{
cout << "thread id: " << QThread::currentThreadId() << endl;
}
main与以前相同
发现并不能正常隔两秒打印一次。根据我查的资料,大概原因是:QTimer是在主线程里创建的,它发的信号只能与主线程相关的QObject来处理。详细信息还需要细看文档。
修改代码,我们在子线程里创建一个QTimer,并用它来发超时信号,子线程会阻塞在exec()这里,所以不用担心mytimer的生存期
将run改为如下:
void Mythread::run()
{
QTimer mytimer;
connect(&mytimer, SIGNAL(timeout()), this, SLOT(mytimedout()));
cout << "child thread id: " << QThread::currentThreadId() << endl;
mytimer.start(2000);
exec();
}
此时可以打印了,不过,我们发现打印的时候,显示的是主线程id,也就是说,mytimedout这个函数是在主线程里执行的。根据所查资料,这里大概是因为:工作线程在创建的时候,线程的事件处理,是依附在创建者身上的,我们需要在创建之后,调用QObject::moveToThread()来改变依附性,
main修改如下:
#include <QtCore/QCoreApplication>
#include "mythread.h"
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
cout << "main thread id:" << QThread::currentThreadId() << endl;
Mythread thread;
thread.start();
thread.moveToThread(&thread);
return a.exec();
}
这时候,便由子线程自己来打印了
接下来看下事件,QEvent!我们让子线程往主线程发送QEvent,主线程接受到后,打印信息表示接收到了。
要让主线程可以处理自定义事件,需要从QCoreApplication继承一个类,并改写虚函数event(QEvent *eve)
#ifndef MYAPP_H
#define MYAPP_H
#include <QCoreApplication>
#include <mythread.h>
class Myapp : public QCoreApplication
{
Q_OBJECT
public:
explicit Myapp(int argc, char* argv[], QObject *parent = 0);
bool event( QEvent * e );
signals:
public slots:
};
#endif // MYAPP_H
#include "myapp.h"
Myapp::Myapp(int argc, char* argv[], QObject *parent) :
QCoreApplication(argc, argv)
{
}
bool Myapp::event( QEvent * e )
{
if(e->type() == (mytype1)){
cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
}
return QCoreApplication::event(e);
}
子线程里,发送事件
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
#include <QTimer>
#include <QEvent>
#include <iostream>
using namespace std;
enum Type{ mytype1 = QEvent::User+1, mytype2 }; // 这是我自定义的事件类型。这里有个问题,可能是qt的bug,如果我编译成功了,然后改mytype1=QEvent::User,再编译运行,就会收不到事件
class Mythread : public QThread
{
Q_OBJECT
public:
explicit Mythread(QObject *parent = 0);
signals:
public slots:
void mytimedout();
protected:
void run();
QTimer _timer;
};
#endif // MYTHREAD_H
#include <QCoreApplication>
#include "mythread.h"
Mythread::Mythread(QObject *parent) :
QThread(parent)
{
}
void Mythread::run()
{
QTimer mytimer;
connect(&mytimer, SIGNAL(timeout()), this, SLOT(mytimedout()));
cout << "child thread id: " << QThread::currentThreadId() << endl;
mytimer.start(2000);
exec();
}
void Mythread::mytimedout()
{
cout << "thread id: " << QThread::currentThreadId() << endl;
QEvent *eve = new QEvent((QEvent::Type)(mytype1));
QCoreApplication::postEvent(QCoreApplication::instance(), eve);
}
#include <QtCore/QCoreApplication>
#include "mythread.h"
#include "myapp.h"
int main(int argc, char *argv[])
{
Myapp a(argc, argv);
cout << "reg value:" << QEvent::registerEventType(mytype1) << endl; // 这里注册一下,看该类型的事件是否被别人注册过了,避免混淆
cout << "reg value:" << QEvent::registerEventType(mytype2) << endl;
cout << "main thread id:" << QThread::currentThreadId() << endl;
Mythread thread;
thread.start();
thread.moveToThread(&thread);
return a.exec();
}
我们在Mythread::mytimedout()里new 了一个QEvnet对象,却没有去delete它,那么它会内存泄漏吗?其实不会,因为这个事件被发出去后,处理该事件的对象在处理完该事件后,会delete它,比如这里是
bool Myapp::event( QEvent * e )
{
if(e->type() == (mytype1)){
cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
}
return QCoreApplication::event(e);
}
return QCoreApplication::event(e); 这里是转给父类去处理,估计最终会由QObject的event函数来delete掉。
我们可以自己写个类继承自QEvent,QEvent的析构函数为虚。我们的类继承它,别人delete这个类时,除了会执行自己的析构函数以外,也会调用QEvent的析构函数。
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
#include <QTimer>
#include <QEvent>
#include <iostream>
using namespace std;
enum Type{ mytype1 = QEvent::User+1, mytype2 };
class Myevent:public QEvent
{
public:
Myevent(QEvent::Type type):QEvent(type){}
~Myevent(){
cout << "thread id: " << QThread::currentThreadId() << "destroy event, type is:" << type() << endl;
}
};
class Mythread : public QThread
{
Q_OBJECT
public:
explicit Mythread(QObject *parent = 0);
signals:
public slots:
void mytimedout();
protected:
void run();
QTimer _timer;
};
#endif // MYTHREAD_H
void Mythread::mytimedout()
{
cout << "thread id: " << QThread::currentThreadId() << endl;
QEvent *eve = new Myevent((QEvent::Type)(mytype1));
QCoreApplication::postEvent(QCoreApplication::instance(), eve);
}
可以看到Myapp的线程在处理完事件后,delete掉了事件,因为调用了Myevent的析构函数。
最后,我们让父类接收到mytype1事件后,往子线程发一个mytype2事件。
类Mythread需要重载event方法
bool Mythread::event( QEvent * e )
{
switch(e->type())
{
case mytype2:
cout << "child thread:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
break;
default:
break;
}
return QThread::event(e);
}
Myapp的event变为
bool Myapp::event( QEvent * e )
{
if(e->type() == (mytype1)){
cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
QEvent *eve = new Myevent((QEvent::Type)mytype2);
postEvent(_recv, eve);
}
return QCoreApplication::event(e);
}
这里_recv是子线程的QObject指针
void setReceive(QObject *obj){
_recv = obj;
}
protected:
QObject *_recv;
main函数
#include <QtCore/QCoreApplication>
#include "mythread.h"
#include "myapp.h"
int main(int argc, char *argv[])
{
Myapp a(argc, argv);
cout << "reg value:" << QEvent::registerEventType(mytype1) << endl;
cout << "reg value:" << QEvent::registerEventType(mytype2) << endl;
cout << "main thread id:" << QThread::currentThreadId() << endl;
Mythread thread;
a.setReceive(&thread);
thread.start();
thread.moveToThread(&thread);
return a.exec();
}
这样,子线程每2秒处理一个超时信号,打印相关信息和往主线程发事件mytype1,主线程接收到该事件后,往子线程发一个mytype2的事件。子线程处理mytype2事件,打印信息
注意:
thread.moveToThread(&thread) // 这不是一个好的方法,这里作为例子这么用可以更快速让例子运行起来
参考:
http://www.qtcn.org/bbs/simple/?t32303.html
http://www.cnblogs.com/tankery/archive/2011/03/09/2004561.html
http://www.cnblogs.com/andreitang/archive/2011/08/03/2125815.html