本文转载自互联网，如果有侵权请及时联系删除
根据博文一中提到在没有event loop的thread使用, 那么thread结束后销毁对象。因此我尝试继承自QObject的对象使用deleteLater先删除，然后调用thread中的quit();这样继承自QObject的对象就可以正常析构了。
博文一：
原文：https://zhuanlan.zhihu.com/p/150178215
一、 ”deleteLater()“的使用
下面是官方文档对 ”deleteLater()“的介绍
Schedules this object for deletion.
The object will be deleted when control returns to the event loop. If the event loop is not running when this function is called (e.g. deleteLater() is called on an object before QCoreApplication::exec()), the object will be deleted once the event loop is started. If deleteLater() is called after the main event loop has stopped, the object will not be deleted. Since Qt 4.8, if deleteLater() is called on an object that lives in a thread with no running event loop, the object will be destroyed when the thread finishes.
Note that entering and leaving a new event loop (e.g., by opening a modal dialog) will not perform the deferred deletion; for the object to be deleted, the control must return to the event loop from which deleteLater() was called. This does not apply to objects deleted while a previous, nested event loop was still running: the Qt event loop will delete those objects as soon as the new nested event loop starts.
Note: It is safe to call this function more than once; when the first deferred deletion event is delivered, any pending events for the object are removed from the event queue.
Note: This function is thread-safe.
总结一下就是以下几点:
- 首先”deleteLater()“是QObject对象的一个函数, 要想使用此方法, 必须是一个QObject对象。
- ”deleteLater()“依赖于Qt的event loop机制。
- 如果在event loop启用前被调用, 那么event loop启用后对象才会被销毁;
- 如果在event loop结束后被调用, 那么对象不会被销毁;
- 如果在没有event loop的thread使用, 那么thread结束后销毁对象。
- 可以多次调用此函数。
- 线程安全。
博文二：
原文：https://www.cnblogs.com/butterflybay/p/10347848.html
Qt deletelater函数分析(1)
生活的全部意义在于无穷地探索尚未知道的东西，在于不断地增加更多的知识。——左拉
该函数是QObject类的函数： -------------------------- （了解该类可以帮助深刻理解即Qt）
deletelater的原理是 QObject::deleteLater()并没有将对象立即销毁，而是向主消息循环发送了一个event，下一次主消息循环收到这个event之后才会销毁对象。
所有继承自QObejet类的类都会维护一个自己的子对象列表，同时会存储自己的父对象，所以界面中的各个控件(各个控价的基类都是QObject)可以实现层次！
“当我们使用父对象来创建一个对象的时候 ，父对象会把这个对象添加到自己的子对象列表中。当这个父对象被删除的时候，它会遍历它的子对象类表并且删除每一个子对象，然后子对象们自己再删除它们自己的子对象，这样递归调用直到所有对象都被删除。 这种父子对象机制会在很大程度上简化我们的内存管理工作，减少内存泄露的风险。所以，使用deleteLater主要作用还是减少内存泄露的风险。”
关闭一个窗口时(QQuickView， QQuickWindow，注意QQuickView的基类是QQuickWindow)，建议用这个方法的deleteLater()
项目中的实例：
QQuickView* view = new QQuickView();
view->setSource(QUrl(QStringLiteral("qrc:/QML/xxx.qml")));
view->show();
关闭view时：
view->close(); //该函数会偶尔导致整个程序退出！看后面分析。可以不用它，直接掉deletelater（）
view->deleteLater()
view = NULL;
调用deleteLater()后，xxx.qml中定义的对象会被销毁（析构函数被调用）。close函数仅仅是关闭页面，并不会将内存释放掉，如果不调用deleteLater函数会导致内存占用不断增加！ 我在调试过程中，快速点击新建和关闭，并没有遇到deleteLater函数调用不及时的问题。
上面调用的close函数是QquickView的基类QWindow的函数，帮助文档中的解释：
“potentially quitting the application!!!!!!!!!!”---所以还是别用了
# 注意：
view->deleteLater()被调用之后需要将view这个指针置为NULL，否则就是野指针。
疑惑：如果按照上面的代码所写，会不会出现这种情况：当删除事件加入循环队列后，指针被赋值为0，接着删除事件被处理，这时因为指针为0，所以堆对象删除失败，造成了内存泄露？---- 不是！
deleteLater函数是QObject类的一个成员函数，它发出一个event给主循环，发出的事件中本身包含了需要被delete的对象的地址。
Ref:
https://www.cnblogs.com/liushui-sky/p/5852090.html https://blog.youkuaiyun.com/qq_30126571/article/details/78036576 https://blog.youkuaiyun.com/ZXHL_hxf/article/details/83410852 https://blog.youkuaiyun.com/li235456789/article/details/50599757 https://bbs.youkuaiyun.com/topics/392388844 https://blog.youkuaiyun.com/dbzhang800/article/details/6300025
博文三
Qt线程QThread开启和安全退出，QMutex线程加锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/birenxiaofeigg/article/details/102948397
1、线程开启
Qt中，开启子线程，一般有两种方法：
a, 定义工作类worker:
worker继承 QThread, 重写run函数，在主线程中实例化worker，把耗时工作放进worker的run函数中完成，结束后，往主线程中发信号，传递参数即可。
注意：此worker的实例，只有run函数在子线程中执行，worker的其他函数，均在主线程中执行。
如果子线程已经start开启，run函数尚未运行完时，再次start，此时子线程不会有任何操作，run函数不会被重新调用，会继续执行run函数。
b, 定义工作类worker:
worker继承Qobject，在worker中完成耗时操作，并在主线程中 #include "worker.h"进来，随后，在主线程中New出几个子线程QThread，使用moveToThread()函数，把worker转移进入子线程，例如：
pWorker = new Worker;
pThread1 = new QThread;
pWorker->moveToThread(pThread1)
之后，再根据需求，看何时开启子线程：pThread1->start();
如果线程已经运行，你重复调用start其实是不会进行任何处理。
2、线程关闭
对于上面a类，在run中开启的子线程，如果run中没有调用exec()，使用quit(),exit()，是无法跳出run中的循环，终止子线程的。不会发生任何效果，QThread不会因为你调用quit()函数而退出正在运行到一半的run。
但使用QThread的terminate()方法，可以立刻结束子线程，但这个函数存在非常不安定因素，不推荐使用。那么如何安全的终止一个线程呢？
最简单的方法是添加一个bool变量，通过主线程修改这个bool变量来进行终止，但这样有可能引起访问冲突，需要对其进行加锁。
void myThread::run()
{
int count = 0;
m_isCanRun = true;//标记可以运行
QString str = QString("%1->%2,thread id:%3").arg(__FILE__).arg(__FUNCTION__)
.arg((unsigned int)QThread::currentThreadId());
emit message(str);
while(1)
{
sleep(1);
++count;
doSomething();
if(m_runCount == count)
{
break;
}
{
QMutexLocker locker(&m_lock);// 此处加锁,防止访问冲突
if(!m_isCanRun)//在每次循环判断是否可以运行，如果不行就退出循环
{
return;
}
}
}
}
因此在子线程的run函数的循环中遇到m_isCanRun的判断后就会退出run函数,继承QThread的函数在运行完run函数后就视为线程完成，会发射finish信号。
子线程指针，尽量不要去delete ，这样不安全。一般会绑定QObject::deleteLater()方法。
connect(pThread,&QThread::finished ,thread,&QObject::deleteLater);
线程结束后调用deleteLater来销毁分配的内存。
对于上面b类，在Qt4.8之后，Qt多线程的写法最好还是通过QObject来实现，和线程的交互通过信号和槽(实际上其实是通过事件)联系。
继承QObject多线程的方法线程的创建很简单，只要让QThread的start函数运行起来就行，但是需要注意销毁线程的方法: 在线程创建之后，这个QObject的销毁不应该在主线程里进行，而是通过deleteLater槽进行安全的销毁，因此，继承QObject多线程的方法在创建时有几个槽函数需要特别关注：
- 一个是QThread的finished信号对接QObject的deleteLater使得线程结束后，继承QObject的那个多线程类会自己销毁
- 另一个是QThread的finished信号对接QThread自己的deleteLater，这个不是必须，下面官方例子就没这样做:
class Worker : public QObject
{
Q_OBJECT
public slots:
void doWork(const QString ¶meter) {
QString result;
/* ... here is the expensive or blocking operation ... */
emit resultReady(result);
}
signals:
void resultReady(const QString &result);
};
class Controller : public QObject
{
Q_OBJECT
QThread workerThread;
public:
Controller() {
Worker *worker = new Worker;
worker->moveToThread(&workerThread);
connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
connect(this, &Controller::operate, worker, &Worker::doWork);
connect(worker, &Worker::resultReady, this, &Controller::handleResults);
workerThread.start();
}
~Controller() {
workerThread.quit();
workerThread.wait();
}
public slots:
void handleResults(const QString &);
signals:
void operate(const QString &);
};
使用QObject创建多线程的方法如下：
- 写一个继承QObject的类，对需要进行复杂耗时逻辑的入口函数声明为槽函数
- 此类在旧线程new出来，不能给它设置任何父对象
- 同时声明一个QThread对象，在官方例子里，QThread并没有new出来，这样在析构时就需要调用- – QThread::wait()，如果是堆分配的话， 可以通过deleteLater来让线程自杀
- 把obj通过moveToThread方法转移到新线程中，此时object已经是在线程中了
- 把线程的finished信号和object的deleteLater槽连接，这个信号槽必须连接，否则会内存泄漏
- 正常连接其他信号和槽（在连接信号槽之前调用moveToThread，不需要处理connect的第五个参数，否则就显示声明用Qt::QueuedConnection来连接）
- 初始化完后调用’QThread::start()'来启动线程
- 在逻辑结束后，调用QThread::quit退出线程的事件循环
3、QMutex线程加锁
QMutex类提供的是多线程之间的访问顺序化。QMutex的目的是保护一个对象、函数、数据结构或者代码段，所以同一时间只有一个线程可以访问它。
例如：
void myTest::testOut()
{
//mtex.lock();
_sleep(3000);
qDebug() << "this is mytest1: -----" ;
qDebug() << "this is mytest2:----";
//mtex.unlock();
}
如果同时在两个线程中调用这个方法，结果的顺序将是：
this is mytest1: -----
this is mytest1: -----
this is mytest2: -----
this is mytest2: -----
如果你使用互斥量，加了锁之后：
void myTest::testOut()
{
mtex.lock();
_sleep(3000);
qDebug() << "this is mytest1: -----" ;
qDebug() << "this is mytest2:----";
mtex.unlock();
}
输出结果为：
this is mytest1: -----
this is mytest2: -----
// 中间延迟 3000ms
this is mytest1: -----
this is mytest2: -----
一个 使用run(),moveToThread()新建子线程并结束线程,QMutex以及单例化实现的Demo示例：
myMutex1::myMutex1(QWidget *parent)
: QMainWindow(parent)
{
ui.setupUi(this);
t1 = new myThread();
t2 = new myThread();
t3 = new myThread();
t4 = new QThread();
t5 = new QThread();
t6 = new QThread();
my1 = myTest::getInstance();
my2 = myTest::getInstance();
my3 = myTest::getInstance();
my1->moveToThread(t4);
my2->moveToThread(t5);
my3->moveToThread(t6);
qDebug() << "t1 addr----" << t1;
qDebug() << "t2 addr----" << t2;
qDebug() << "t3 addr----" << t3;
qDebug() << "t4 addr----" << t4;
qDebug() << "t5 addr----" << t5;
qDebug() << "t6 addr----" << t6;
}
该样例Demo下载地址：
https://download.youkuaiyun.com/download/birenxiaofeigg/11963711
扫一扫
1330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
