Threadsafe einen Zähler herunterzählen

[bernhard_LA]

ich will mit dem Thread.Onterminate Event einen Zähler herunterzählen und dann diesen Wert in der UI ausgeben ....

Delphi-Quellcode:

procedure TThreadMainClass.ThreadTerminateInfo(Sender: TObject);
var
  FCriticalSection: TCriticalSection;

begin
  FCriticalSection := TCriticalSection.Create;
  try
    FCriticalSection.Enter;
    g_RunningThreads := g_RunningThreads - 1;
    
    memo1.lines.add (0, ' number of  still running threads' + IntToStr(g_RunningThreads));
    FCriticalSection.Leave;
  finally
    FCriticalSection.Free;
  end;

end;

procedure TRoutingClass.executeRouting;
var
    
  .......
  _Threads: array of TMyThread;
  _hArr: Array of THandle;
  rWait: Cardinal;
begin

  if g_threadCount > 1 then
  begin
    setlength(_Threads, g_threadCount);
    setlength(_hArr, g_threadCount);

    .......

    for i := 1 to g_threadCount do
    begin
            _Threads[i - 1] := TMyThread.Create( ....);
      _Threads[i - 1].FreeOnTerminate := true;

      _Threads[i - 1].OnTerminate := ThreadTerminateInfo;

      _Threads[i - 1].Start;

      _hArr[i - 1] := _Threads[i - 1].Handle;

    end;

    WaitForMultipleObjects(g_threadCount, Pointer(_hArr), true, INFINITE);

    //  hier bleibt mein Programm in einem DEADLOCK ? stehen  ohne
    //  Free On terminate hat es funktioniert  :-( 
    //

[geskill]

Du erstellst eine lokale CS, aber ich gehe davon aus, dass du etwas global (g_RunningThreads) vor mehreren Zugriffen schützen möchtest. Also entweder CS global deklarieren (so dass alle die gleiche CS-Instanz benutzen) oder einfach TInterlocked.Decrement(g_RunningThreads); benutzen

[himitsu]

Und für ältere Delphis die passende WinAPI InterlockedDecrement.

[jaenicke]

Im Profil steht ja XE8, da hast du ja die Parallel Programming Library. Da kannst du das über Tasks erledigen:
http://docwiki.embarcadero.com/RADSt...amming_Library
Dort kannst du auch Nachrichten schicken usw., so dass du das alles nicht selber nachprogrammieren musst.

[Blup]

Zitat:

Note: The method assigned to the OnTerminate event is executed in the context of the main thread rather than the context of the thread being terminated. This means you can access the user interface of your application safely without calling the Synchronize method.

Das heist der Hauptthread wartet noch im WaitForMultipleObjects(), OnTerminate soll aber bereits im Hauptthread ausgeführt werden.

[Sir Rufo]

Das Warten auf einen Thread im MainThread ist schon fast ein AntiPattern, da der Deadlock nur noch einen Schritt entfernt ist.

In Delphi gibt es von Haus aus - auch mit der neuen TPL nicht - keine vernünftig funktionierende Lösung für eine Task/Thread Completion Behandlung. Das muss man sich selber zusammenfummeln.

[bernhard_LA]

jeder Versuch etwas in die GUI auszugeben wird mit einem DEADLock bestraft ,
ohne GUI scheint alles prima abzu laufen

[Namenloser]

Klar gibt es einen Deadlock. Der Hauptthread (GUI-Thread) wartet mit WaitForMultipleObjects auf das Ende deines Worker-Threads, und der Worker-Thread wartet darauf, dass der Hauptthread die Synchronize-Message abarbeitet, was aber nie passiert, weil dazu ja erst der Worker-Thread terminieren muss.

[himitsu]

Aus diesem Grund macht TThread.WaitFor etwas, was man sonst besser nicht macht .. quasi ein Application.ProcessMessages;

Delphi-Quellcode:

{ This prevents a potential deadlock if the background thread
  does a SendMessage to the foreground thread }
if WaitResult = WAIT_OBJECT_0 + 2 then
  PeekMessage(Msg, 0, 0, 0, PM_NOREMOVE);