Qt4.7中，线程，信号，事件的一点理解

首先，写个线程类，继承自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

Qt4.7中，线程，信号，事件的一点理解

折騰nas

使用vscode

鍵盤之個人體驗

c++標準IO庫

Qt4.7中，線程，信號，事件的一點理解

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結