100 Gummipunkte für meinen Hohlkopf!

Leider -200 Gummipunkte für mich. Ich glaube ich bin zu dämlich dafür die Ableitung aus Beitrag 2 zu nutzen

markieren

Delphi-Quellcode:

var TestThread: TTestThread;

procedure TForm1.Button2Click(Sender: TObject);
begin
 TestThread:= TestThread.Create;
 TestThread.Interval := 60000;
end;

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit3;

interface

uses
 System.Classes, System.Classes, System.SyncObjs, uCustomThread, Dialogs;

type
 TTestThread = class(TCustomThread) // TCustomThread ist die Unit aus Beitrag 2
 private
  {Private-Deklarationen}
 protected
  procedure Execute; override;
 end;

implementation

{TTestThread}

procedure TTestThread.Execute;
var
 res: TWaitResult;
begin
 while not Terminated do
  begin
   // Sleep(1000);
   res := FEvent.WaitFor(FInterval); // also z.B. 1000

   // An FEvent komme ich nicht dran. An FInterval natürlich auch nicht. Nur die Frage ist wieso.

   // if 1 = 2 then
   // viel zu tun
   // end;
   case res of
    wrSignaled:
     TThread.Synchronize(nil,
       procedure
      begin
       showmessage('Signaled');
      end);
    wrTimeout:
     ;
    wrAbandoned:
     Terminate;
    wrError: {Fehler loggen}
     ;
   end;
  end;
end;

end.

Du musst
executeTimed überschreiben.

Eigentlich sollte der Compiler meckern da Execute als final deklariert ist

Damit das mit dem Event auch klappt, habe ich folgende Zeile in der Hauptunit (Beitrag 2) eingefügt. Ansonsten kann ich Event in einer Ableitung nicht sehen.

markieren

Delphi-Quellcode:

public
 property Event: TEvent read FEvent write FEvent;

ExecuteTimed also. Ok. Ich habe währenddessen ein bisschen rumprobiert um zu sehen wie der Thread reagiert je nachdem was ich mache.
Mit dem Event-Property funktioniert dann auch das hier

zusammenfalten · markieren

Delphi-Quellcode:

procedure TTestThread.ExecuteTimed;
var
 res: TWaitResult;
begin
 while not Terminated do
  begin
   res := Event.WaitFor(Interval); // also z.B. 1000

   case res of
    wrSignaled:
     TThread.Synchronize(nil,
       procedure
      begin
       showmessage('Signaled'); // Wird beispielsweise aufgerufen, wenn ich außen <Thread-Instanz>.Terminate; ausführe
      end);
    wrTimeout:
     TThread.Synchronize(nil,
      procedure
      begin
       showmessage('Timeout'); // Wird immer aufgerufen, wenn oben das WaitFor vorbei ist AUßER es gab vorher wrSignaled, wrAbandoned oder wrError.
      end);
    wrAbandoned:
     Terminate;
    wrError: {Fehler loggen}
     ;
   end;
  end;

 TThread.Synchronize(nil,
  procedure
  begin
   showmessage('Thread Ende');
  end);
end;

Was genau wrSignaled macht habe ich aber noch nicht herausgefunden.

jetzt hast du 2 mal eine Schleife die auf Terminated wartet.
Im execute und im ExecuteTimed.
Vergiss doch einfach den Event im ExecuteTimed, oder noch besser versuche zu verstehen was Deine ThreadKlasse wirklich macht....

Ich denke ich habs jetzt raus.
Das while in override ExecuteTimed muss natürlich raus weil das TCustomThread.Execute; in einer Schleife ja auch immer ExecuteTimed aufruft.
Nun funktioniert auch Enabled richtig.

Zitat:

Vergiss doch einfach den Event im ExecuteTimed

Wie soll ich denn das Event vergessen. Braucht man das im eigenen Thread, also der Ableitung, im ExecuteTimed gar nicht?

Dann wird Beitrag 18 vermutlich falsch sein
http://www.delphipraxis.net/1390098-post18.html

Zitat:

Wie soll ich denn das Event vergessen. Braucht man das im eigenen Thread, also der Ableitung, im ExecuteTimed gar nicht?

Nein brauchst Du nicht, das ist ja der Witz and der Klasse.
Du machst eine Ableitung,
überschreibst ExecuteTimed und gut ist. Im alles andere kümmert sich die Thread-Klasse

Zitat:

Aufgeweckt wird der Thread entweder wenn TimeOut aufgetreten ist oder wenn mit SetEvent der Event gesetzt wird (extern oder ggf. im Destructor)

Von Außen kann man den Thread leider nur aufwecken, wenn man folgende Änderungen in der Unit vornimmt

markieren

Delphi-Quellcode:

public
 property Event: TEvent read FEvent write FEvent; // Damit man Event von Außen überhaupt sieht

Und in TCustomThread.Execute

markieren

Delphi-Quellcode:

// Aus
if FEvent.WaitFor(LInterval) = TWaitResult.wrTimeout then

// wird
if FEvent.WaitFor(LInterval) in [TWaitResult.wrTimeout, TWaitResult.wrSignaled] then

Nur bin ich mir bei der letzten Zeile nicht so sicher, ob das OK ist.

Von Außen kann man dann aufrufen TestThread.Event.SetEvent;

if FEvent.WaitFor(LInterval) in [TWaitResult.wrTimeout, TWaitResult.wrSignaled] then Das ist Ok, aber den Event ohne Setter und Getter sichtbar machen nicht.

Lass das weg und benutze im code doch einfach das Enabled Property, da wird der Event auch ausgelöst. (Threadsafe)