THREADS: Benutzung von "TThread.ReturnValue"

[APP]

Hallo,

ich suche ein Beispiel für die Benutzung von "TThread.ReturnValue",
darf man lt. Hilfe dieses Property frei benutzen :?:

Zitat:

Specifies the value returned to other waiting threads when the thread finishes executing.

Delphi syntax:

property ReturnValue: Integer
...
Description

Use ReturnValue to indicate success/failure or numeric result/output of the thread to the application or other threads. The WaitFor method returns the value stored in ReturnValue.

[DataCool]

Genau an diesem Problem sitze ich auch gerade !
Laur Delphi-Hilfe soll die Methode waitfor, auf das ende eines Threads warten und den Wert von ReturnValue zurück geben, eigentlich genau was ich brauche.

Aber es funktioniert leider nicht !
Wann muß der Wert für ReturnValue innerhalb des Threads gesetzt werden ?
Ich mache das im Moment im Ereigniss OnTerminate, hab's aber auch schon am Ende von Execute gemacht; beides kein Erfolg !

Im Moment mache das ganze quick and dirty !
Habe mir ne global zugängliche Longint Variable in der Threadunit erstellt, schreibe da das Ergebnis rein und lese es vom Hauptthread nachdem ich waitfor des threads aufgerufen habe wieder aus.
Aber das kann's doch nicht sein, oder ?

[Praktikant]

und ich suche auch ein Bsp. wie man returnvalue und wait for benutzt.
Die Delphi Hilfe bietet da ja überhaupt nichts.

Hmm... sehe dass das ja nur mit Verbindung von threads geht. Da ich davon null plan habe brauche ich nun doch nicht mehr wissen wie return/waitfor funktioniert. :roll:

[DataCool]

Hi Leute,

ich habe das Problem jetzt folgender Massen gelöst :

Erstmal habe ich mir eine seperate Klasse ThreadResult erstellt(s. Code) :

Code:

unit ThreadResult;

interface

uses Classes;

type

   TThreadResult = class
      private
         fStr : String;
         fInt : Longint;
         fOk  : Boolean;
      protected
         {}
      public
         Constructor Create;
         property StrRes : String read fStr write fStr;
         property IntRes : Longint read fInt write fInt;
         property Ok     : Boolean read fOk  write fOk;
   end;

implementation

constructor TThreadResult.Create;
begin
   inherited;
   fStr := '';
   fInt := -100;
   fOk  := false;
end;

end.

So, vorm starten eines Threads erzeuge ich eine Instanz dieser Klasse und übergebe diese mit in den Thread.
Da die Instanz dieser Klasse nicht vom Thread erzeugt wird, wird der Speicherbereich auch nicht nach Ende des Threads freigegeben.
An den Thread wird ja nur ein Zeiger auf die Klasse übergeben, so kann der Thread die Werte der Klase ändern, aber die Klase wird nicht bei Beendigung des Threads zerstört.
Siehe folgendes Beispiel :

Code:

function ThreadBsp : Boolean;
Var
   myThd   : TmyThread;
   ThdRes  : TThreadResult;
begin
   // Speicher-KLasse für THread-ERgebnis erzeugen
   ThdRes := TThreadResult.Create;
   try
      // Thread erzeugen, wird aber noch nicht gestartet
      myThd := TmyThread.Create(ThdRes);
      // Thread starten
      myThd.Resume;
      // auf Ende des Threads warten
      myThd.WaitFor;
      // Thread-Ergebnis auslesen
      result := ThdRes.Ok;

      // Wenn man einen String als Rückgabewert erwartet dann ..
      // ThdRes.StrRes

      // Wenn man einen Integer als Rückgabe Wert erwartet dann ..
      // ThdRes.IntRes
   finally
      // Speicher-KLasse wieder freigeben
      ThdRes.free;
   end;
end;

Der Thread selber wird suspended gestart und die Eigenschaft FreeOnTerminate wird auf True gesetzt !

Gruß Data

[scp]

Ein Beispiel:

Delphi-Quellcode:

procedure TDownloadThread.Execute;
begin
  ReturnValue := 0;

  DownloadFiles;

  ReturnValue := 1;
end;

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  ThreadResult : integer;
begin
  ThreadResult := DownloadThread.WaitFor;

  If (ThreadResult = 1) then
    ShowMessage('Thread beendet')
  else
  If (ThreadResult = 0) then
  else
    ShowMessage('Thread läuft noch')
  else
  If (ThreadResult < 0) then
    ShowMessage('Thread mit Fehler ' + IntToStr(ThreadResult) + ' beendet.');
end;

[Luckie]

Dann darf FreeOnTerminate natürlich nicht True sein. Oder täusche ich mich da jetzt? :gruebel:

[scp]

Stimmt, sonst wäre waitfor ja nicht mehr gültig.

[DataCool]

@Luckie:
Du meintest doch nicht mich oder ?

@SCP:
Mir und den anderen ging es nicht darum herrauszufinden, ob der Threads noch läuft, sondern je nach Ablauf des Threads ein bestimmtes Ergebnis zu erhalten

Gruß Data

[scp]

siehe oben

[Luckie]

@DataCoo, ich meinte spc.

@spc: Jetzt wird es aber kompliziert: Wo wird der negative ExitCode gesetzt?

[scp]

Innerhalb des Threadcodes, die zwei wollten ja unterschiedliche Rückgabewerte.

[Garby]

Hallo,

mal generell: Warum sollte ich einen Thread verwenden, wenn ich die Ausführung des Hauptthreads anhalte, bis der erzeugte Thread beendet wird?

Ich verwende immer ein Ereignis im Thread, das ich am Ende von TThread.Execute (oder bei einem evtl. auftretenden Fehler) synchronisiert aufrufe.

[DataCool]

Da ist mir meine Lösung aber bei weitem lieber !

1. Kann man die Klase ThreadResult beliebig erweitern

2. Kann ich auch Strings zurück bekommen

3. Kann ich die Eigenschaft FreeOnTerminate bei mir auf True setzen

Gruß Data

[Luckie]

waitFor legt den Hauptthread nicht lahm, sonst dürfte scp's Beispiel nicht funktionieren. WaitFor fragt nur den ExiotCode des Threads ab, wenn ich das richtig sehe.

[DataCool]

@Garby:
Wer hat den gesagt, das der Thread innerhalb des Haupt-Threads erzeugt wird ?
Bei mir wird der Thread aus anderen Threads erzeugt.

Gruß Data

[Garby]

AHA, und warum erzeugst du dann noch einen Thread :?:

[Luckie]

Eventuell ist das ein Dispatcher Thread. Oder weiß der Geier, was das für eine Konstruktion ist. :mrgreen:

[DataCool]

Weil einen Thread mehere Aufgaben verwaltet und die entsprechenden Child-Threads aufruft.

Außerdem hat Luckie wiedermal recht, wenn er sagt das waitFor nicht den mainThread blockiert.

Gruß Data