Zitat von Dezipaitor:

Sowas?

Ähm...Das war meine erste Antwort

Dein Edit habe ich nicht mehr gelesen.

Hallo zusammen,

Danke euch allen für die Anregungen und auch die Diskussionen - das alles hat mir nicht nur für die eigentliche Umsetzung, sondern auch für das Wissen, warum ich das eigentlich tue, weitergeholfen.

Einen hab ich aber noch. Am Anfang hatte ich selbst noch eine Lösung vorgeschlagen, auf die niemand weiter eingegangen ist (wie gemein... ). Das war der Ansatz, in dem sich der Thread am Ende mit Suspend selbst Schlafen gelegt hat und dann von außen wieder durch einen Timer aufgeweckt wurde. Wenn man das mit den anderen Beiträgen hier vergleicht, ist das ja fast so eine Art Zwischending zwischen dem Vorschlag von sirius (und anderen) und Frederika. Ist an dem Ansatz etwas wirklich falsch? Ist ein Timer ineffektiver als ein WaitFor? Oder ist er einfach nur unschön oder ungewöhnlich?

Bis denn
Bommel

Hallo Sirius, hallo zusammen,

eine Nachfrage habe ich noch zu deinem Ansatz.

Zitat von sirius:

zusammenfalten · markieren

Delphi-Quellcode:

constructor Tmythread.Create(CreateSuspended: Boolean);
begin
  inherited Create(false); // <----- muss das wirklich "false" sein?
  FEvent:=TEvent.Create(nil,true,false,'');
end;

[...]

procedure Tmythread.execute;
begin
  while not terminated do
  begin
    DoSomething;
    FEvent.ResetEvent; // <----- ist das hier wirklich sinnvoll?
    FEvent.WaitFor(10000);
  end;
end;

Es geht mir um die markierten Stellen:

1. Create: Du rufst den Vorgänger immer mit "false" auf - machst du das, weil sonst die Gefahr besteht, dass das Execute schon losrennt, bevor das Create durch ist? Das heißt, wenn ich will, dass der Parameter noch weiter beachtet wird, müsste das Create vollständig so aussehen:

markieren

Delphi-Quellcode:

constructor Tmythread.Create(CreateSuspended: Boolean);
begin
  inherited Create(false);
  FEvent:=TEvent.Create(nil,true,false,'');

  if not CreateSuspended then
    Resume;
end;

Edit: Da hatte ich wohl Tomaten auf die Augens und true und false verwechselt - Die richtige Frage wäre also: Warum startest du den Thread IMMER als nicht-suspended?

2. ResetEvent: Ist das nicht eher störend? Das Event startet doch durch die Parameter bei Create eh als nicht gesetzt. Durch dieses Reset könnte doch nun folgendes passieren: Nehmen wir an, DoSomething dauert ein paar Sekunden (eben jene Datenbank-Abfrage beispielsweise) und während diese DoSomething läuft, wird der Thread terminiert und damit das Event gesetzt. Nach dem DoSomething wird es aber erst mal zurückgesetzt, was bedeutet, dass noch mal 10 Sekunden lang ein WaitFor aufgerufen wird, obwohl man das eigentlich gar nicht mehr braucht. Oder? Mein (sinnloser) Demo-Thread funktioniert jedenfalls auch ohne das Reset genau wie gewünscht.

Verzeiht meine vielen Nachfragen. Wie gesagt, ich bin halt noch neu im Thema Threads und möchte so gut wie möglich verstehen, was ich da tue, bevor ich das in Produktiv-Systeme einbaue.

Bis denn
Bommel

Suspend und Resume sollte man nicht verwenden (wird zwar intern von TThread verwendet, aber egal). Ist laut msdn auch nur für das Debuggen von Processen und Threads gedacht.

Zitat von msdn:

[SuspendThread]
This function is primarily designed for use by debuggers. It is not intended to be used for thread synchronization. ...

Das Waitfor bzw. die vernwednete Klasse TEvent, entspricht der Idee ein Ereignis zu setzen und mit Waitforsingleobject auf das Ereignis oder die verstrichene Zeit zu warten. TEvent kapselt die Funktionen der WinAPI (u.a. waitforsingleobject wird zur Methode TEvent.WaitFor)
Der Vorschlag mit dem Timer ist, dass du jedesmal einen neuen Thread und damit eine neue Verbindung aufbaust.

[roter Kasten] lese ich mir gleich durch


Edit: zum roten Kasten (letzter Beitrag)
Punkt 1. Jep das war falsch. das muss inherited Create(CreateSupended) hin. Der Thread wird so oder so fühestens erst nach dem Constructor gestartet.

Punkt 2. Hmm ja, müsste man nochmal genauer drüber nachdenken. bzw. wenn ich nochmal drüber nachdenke --> ja kann man streichen. Ich arbeite häufig mit mehreren Events, und da muss ich hin und wieder zurücksetzen.

Alles klar. Vielen Dank noch mal, jetzt kann es dann so langsam ans echte Projekt gehen.

Das Thema ist schon etwas älter aber ich habe es so gelöst:

markieren

Code:

constructor TBThread.Create;
begin
  inherited Create(true);
  FTerminateEvent := CreateEvent(nil, true, False, nil);
end;

destructor TBThread.Destroy;
begin
  SetEvent(FTerminateEvent);
  CloseHandle(FTerminateEvent);
  inherited;
end;

procedure TBThread.Execute;
begin
  while not Terminated do
  begin
      if WaitForSingleObject(FTerminateEvent, fcint) = WAIT_TIMEOUT then
    begin
      if not Terminated then
        DoSomething;
    end;
  end;
end;

procedure TBThread.TerminatedSet;
begin
  inherited;
  SetEvent(FTerminateEvent);
end;

fcint ist die Zeit die der Thread warten soll.
Und durch dass Event welches durch die überschriebene Methode TerminatedSet gesetzt wird wird das warten vorzeitig beendet.