Nicht gestarteter TThread wird nicht beendet - Verständnisproblem: Thread und Event

[TiGü]

Hallo Gemeinde,

ich habe gerade ein Brett vor dem Kopf und das Gefühl etwas ganz Wesentliches in Bezug auf Threads und Events nicht verstanden zu haben.

Wenn mich jemand in die richtige Richtung schubsen würde, wäre ich sehr dankbar.

Was habe ich vor?

Eine Anwendung soll aus einer DLL über ein COM-Interface-Objekt als Wrapper einen Thread starten.
Beim Instanziieren des COM-Interface-Objekts aus der DLL wird der Thread suspendiert erzeugt.

Dieser Thread soll nach dem Starten beim Ausführen ein Messgerät ständig abfragen bzw. pollen und zwar so schnell wie möglich (oder wie es die Hardware zulässt).

Die Host-Anwendung lässt sich super beenden, wenn der Thread gestartet wurde und sein Execute durchläuft.
Wenn ich aber das Programm beenden will, ohne das der Thread losläuft, dann hänge ich im System.Classes.TThread.Destroy fest.
Es wird die folgende While-Schleife nie verlassen:

Delphi-Quellcode:

destructor TThread.Destroy;
begin
  if (FThreadID <> 0) and not FFinished and not FExternalThread then
  begin
    Terminate;
    if FCreateSuspended or FSuspended then
      Resume;
...
    while not FStarted do
...
      Yield;  // Hier komme ich nicht raus!
    WaitFor;
  end;
...
end;

Mit der folgenden Testanwendung (auch als gezipptes XE7-Projekt im Anhang) wird mein Problem nachvollziehbar.
Das COM-Interface-Objekt wird im AfterConstruction des Hauptformulars erzeugt und erzeugt dann wiederrum intern den Thread.
Wenn die Anwendung beendet wird, ohne auf den Button geklickt zu haben, bleibt das Programm im Taskmanager mit Endlosschleife stehen.

Was mache ich falsch?
Muss ich das Problem ganz anderes angehen?
Ich bitte um Rat!

Delphi-Quellcode:

unit Main.View;

interface

uses
  System.SysUtils,
  System.Classes,
  Vcl.Controls,
  Vcl.Forms,
  Vcl.StdCtrls;

type
  IDataManager = interface
    ['{936641B4-4868-4EFB-8513-65FE4DF51397}']
    procedure StartDataGrapping; stdcall;
  end;

  TForm2 = class(TForm)
    btnStartDataGrapping : TButton;
    procedure btnStartDataGrappingClick(Sender : TObject);
  private
    FDataManager : IDataManager;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

const
  THREAD_PROBLEM_DLL = 'ThreadProblemDLL.dll';

function GetDataManager(out DataManager : IDataManager) : ByteBool; stdcall; external THREAD_PROBLEM_DLL;

var
  Form2 : TForm2;

implementation

{$R *.dfm}


procedure TForm2.AfterConstruction;
begin
  inherited;
  GetDataManager(FDataManager);
end;

procedure TForm2.BeforeDestruction;
begin
  inherited;
end;

procedure TForm2.btnStartDataGrappingClick(Sender : TObject);
begin
  if Assigned(FDataManager) then
  begin
    FDataManager.StartDataGrapping;
  end;
end;

end.

Delphi-Quellcode:

unit DLL.DataManager;

interface

uses
  System.SysUtils,
  System.Classes,
  DLL.Thread;

type
  IDataManager = interface
    ['{936641B4-4868-4EFB-8513-65FE4DF51397}']
    procedure StartDataGrapping; stdcall;
  end;

  TDataManager = class(TInterfacedObject, IDataManager)
  strict private
    FMyThread : TMyThread;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;

    procedure StartDataGrapping; stdcall;
  end;

function GetDataManager(out DataManager : IDataManager) : ByteBool; stdcall;

implementation

var
  _DataManager : IDataManager;

function GetDataManager(out DataManager : IDataManager) : ByteBool; stdcall;
begin
  if not Assigned(_DataManager) then
  begin
    _DataManager := TDataManager.Create;
  end;
  DataManager := _DataManager;
  Result := Assigned(DataManager);
end;

procedure TDataManager.AfterConstruction;
begin
  inherited;
  FMyThread := TMyThread.Create(True);
end;

procedure TDataManager.BeforeDestruction;
begin
  inherited;
  FMyThread.Free;
end;

procedure TDataManager.StartDataGrapping;
begin
  if Assigned(FMyThread) then
  begin
    if not FMyThread.Started then
    begin
      FMyThread.Start;
    end;
  end;
end;

end.

Delphi-Quellcode:

unit DLL.Thread;

interface

uses
  System.SysUtils,
  System.Classes,
  Winapi.Windows,
  System.SyncObjs;

type
  TLock = System.SyncObjs.TCriticalSection;

  TBaseThread = class(TThread)
  private
    FThreadName : string;
  protected
    FLock : TLock;
    FWaitEvent : TEvent;

    procedure Execute; override;
    procedure ProcessInternalTask; virtual; abstract;
    procedure TerminatedSet; override;
  public
    procedure LogToOutput(const Text : string);
    constructor Create(CreateSuspended : Boolean = True); overload;
    destructor Destroy; override;
  end;

  TMyThread = class(TBaseThread)
  strict private
    FData : UInt64;
  protected
    procedure ProcessInternalTask; override;
  end;

implementation

constructor TBaseThread.Create(CreateSuspended : Boolean = True);
begin
  inherited Create(CreateSuspended);
  FLock := TLock.Create;
  FWaitEvent := TEvent.Create;
  FThreadName := Self.ClassName + '-' + Self.ThreadID.ToString;
  NameThreadForDebugging(FThreadName, ThreadID);
end;

destructor TBaseThread.Destroy;
begin
  inherited;
  FWaitEvent.Free;
  FLock.Free;
end;

procedure TBaseThread.Execute;
begin
  inherited;
  while not Terminated do
  begin
    FWaitEvent.WaitFor(1);
    if not Terminated then
    begin
      ProcessInternalTask;
    end;
  end;
end;

procedure TBaseThread.LogToOutput(const Text : string);
begin
  OutputDebugString(PWideChar(Text));
end;

procedure TBaseThread.TerminatedSet;
begin
  inherited;
  FWaitEvent.SetEvent;
end;

procedure TMyThread.ProcessInternalTask;
begin
  try
    Inc(FData);
    if (FData mod 1000) = 0 then
      LogToOutput('FData say Hello! ' + FData.ToString);
  except
    on E : Exception do
      LogToOutput(E.ClassName + ': ' + E.Message);
  end;
end;

end.

[Der schöne Günther]

Ich habe einmal folgendes getan:

1. Dem
   Delphi-Quellcode:

   IDataManager

   einmal eine Methode
   Delphi-Quellcode:

   Dispose()

   hinzugefügt
2. Sie in
   Delphi-Quellcode:

   TDataManager

   mit
   Delphi-Quellcode:

   FreeAndNil(FMyThread)

   gefüllt
3. Im Destruktor der MainForm einmal
   Delphi-Quellcode:

   FDataManager.Dispose()

   gesagt.

Dann bekommt er es hin, den schlafenden Thread zu resumen damit dieser sich dann beenden kann. Warum das so ist habe ich allerdings auch noch nicht verstanden.

Ich sehe nur, dass TThread.Resume ResumeThread aus der WinApi aufruft und eben dieser Aufruf in "deinem" Fall 0 und in "meinem" 1 zurückgibt. Komisch.

Edit:
Ich sehe auch grade, der Aufrufstack der Dispose-Methode und des Destruktors deines TDataManager ist ein völlig anderer. Wahrscheinlich liegt das an der globalen Variable dass deren RefCount erst ziemlich spät auf Null fällt und zu dem Zeitpunkt hat die Host-Anwendung in ihrem Shutdown wahrscheinlich schon so komische Dinge gedreht dass man keine Threads mehr fortsetzen kann.

PPS: Ja, das scheint es zu sein.

[Uwe Raabe]

Zitat:

Zitat von Der schöne Günther (Beitrag 1292423)

Wahrscheinlich liegt das an der globalen Variable dass deren RefCount erst ziemlich spät auf Null fällt und zu dem Zeitpunkt hat die Host-Anwendung in ihrem Shutdown wahrscheinlich schon so komische Dinge gedreht dass man keine Threads mehr fortsetzen kann.

Globale Interface-Variablen sind m.E. ein No-Go. Mal unabhängig davon, daß globale Variablen an sich schon bedenklich sind.

[Der schöne Günther]

Ja. Ich würde mir einen Zähler einbauen und sagen "mehr als 100 Instanzen erlaube ich nicht". Falls das gewünscht ist. Mit so etwas läuft das Programm dann auch wie gewünscht.

[TiGü]

Zitat:

Zitat von Uwe Raabe (Beitrag 1292429)

Zitat:

Zitat von Der schöne Günther (Beitrag 1292423)

Wahrscheinlich liegt das an der globalen Variable dass deren RefCount erst ziemlich spät auf Null fällt und zu dem Zeitpunkt hat die Host-Anwendung in ihrem Shutdown wahrscheinlich schon so komische Dinge gedreht dass man keine Threads mehr fortsetzen kann.

Globale Interface-Variablen sind m.E. ein No-Go. Mal unabhängig davon, daß globale Variablen an sich schon bedenklich sind.

Daran habe ich gar nicht gedacht!
Meine Vermutung war, dass ich irgendetwas mit dem Event verkehrt gemacht habe.
Wenn ich die Factory-Funktion so umändere, dass die einzig lebende Instanz dann nur im Hauptformular existiert, dann geht es!
Vielen Dank!

Delphi-Quellcode:

implementation

//var
//  _DataManager : IDataManager;

function GetDataManager(out DataManager : IDataManager) : ByteBool; stdcall;
begin
//  if not Assigned(_DataManager) then
//  begin
//    _DataManager := TDataManager.Create;
//  end;
//  DataManager := _DataManager;

  DataManager := TDataManager.Create;
  Result := Assigned(DataManager);
end;

Ich hatte mir das ein bisschen von VCL.Direct2D abgeschaut.
Das scheint aber ein bisschen anderes zu funktionieren, verstehe den Trick mit dem InterlockedCompareExchangePointer noch nicht so ganz.

Delphi-Quellcode:

unit Vcl.Direct2D;
...
implementation
...
{ Singleton objects }

var
  SingletonD2DFactory: ID2D1Factory;

  function D2DFactory(factoryType: TD2D1FactoryType=D2D1_FACTORY_TYPE_SINGLE_THREADED;
  factoryOptions: PD2D1FactoryOptions=nil): ID2D1Factory;
var
  LD2DFactory: ID2D1Factory;
begin
  if SingletonD2DFactory = nil then
  begin
  D2D1CreateFactory(factoryType, IID_ID2D1Factory, factoryOptions, LD2DFactory);
  if InterlockedCompareExchangePointer(Pointer(SingletonD2DFactory), Pointer(LD2DFactory), nil) = nil then
    LD2DFactory._AddRef;
  end;
  Result := SingletonD2DFactory;
end;

[TiGü]

Wäre die Situation aus Clean Code Sicht eigentlich okay, wenn ich derartige Variablen als

Delphi-Quellcode:

strict private class var

deklariere oder ist das auch schon grenzwertig und nur verschlimmbesserte globale Variablen?

[Der schöne Günther]

Ich verstehe nicht, warum du dir deine Instanz überhaupt in der Dll merken willst. Wozu? Soll es nur eine (eine bestimmte Anzahl) gleichzeitig geben können? Dann mach doch einen Zähler.
Willst du ein Singleton? Dann merke es dir doch als Klassentyp (TDataManager), denn du weißt ja in der Dll die konkrete Klasse.

[TiGü]

Also für den "DataManager" in diesem Beispiel war das natürlich Quatsch.
Hier ist es wirlich besser die einzige lebende Instanz im Hauptprogramm zu halten.

Aber wie ist es bei der Verwaltung von Hardware-Ressourcen?
In meiner richtigen Problemstellung steuere und erhalte ich Messwerte von einer externen Hardware per PCI-Karte (http://www.adlinktech.com/PD/web/PD_detail.php?pid=20).

Hier habe ich mir eine Klasse als zentrale Verwaltungseinheit geschrieben (nennen wir sie CardManager), die erstmal nach dem Erzeugen (AfterConstruction) guckt, wieviele Karten es so gibt und welche Funktion sie erhalten sollen (abspeichern in einen Dictionary).
Das Suchen und Zuweisen von Funktionen soll natürlich nur einmal geschehen.

Eine abstrakte Factory-Klasse erhält eine

Delphi-Quellcode:

class var

auf diese CardManager-Klasse und kann von außen abgefragt werden, wenn auf die Ressourcen zugegriffen werden soll.

Hm, also ich tue mich einfach nur ein bisschen schwer eine vernünftige Struktur zu entwerfen, die wasserdicht und relativ zukunftsicher ist.
Du musst anscheinend in deiner beruflichen Problemstellung auch Werte von externen Messgeräten verarbeiten.
Wie handhabt ihr das so? Gibt es da irgendwelche empfehlenswerte Literatur/Websiten?

[Der schöne Günther]

Ganz verstanden habe ich es noch nicht. Der

Delphi-Quellcode:

CardManager

ist ein Singleton, richtig? Der kümmert sich einmalig um alle angeschlossenen Systeme ("soll natürlich nur einmal geschehen").

Und diese Instanz möchtest du als COM-Interface rausgeben. Sieht doch alles super aus finde ich.

Etwas off-Topic:
Eins habe ich anfangs auch immer gemacht, mittlerweile bereue ich es heftigst: Im Konstruktor eines Objekts anfangen, irgendwelche Dinge zu tun. Hier sogar Kommunikation starten, auswerten, was auch immer. Das ist einer der heftigsten Fehler den ich durchgehend getan habe.

Eine Zusammenfassung in ein paar Zeilen warum nicht liefert der Google C++ Styleguide: Link.
Auf Delphi trifft das natürlich genauso zu.

Wochenend-(Urlaub?)Lesestoff dazu: Link.

Ob du das nun im

Delphi-Quellcode:

constructor

oder im

Delphi-Quellcode:

AfterConstruction

machst ist kein Unterschied. Warum überhaupt

Delphi-Quellcode:

AfterConstruction

?

[TiGü]

Das mit dem Konstruktor muss ich mal in Ruhe durchdenken, dass mache ich nämlich häufig und könnte wirklich zu einem Problem werden.

Ich habe mein Anlegen in einen hoffentlich verständlichen Beispiel runtergetippt.
Leider ist es etwas länger geworden.

Im folgenden Konsolenprogramm geht es um einen Waschsalon.
Man kann von außen angeben, wieviele Waschmaschinen der Salon hat.

Die Hardware-Implementation einer einzelnen Waschmaschine soll für diese aber egal sein. Sie muss nicht wissen, wie und mit was sie kommuniziert.
Daher habe ich ein Interface

Delphi-Quellcode:

IHardwareAnsteuerung

als Field deklariert.
Im Beispiel ist die Hardwareansteuerung per PCI-Karte implementiert (

Delphi-Quellcode:

THardwareAnsteuerungPerPCI_Karte

), aber es sollen zukünftig noch andere Verfahren möglich sein (USB, Ethernet, Bluetooth, WLAN).
Am Ende geht es um Daten die zu der Waschmaschine hingehen ('Jetzt mal waschen') und Daten die abgefragt werden ('Wie lange ist denn noch?', 'Wie warm ist das Wasser?, 'Wo ist die rote Socke in der Trommel?').

Hier ist auch der Punkt mit der

Delphi-Quellcode:

class var

in der

Delphi-Quellcode:

THardwareAnsteuerungFactory

eingebaut.
Ob ich jetzt wirklich ein Singleton brauche ist fraglich...hm, mal am Wochenende drüber nachdenken!

Ist grundsätzlich meine Struktur tragbar?

Delphi-Quellcode:

program Waschsalon;

{$APPTYPE CONSOLE}

{$R *.res}


uses
  System.SysUtils,
  System.Classes,
  System.Math,
  System.Generics.Collections;

type
  TPCICardID = record
  private
    FBits : LongWord;
  public
    procedure SetBits(const Bits : LongWord);
    function GetBits : LongWord;
  end;



  IHardwareAnsteuerung = interface
    ['{C279C43A-E9E5-4E2D-96B5-A9CAD9E8A118}']
    procedure MachWaschen;
    procedure MachSchleudern;
    procedure MachRödeln;
  end;

  THardwareAnsteuerungPerPCI_Karte = class(TInterfacedObject, IHardwareAnsteuerung)
  private
    FPCICardID : TPCICardID;
  public
    constructor Create(const CardID : TPCICardID);
    procedure MachWaschen;
    procedure MachSchleudern;
    procedure MachRödeln;
  end;



  ICardManager = interface
    ['{6839D9A7-295A-4356-8B69-FD6BB1522280}']
    function GibSchonHerDieHardware : IHardwareAnsteuerung;
  end;

  TCardManager = class(TInterfacedObject, ICardManager)
  private
    FCard : TPCICardID;
  public
    procedure AfterConstruction; override;
    procedure InitializePCICard;
    function GibSchonHerDieHardware : IHardwareAnsteuerung;
  end;

  THardwareAnsteuerungFactory = class abstract
  strict private
    class var _CardManager : ICardManager;
  public
    class function GetHardwareAnsteuerung(out HardwareAnsteuerung : IHardwareAnsteuerung) : Boolean;
  end;



  IWaschmaschine = interface
    ['{79EA598A-4A88-4D0A-BC99-DDF28ECC95F3}']
    procedure Waschen;
    procedure Schleudern;
    procedure NurSoRumRödeln;
  end;

  TWaschmaschine = class(TInterfacedObject, IWaschmaschine)
  strict private
    class var FWaschmaschinenAnzahl : Integer;
  private
    FWaschmaschinenNummer : Integer;
    FHardwareansteuerung : IHardwareAnsteuerung;
  public
    constructor Create(const HardwareAnsteuerung : IHardwareAnsteuerung);
    procedure Waschen;
    procedure Schleudern;
    procedure NurSoRumRödeln;
    procedure AfterConstruction; override;
  end;



  IWaschsalon = interface
    ['{240F248A-E379-44B3-ADBA-B08B3DE26567}']
    function GibtWaschmaschineMitDerNummer(WaschmaschinenNummer : Integer) : IWaschmaschine;
  end;

  TWaschsalon = class(TInterfacedObject, IWaschsalon)
  private
    FWaschmaschinenAnzahl : Integer;
    FWaschmaschinenListe : TList<IWaschmaschine>;
    procedure FülleWaschmaschinenListe;
  public
    constructor Create(const WaschmaschinenAnzahl : Integer);
    function GibtWaschmaschineMitDerNummer(WaschmaschinenNummer : Integer) : IWaschmaschine;
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

  { TWaschmaschine }

procedure TWaschmaschine.AfterConstruction;
begin
  inherited;
  FWaschmaschinenNummer := FWaschmaschinenAnzahl;
  Inc(FWaschmaschinenAnzahl);
end;

constructor TWaschmaschine.Create(const HardwareAnsteuerung : IHardwareAnsteuerung);
begin
  FHardwareansteuerung := HardwareAnsteuerung;
end;

procedure TWaschmaschine.NurSoRumRödeln;
begin
  Writeln(FWaschmaschinenNummer.ToString + ' Rödeln!');
  FHardwareansteuerung.MachRödeln;
end;

procedure TWaschmaschine.Schleudern;
begin
  Writeln(FWaschmaschinenNummer.ToString + ' Schleudern!');
  FHardwareansteuerung.MachSchleudern;
end;

procedure TWaschmaschine.Waschen;
begin
  Writeln(FWaschmaschinenNummer.ToString + ' Waschen!');
  FHardwareansteuerung.MachWaschen;
end;


{ TWaschsalon }

procedure TWaschsalon.AfterConstruction;
begin
  inherited;
  FWaschmaschinenListe := TList<IWaschmaschine>.Create;

  FülleWaschmaschinenListe;
end;

procedure TWaschsalon.BeforeDestruction;
begin
  inherited;
  FWaschmaschinenListe.Free;
end;

constructor TWaschsalon.Create(const WaschmaschinenAnzahl : Integer);
begin
  FWaschmaschinenAnzahl := WaschmaschinenAnzahl;
end;

procedure TWaschsalon.FülleWaschmaschinenListe;
var
  LWaschmaschine : IWaschmaschine;
  I : Integer;
  LHardwareAnsteuerung : IHardwareAnsteuerung;
begin
  if THardwareAnsteuerungFactory.GetHardwareAnsteuerung(LHardwareAnsteuerung) then
  begin
    for I := 1 to FWaschmaschinenAnzahl do
    begin
      LWaschmaschine := TWaschmaschine.Create(LHardwareAnsteuerung);
      FWaschmaschinenListe.Add(LWaschmaschine);
    end;
  end;
end;

function TWaschsalon.GibtWaschmaschineMitDerNummer(WaschmaschinenNummer : Integer) : IWaschmaschine;
begin
  if InRange(WaschmaschinenNummer, 0, FWaschmaschinenListe.Count) then
  begin
    Result := FWaschmaschinenListe.Items[WaschmaschinenNummer];
  end;
end;

{ THardwareAnsteuerung }

constructor THardwareAnsteuerungPerPCI_Karte.Create(const CardID : TPCICardID);
begin
  FPCICardID := CardID;
end;

procedure THardwareAnsteuerungPerPCI_Karte.MachRödeln;
begin
  FPCICardID.SetBits($0123);
end;

procedure THardwareAnsteuerungPerPCI_Karte.MachSchleudern;
begin
  FPCICardID.SetBits($0456);
end;

procedure THardwareAnsteuerungPerPCI_Karte.MachWaschen;
begin
  FPCICardID.SetBits($0789);
end;

{ THardwareAnsteuerungFactory }

class function THardwareAnsteuerungFactory.GetHardwareAnsteuerung(out HardwareAnsteuerung : IHardwareAnsteuerung) : Boolean;
begin
  if not Assigned(_CardManager) then
  begin
    _CardManager := TCardManager.Create;
  end;

  HardwareAnsteuerung := _CardManager.GibSchonHerDieHardware;
  Result := Assigned(HardwareAnsteuerung);
end;

{ TCardManager }

procedure TCardManager.AfterConstruction;
begin
  InitializePCICard;
end;

function TCardManager.GibSchonHerDieHardware : IHardwareAnsteuerung;
begin
  Result := THardwareAnsteuerungPerPCI_Karte.Create(FCard);
end;

procedure TCardManager.InitializePCICard;
begin
  FCard.SetBits($01010101);
end;

{ TPCICardID }

function TPCICardID.GetBits : LongWord;
begin
  Result := FBits;
end;

procedure TPCICardID.SetBits(const Bits : LongWord);
begin
  FBits := FBits or Bits;
end;

procedure Main;
var
  LWaschsalon : IWaschsalon;
  LWaschmaschine : IWaschmaschine;
  WaschmaschinenAnzahl, I : Integer;
begin
  Writeln('Wieviele Waschmaschinen sind im Waschsalon?');
  Readln(WaschmaschinenAnzahl);

  LWaschsalon := TWaschsalon.Create(WaschmaschinenAnzahl);
  for I := 0 to WaschmaschinenAnzahl - 1 do
  begin
    LWaschmaschine := LWaschsalon.GibtWaschmaschineMitDerNummer(I);

    LWaschmaschine.Waschen;
    LWaschmaschine.NurSoRumRödeln;
    LWaschmaschine.Schleudern;
  end;
end;

begin
  try
    Main;
    Readln;
  except
    on E : Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

end.