Thread in DLL richtig freigeben

[Dalai]

Hallo Leute, ich benötige mal wieder euer Fachwissen. Basierend auf Sir Rufos Vorschlag hab ich einen Thread zusammengebaut. Nachfolgend die nach Tests sehr stark abgespeckte Variante.

Delphi-Quellcode:

type
  TSignatureVerificationThread2 = class(TThread)
  private
    FCS: TCriticalSection;
    FEvent: TEvent;
    FWorkList: TObjectList;
    function GetItem: TObject;
  protected
    procedure Execute; override;
    {$IFDEF USE_TERMINATEDSET}
    procedure TerminatedSet; override;
    {$ENDIF USE_TERMINATEDSET}
  public
    constructor Create;
    destructor Destroy; override;
    procedure WorkOnItem(const AItem: TObject);
  end;

implementation

{ TSignatureVerificationThread2 }

constructor TSignatureVerificationThread2.Create;
begin
//    FreeOnTerminate:= True;
    FCS:= TCriticalSection.Create;
    FEvent:= TEvent.Create(nil, False, False, '');
    FWorkList:= TObjectList.Create(True);
    inherited Create(False);
end;

destructor TSignatureVerificationThread2.Destroy;
begin
{$IFDEF USE_TERMINATEDSET}
{$ELSE}
    Terminate;
    FEvent.SetEvent;
{$ENDIF USE_TERMINATEDSET}
    inherited;
    FWorkList.Free;
    FEvent.Free;
    FCS.Free;
end;

{$IFDEF USE_TERMINATEDSET}
procedure TSignatureVerificationThread2.TerminatedSet;
begin
    inherited;
    FEvent.SetEvent;
end;
{$ENDIF USE_TERMINATEDSET}

function TSignatureVerificationThread2.GetItem: TObject;
begin
    FCS.Enter;
    try
        Result:= FWorkList.Extract(FWorkList.First);
        if (FWorkList.Count > 0) then
            FEvent.SetEvent;
    finally
        FCS.Leave;
    end;
end;

procedure TSignatureVerificationThread2.Execute;
begin
    while NOT Terminated do begin
        FEvent.WaitFor(INFINITE);
        if NOT Terminated then begin
        end;
    end;
end;

procedure TSignatureVerificationThread2.WorkOnItem(const AItem: TObject);
begin
   FCS.Enter;
   try
       FWorkList.Add(AItem);
       FEvent.SetEvent;
   finally
       FCS.Leave;
   end;
end;

Delphi-Quellcode:

library FooBar;

{$IFDEF VERIFY_IN_BACKGROUND_THREAD}
var Glob_SigThread: TSignatureVerificationThread2;
    {$ENDIF VERIFY_IN_BACKGROUND_THREAD}

[...]

procedure DllEntryPoint(dwReason: DWORD);
begin
[...]
DLL_PROCESS_DETACH:
            begin
              {$IFDEF VERIFY_IN_BACKGROUND_THREAD}
              if Assigned(Glob_SigThread) then begin
                  Glob_SigThread.Terminate;
//                  Glob_SigThread.WaitFor;
              end;
              FreeAndNil(Glob_SigThread);
              {$ENDIF VERIFY_IN_BACKGROUND_THREAD}
           end;
[...]
end;

Der hier gezeigte Thread macht ja eigentlich gar nichts, und trotzdem ist die Freigabe absolut unzuverlässig. Manchmal klappt es sauber, aber meist hängt die ganze Sache im Destruktor des Threads, konkret beim vererbten WaitFor, und lastet dabei einen Kern voll aus. Nun habe ich an mehreren Stellen im Internet gelesen, dass die Stelle DLL_PROCESS_DETACH zum Freigeben des Threads ungünstig bzw. zu spät ist. Kann mir jemand sagen, ob das zutrifft, und vielleicht noch eine Erklärung liefern, warum das so ist? Sind die Probleme also wirklich erwartbar?

Das Hostprogramm, in dem meine DLL geladen wird, stammt nicht von mir und ist als gegeben hinzunehmen. Es gibt im DLL-Interface des Hostprogramms keine Funktion, die vor dem Entladen der DLL gerufen werden könnte. Sollte das Freigeben an dieser Stelle tatsächlich ein Problem sein, weiß ich nicht so recht, wie es anders gehen sollte. Hat dazu jemand noch eine Idee?

Grüße
Dalai