Thread wird nur einmal ausgeführt



  • Hallo,

    ich habe ein Thread Object das mit Resume nur einmal ausgeführt wird.

    Hier mein Hauptprogramm:

    __fastcall TForm1::TForm1(TComponent* Owner)
    	: TForm(Owner)
    {
    	x = new test(true); // Thread Object erzeugen
         count = 0;
    }
    //---------------------------------------------------------------------------
    
    void __fastcall TForm1::Button2Click(TObject *Sender)
    {
    	Edit1->Text = "";
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Timer1Timer(TObject *Sender)
    {
    	Edit2->Text = count;      //Counter erhöhen und ausgeben zum testen
         count++;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Button1Click(TObject *Sender)
    {
        x->Resume();  			//Thread ausführen
    }
    //---------------------------------------------------------------------------
    

    Nach betätigen von Button1 wird der Thread ausgeführt.
    Nach erneutem betätigen von Button1 wird der Thread nicht mehr ausgeführt.
    Hier die Thread Klasse:

    __fastcall test::test(bool CreateSuspended)
    	: TThread(CreateSuspended)
    {
    	  Priority = tpLowest;
    }
    //---------------------------------------------------------------------------
    void __fastcall test::Execute()
    {
    	Form1->Edit1->Text = "Thread Running";
    	for(unsigned long x = 0; x<=800000000; x++){}; //Nur zum testen eine Verzögerung
    	Synchronize(DisplayIt);
    }
    //---------------------------------------------------------------------------
    void __fastcall test::DisplayIt()
    {
    	Form1->Edit1->Text = "Thread Ready";
    }
    


  • So soll's auch sein. Wenn er fertig ist, dann ist es vorbei. Dann müsstest du einen neuen Thread erzeugen, um die Funktion erneut durchlaufen zu lassen. Oder du verwendest eine Schleife und irgendein Synchronisationsobjekt, sieht aus, als ob du das machen wolltest.



  • Besteht dann das Thread Object x ohne delete x nicht mehr und muss ich
    jedesmal ein neues Object erzeugen.

    void __fastcall TForm1::Button1Click(TObject *Sender)
    {
        x = new test(true); // Thread Object erzeugen
        x->Resume();              //Thread ausführen
    }
    

    Oder wie ist das zu verstehen?



  • Das hängt von FreeOnTerminate ab.



  • Ringding schrieb:

    Das hängt von FreeOnTerminate ab.

    ???



  • Hallo

    schaffst du es nicht einmal, die BCB-Hilfe nach einem Wort zu durchsuchen?
    TThread->FreeOnTerminate

    bis bald
    akari



  • Schuldigung wenn ich in einem Forum was frage.

    Habe bei der Borland Hilfe unter Thread nachgeschaut die Hilfe dazu
    ist nicht sehr umfangreich.

    Hätte natürlich auch mal unter TThread schauen können, bin nur manchmal etwas
    Lesefaul.

    Die Eigenschaft der Klasse TThreat

    FreeOnTerminate = true;

    Löscht das Object.

    //Hauptprogramm
    test_thread* my_thread;
    TForm1 *Form1;
    unsigned int count;
    //---------------------------------------------------------------------------
    __fastcall TForm1::TForm1(TComponent* Owner)
    	: TForm(Owner)
    {
         count = 0;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Timer1Timer(TObject *Sender)
    {
    	Edit2->Text = count;      //Counter erhöhen und ausgeben zum testen ob gleichmässig
         count++;                  //während des Threads weitergezählt wird
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Button1Click(TObject *Sender)
    {
    	my_thread = new test_thread(false,Edit1); // Thread Object erzeugen und starten
    
    }
    
    //Thread
    TEdit* thread_edit;
    __fastcall test_thread::test_thread(bool CreateSuspended,TEdit* edit)
    	: TThread(CreateSuspended)
    {
    	  thread_edit = edit;
    	  Priority = tpLowest;
           FreeOnTerminate = true;		//nach ausführen Thread Object zerstören
    }
    //---------------------------------------------------------------------------
    void __fastcall test_thread::Execute()
    {
    	thread_edit->Text = "Thread Running";			//Meldung ausgeben
    	for(unsigned long x = 0; x<=1000000000; x++){}; 	//Verzögerung nur zum testen
    	Synchronize(DisplayIt);
    }
    //---------------------------------------------------------------------------
    void __fastcall test_thread::DisplayIt()
    {
    	thread_edit->Text = "Thread Ready";              //Meldung ausgeben Thread beendet
    }
    

    Danke für die Hilfe.


Anmelden zum Antworten