Irgendwie gefällt mir das auch alles nicht, wieso z.b. das ResetEvent vor DoWork? Ausserdem wird as FEvent zu spaet erzeugt.

wie wärs mit:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TSleepingThread = class(TThread)
  protected
    FEvent: TEvent;
    FBusy: Boolean;
    procedure Execute; override;
    procedure DoWork; virtual; abstract;
  public
    function WakeUp: Boolean;
    constructor Create(_Suspended: Boolean);
    destructor Destroy; override;
    property Busy: Boolean read FBusy;
  end;

  TTestThread = class(TSleepingThread)
  private
    FCountLoop: Integer;
  protected
    procedure DoWork; override;
    property CountLoop: Integer read FCountLoop;
  end;

{ TMyThread }

constructor TSleepingThread.Create(_Suspended: Boolean);
begin
  FEvent := TEvent.Create(nil, True, False, '');
  FBusy := False;
  inherited Create(_Suspended);
end;

destructor TSleepingThread.Destroy;
begin
  Terminate; // FTerminate setzen
  WakeUp; // Event setzen
  WaitFor; // warten bis der eigene Thered sich beendet hat
  FreeAndNil(FEvent);
  inherited;
end;

function TSleepingThread.WakeUp: Boolean;
begin
  Result := FBusy;
  if not Result then
    FEvent.SetEvent;
end;

procedure TSleepingThread.Execute;
begin
  while not Terminated do begin
    case FEvent.WaitFor(INFINITE) of
      wrSignaled: begin
          if not Terminated then begin
            FBusy := True;
            DoWork;
            FEvent.ResetEvent;
            FBusy := False;
          end;
        end;
      wrTimeout: ;

      wrError: begin
          ReturnValue := FEvent.LastError;
          Exit;
        end;

      wrAbandoned:
        Exit;
    end;
  end;
end;

{ TTestThread }

procedure TTestThread.DoWork;
var
  t: Cardinal;
begin
  t := GetTickCount;
  while GetTickCount - t < 2000 do
    Sleep(100);
  Inc(FCountLoop);
end;

procedure TForm28.OnTerminateThread(_Sender: Tobject);
begin
  caption := inttostr((_Sender as TTestThread).CountLoop);
end;

procedure TForm28.Button1Click(Sender: TObject);

var
  tt: TTestThread;
begin
// recht sinnloses beispiel da FreeAndNil immer auf Ende wartet aller arbeiten wartet
// und es somit "blockierend" aussieht
  tt := TTestThread.Create(False);
  try
    tt.OnTerminate := OnTerminateThread;
    if tt.WakeUp then begin
      // joa konnte ausgefuerht werden
    end;
    Sleep(10); // naja irgendwas im HauptThread zwischendurch
  finally
    FreeAndNil(tt);
  end;
end;

Edit: Ah Thread falsch aufgeweckt ;P
Edit2: Beispiel erweiter (u.a. busy usw.)

Hi brechi,

Das Terminate in den Destructor zu setzen gefällt mir auch.

Aber den geerebten Constructor kannst du auch am Anfang aufrufen. Das ist ein Märchen, dass bei TThread das inherited am Ende des Constructors sitzen muss. Der Thread wird eh erst in der überschriebenen Methode "AfterConstruction" gestartet (sofern createsuspended=false), also erst wenn der komplette Code des Constructors abgearbeitet ist.

Zitat von sirius:

Der Thread wird eh erst in der überschriebenen Methode "AfterConstruction" gestartet (sofern createsuspended=false), also erst wenn der komplette Code des Constructors abgearbeitet ist.

Für Delphi 5 scheint das aber nicht zu stimmen:

zusammenfalten · markieren

Delphi-Quellcode:

constructor TThread.Create(CreateSuspended: Boolean);
var
  Flags: DWORD;
begin
  inherited Create;
  AddThread;
  FSuspended := CreateSuspended;
  Flags := 0;
  if CreateSuspended then Flags := CREATE_SUSPENDED;
  FHandle := BeginThread(nil, 0, @ThreadProc, Pointer(Self), Flags, FThreadID); // <=====
end;

Also muss man wohl zuerst das Event erzeugen (oder man erzeugt es erst in Execute() und handelt sich dafür andere Probleme ein).

Zitat von brechi:

Irgendwie gefällt mir das auch alles nicht, wieso z.b. das ResetEvent vor DoWork?

Weil ja während DoWork noch abgearbeitet wird von Aussen ein neuer "WakeUp-Befehl" eintreffen könnte.
So richtig nützlich wird das Ganze erst, wenn man noch ein threadsicheren Fifo hinzunimmt, damit DoWork jedes Mal die richtigen Inputdaten bekommt.

Aber es scheint ja auch so schon schwierig genug einen TThread mit einem TSimpleEvent zu verheiraten.

Jetzt weiß ich auch wieder, warum ich nur noch die Kompatibilität bis D7 und bei aktuellen Projekten nur noch bis maximal D2006 gewährleiste

Zitat von shmia:

Für Delphi 5 scheint das aber nicht zu stimmen:

Daher kommt das immer. Ok in Delphi 7 wird im Constructor BeginThread immer CREATE_SUSPENDED aufgerufen und dann gibt es AfterConstruction:

markieren

Delphi-Quellcode:

procedure TThread.AfterConstruction;
begin
  if not FCreateSuspended then
    Resume;
end;

Ich habe den Konstruktor jetzt so geändert:

markieren

Delphi-Quellcode:

constructor TSleepingThread.Create(CreateSuspended: Boolean);
begin
   inherited Create(True);
   FEvent := TSimpleEvent.Create;
   if not CreateSuspended then
      Resume;
end;

Ausserdem gibt es noch einen 2. Thread in dem Demo um es einfache Datenübergabe zu zeigen.