System.Threading: Kann man einen Task / Threadpool beenden?

[Der schöne Günther]

Zitat:

Zitat von Dejan Vu (Beitrag 1286653)

Das wäre fein. Und kein Problem. Schreibe einfach einen Wrapper um die Win-API die [...]

Habe ich auch schon längst :thumb:

Ich wollte ja nur wissen "Kann System.Threading den bestehenden Kram ersetzen?". Die Antwort war nein. :spin2:

[Der schöne Günther]

Ich bin aber ehrlich gesagt immer noch nicht ganz zufrieden mit der Sache. Folgendes Beispiel, einmal ein Piep-Thread, und ein Piep-Task.

Delphi-Quellcode:

unit Unit3;

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

type
  TForm3 = class(TForm)
   startTaskButton: TButton;
   startThreadButton: TButton;
   procedure startTaskButtonClick(Sender: TObject);
   procedure startThreadButtonClick(Sender: TObject);
  end;

var
  Form3: TForm3;

implementation uses System.Threading, System.SysUtils;

{$R *.dfm}

procedure proc();
const
   maxCount = 10;
var
   count: Integer;
begin
   count := 0;
   repeat
      Beep();
      Inc(count);
      Sleep(500);
   until (count = maxCount);
end;

procedure TForm3.startTaskButtonClick(Sender: TObject);
begin
   TTask.Run(proc);
end;

procedure TForm3.startThreadButtonClick(Sender: TObject);
begin
   TThread.CreateAnonymousThread(proc).Start();
end;

end.

Einmal Button drücken, dann Anwendung beenden. Der Thread wird durch

Delphi-Quellcode:

Halt

vernünftig vorzeitig beendet. Der Task arbeitet seine zehn Piepser immer ab.

Ausprobiert mit XE7. Ist das mit 10 Seattle immer noch so? Ich finde das ehrlich gesagt gruselig.

[Sir Rufo]

Ist so ... Emba hat das Abbrechen von Tasks nicht so richtig auf dem Schirm gehabt.

Generell musst du für einen abbrechbaren Task den Abbruch aber auch selber behandeln. Der anonyme Thread wird einfach so beendet, was auch nicht die feine englische Art ist :stupid:

[Der schöne Günther]

Natürlich sollte ich das. Mich ärgert halt ziemlich dass, sollte ich in einem Task einen dummen Fehler machen, er nie terminiert, man die Anwendung nur noch über den Taskmanager abschießen kann.

In System.Threading.pas steht sogar

Delphi-Quellcode:

// Check each thread to see if it is already marked for termination and/or if it is hung.

, aber geprüft wird da gar nichts. Einfach Destroy() auf allen Threads aufrufen, nur leider steht da

Delphi-Quellcode:

destructor TThreadPool.TBaseWorkerThread.Destroy;
begin
  if FRunningEvent <> nil then
    FRunningEvent.WaitFor(INFINITE); // This waits for the Execute to actually be called.

Im Endeffekt läuft es darauf hinaus, dass ich mich nicht traue System.Threading zu verwenden und weiterhin mir selbst immer Threads zusammenfummeln werde. Echt schade.

[himitsu]

Destroy setzt auch Terminated auf True und genau das mußt du auch prüfen, in deinen Threads.
Bei Anonymen Threads kann man sich das Threadobjekt holen

Delphi-Quellcode:

if TThread.CurrentIrengwas.Terminated then raus;

.

[Der schöne Günther]

Ja, in einem Task kann ich prüfen ob der "Current" Thread nicht eigentlich beendet werden soll

Delphi-Quellcode:

procedure proc();
begin
   repeat
      Beep();
      TTask.CurrentTask.CheckCanceled(); // Bringt nichts
      if TThread.Current.CheckTerminated() then Break; //Das hier bringt's
      Sleep(500);
   until False;
end;

Wie gesagt, mir geht es aber um den Fall dass im Code ein dummer Fehler ist dass er nie terminiert. Ein Deadlock, sonst was. Benutze ich die Task-Library, wird sich die Anwendung niemals beenden.

[himitsu]

Threads/Tasks dürfen sich IMMER nur selber "definiert" beenden/anhalten.

Einfaches Beispiel: Der Thread macht grade beim Speichermanager eine Anfrage oder spielt mit Strings/Arrays rum ... wenn dabei der Thread extern beendet wird, kann das komplette Programm (alle Threads) blockieren.