82nd lesson, Thread life cycle

one, the life cycle of the thread

1, a project in the actual

(1),C + + object has a life cycle

(2), thread also has a life cycle

(3), the experience in engineering practice to find ways to ensure: Thread object (Qthread object) life cycle > corresponding thread life cycle

Problem code: After defining the local thread Object T.start () in the stack, the inheritance is executed down, then the thread object is destroyed, and the member variable i is destroyed, but run () is not finished, it will operate a destroyed object, the program crashes

second, the design of synchronous thread

1. Concept: Thread object is actively waiting for thread life to end before destroying

2. Features

(1), while supporting the creation of thread objects in stacks and heaps

(2), the object is destroyed to ensure that the end of the thread life cycle

3. Important: Call the Wait () function in the destructor to force the wait thread to run the end

4, use occasions: the thread life cycle is relatively short case

three, asynchronous threading design

1. Concept: Notification of the destruction of thread objects at the end of the thread life cycle

2. Features

(1), you can only create thread objects in the heap ( declare constructors as private, so define static member functions like second-order constructs to create objects )

(2), thread object can not be actively destroyed by the outside ( declare the destructor as private )

3. Key points:

(1), the last call to the Deletelater () function in Run () (as the name implies Deletelater () can only create objects on the heap)

(2), thread body function active request to destroy Thread object (apply to QT platform)

4, use occasions: the thread cycle is not controllable, it takes a long time to run in the background of the situation

int Main (intchar0x1c08void0x2050void0 void 1 void 2 void Asynthread::run () Endasynthread::~asynthread ()// called destructor, indicating no memory leaks

   #ifndef mythread_h   #define  Mythread_h #include  <qthread>class  MyThread: public   qthread{q_object  public  :  explicit     MyThread (Qobject *parent = 0   public   slots:  private  :  void     Span style= "COLOR: #000000" > run (); };  #endif  //  Mythread_h   

Problematic Thread MyThread.h

#include"MyThread.h"#include<QDebug>Mythread::mythread (Qobject*parent): Qthread (parent) {}voidMythread::run () {qdebug ()<<"void Mythread::run () tid="<<Qthread::currentthreadid ();  for(intI=0; i<3; i++) {qdebug ()<<"void Mythread::run () i="<<i; Sleep (1); } qdebug ()<<"void Mythread::run End";}

Problematic Thread MyThread.cpp

   #ifndef synthread_h   #define  Synthread_h #include  <qthread>class  synthread: public   qthread{Q_object  public  :      Explicit  synthread (qobject *parent = 0   ~synthread ();  private  :      void   run (); };  #endif  //  Synthread_h   

Synchronous Thread SynThread.h

#include"Synthread.h"#include<QDebug>Synthread::synthread (Qobject*parent): Qthread (parent) {}voidSynthread::run () {qdebug ()<<"void Synthread::run () tid="<<Qthread::currentthreadid ();  for(intI=0; i<3; i++) {qdebug ()<<"void Mythread::run () i="<<i; Sleep (1); } qdebug ()<<"void Synthread::run () End";} Synthread::~Synthread () {wait ();//the end of the waiting thread cycle in the destructorQdebug () <<"Synthread::~synthread ()";}

Synchronous Thread SynThread.cpp

#ifndef Asynthread_h#defineAsynthread_h#include<QThread>classAsynthread: Publicqthread{Q_object Public:    Staticasynthread* newinstance (Qobject *parent=0);Private:    voidrun (); ExplicitAsynthread (Qobject *parent =0);//constructors and destructors are defined as private~asynthread ();};#endif //Asynthread_h

Asynchronous Thread AsynThread.h

#include"AsynThread.h"#include<QDebug>Asynthread::asynthread (Qobject*parent): Qthread (parent) {}asynthread* Asynthread::newinstance (Qobject *parent) {    return NewAsynthread (parent);}voidAsynthread::run () {qdebug ()<<"void Asynthread::run () tid="<<Qthread::currentthreadid ();  for(intI=0; i<3; i++) {qdebug ()<<"void Asynthread::run () i="<<i; Sleep (1); } qdebug ()<<"void Asynthread::run () End"; Deletelater ();//be careful to put the last}asynthread::~Asynthread () {qdebug ()<<"Asynthread::~asynthread ()";}

Asynchronous Thread AsynThread.cpp

#include <QtCore/QCoreApplication>#include"MyThread.h"#include"Synthread.h"#include"AsynThread.h"#include<QDebug>#include<QThread>voidMythread () {mythread T; T.start ();}voidSynthread () {Synthread st; St.start ();}voidAsynthread () {Asynthread* at =asynthread::newinstance (); //Asynthread t;//compile error, constructor private at-start (); //Delete at;//error compiling, destructor private}intMainintargcChar*argv[])        {Qcoreapplication A (argc, argv); Qdebug ()<<"int main (int argc, char* argv[]) tid="<<Qthread::currentthreadid (); //mythread ();//program Crashes//Synthread ();//synchronous thread, running correctlyAsynthread (); returna.exec ();}

main.cpp Iv. Summary

(1), the life cycle of the thread object must be greater than the corresponding thread's life cycle

(2), synchronous thread Design---thread life-cycle is short

(3), asynchronous Threading Design---Thread life-time is not controllable

(4), thread class design must adapt to specific occasions

(5), no universal design, only the right design

82nd lesson, Thread life cycle