QThread beendet() verbunden mit deleterater eines QObjects

Question

Ich habe viel nachgedacht und viele Artikel gelesen, bevor ich diese Frage hier gestellt habe. Keiner der Artikel gab mir eine richtige Antwort.

http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/

QThread* thread = new QThread; 
Worker* worker = new Worker(); 
worker->moveToThread(thread); 
connect(worker, SIGNAL(error(QString)), this, SLOT(errorString(QString))); 
connect(thread, SIGNAL(started()), worker, SLOT(process())); 
connect(worker, SIGNAL(finished()), thread, SLOT(quit())); 
connect(worker, SIGNAL(finished()), worker, SLOT(deleteLater())); 
connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); 
thread->start(); 

Worker-Objekt hat die Affinität des neuen Thread.

1> Worker beendete Signal wird quit() auf dem Thread aufrufen. Dies wird die Ereignisschleife des Threads beenden und das Ende des Thread-Signals auslösen.

2> Worker beendete Signal ist mit dem Worker deleteLater() verbunden. Gemäß deleteLater() Dokumentation

** Plant dieses Objekt zum Löschen. Das Objekt wird gelöscht, wenn die Steuerung zur Ereignisschleife zurückkehrt. Wenn die Ereignisschleife ist> nicht

läuft, wenn diese Funktion aufgerufen wird (z deleteLater() auf einem Objekt vor QCoreApplication aufgerufen :: exec()), wird das Objekt gelöscht einmal die Ereignisschleife gestartet wird.

Beachten Sie, dass das Eingeben und das Verlassen einer neuen Ereignisschleife (z. B. durch Öffnen eines modalen Dialogfelds) nicht die verzögerte Löschung von ausführen; Für das zu löschende Objekt muss die Steuerung zu der Ereignisschleife zurückkehren, von der deleteLater() aufgerufen wurde.

Hinweis: Es ist sicher, diese Funktion mehr als einmal aufzurufen; wenn die ersten latenten Deletionsereignis geliefert wird, alle anstehenden Ereignisse für das Objekt werden aus der Ereigniswarteschlange entfernt. **

Also, wenn es keine Ereignisschleife, da der Faden bereits austritt und es wird bereits angehoben das fertige Signal und wir werden nicht mehr den gleichen Thread erneut starten. In diesem Fall wird deleteLater() niemals behandelt, da die Ereignisschleife nicht existiert und das Worker-Objekt überhaupt nicht gelöscht wird. Wird dadurch kein Speicherleck erzeugt?

Wenn wir denken, dass das Vertauschen der zwei Linien das Problem beheben wird, dann habe ich eine andere Frage. QT gibt eindeutig an, dass die Reihenfolge, in der die Steckplätze aufgerufen werden, wenn ein Signal ausgegeben wird, unbestimmt ist

Es gibt eine Menge Kommentare in der oben genannten Artikelverknüpfung. Auch war der Autor nicht in der Lage, die Frage völlig

Answer 1

QThread mit einem Ereignistyp von QEvent :: DeferredDelete ein QCoreApplication::sendPostedEvents tun zu beantworten nach dem Senden es fertig Signal

mit anderen Worten QThread sammeln alle anstehenden deleteLaters und führen sie nach run kehrt

Quelle: https://qt.gitorious.org/qt/qtbase/source/c657bb7b51115d6e1719166fb502bb0ca1dcf4e8:src/corelib/thread/qthread_win.cpp#L363-462

Answer 2

//! put the following code in constructor 
QThread *thread = new QThread; 
//! type of m_weakThread is QWeakPointer<QThread> 
m_weakThread = thread; 
Worker *worker = new Worker; 
//! type of m_weakWorker is QWeakPointer<Worker> 
m_weakWorker = worker; 
worker->moveToThread(thread); 
connect(worker, SIGNAL(error(QString)), this, SLOT(errorString(QString))); 
connect(thread, SIGNAL(started()), worker, SLOT(process())); 
connect(worker, SIGNAL(finished()), worker, SLOT(deleteLater())); 
//! instead of finished() signal, connect destroyed() signal to thread's quit() slot 
connect(worker, SIGNAL(destroyed()), thread, SLOT(quit())); 
connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); 
thread->start(); 

//! put the following code in destructor 
if (!m_weakThread.isNull()) { 
    QThread *thread = m_weakThread.data(); 
    if (thread->isRunning()) { 
     thread->quit(); 
     thread->wait(); 
    } 
} 
if (!m_weakWorker.isNull()) { 
    Worker *worker = m_weakWorker.data(); 
    m_weakWorker.clear(); //! optional, a little optimization 
    //! it's safe to release worker since the secondary thread exits 
    delete worker; 
} 
if (!m_weakThread.isNull()) { 
    QThread *thread = m_weakThread.data(); 
    m_weakThread.clear(); 
    //! it's safe to release thread since it exits and all objects in it has released 
    delete thread; 
}