Downloadlogik unter Firemonkey

[himitsu]

Ich hab aktuell eine Laderoutine die hat eine globale Liste (Tasks) über die sie sich absichert.
Kann auch für z.B. die selbe Anzeige-Komponente, während einer läd was anderes laden und paralell dem ersten Sagen, dass seine Arbeit nicht mehr benötigt wird
und alles ohne Warten und somit auch ohne Deadlocks für den Benutzer.

Jeder Thread/Task der gestartet wird trägt sich in eine Liste ein, und den von dem er gestartet wurde, bzw. an wen er sich am Ende wieder wenden will.
Wer fertig ist, trägt sich aus der Liste wieder aus, bzw. wird automatisch ausgetragen (vor allem der Besitzer/Starter).
https://www.delphipraxis.net/203408-...ml#post1457779

Spätestens am Ende schauen die Threads dann nochmal nach, ob sie noch arbeiten sollen und wenn doch, erst dann wenden sie sich an an den Aufrufer. (wenn nicht, dann beenden und es ist egal, ob der Aufrufer noch existiert und der gespeicherte Zeiger/Callback schon ungültig ist)


PS: in den NextGen-Compilern (Android/iOS) verhalten sich Komponenten wie Interfaces, also di gibst die Form frei, aber da du noch einen Objektzeiger oder Callback (mit einem Objektzeiger drin) hast, existiert die Komponente dann immernoch



Ist zwar aktuell nur im VCL/Windows im Einsatz, aber sollte überall laufen.

Delphi-Quellcode:

TBackgroundTasks.Start(Image1, TLoadImageThread.Create(Filename));

// oder
TBackgroundTasks.Start<string>(Image1, LoadImageProc, Filename);

procedure TIrgendwas.LoadImageProc(ID: TTaskID; Owner: TObject; Filename: string);
var
  xxx: TBitmap;
begin
  // laden
  xxx.LoadFromUndMachIrgendwas(Filename);

  TBackgroundTasks.Synchronize(procedure
    begin
      if not TBackgroundTasks.Check(ID) then  // Aufgabe ist abgelaufen
        Exit;

      // anzeigen
      Image1.Picture.Bitmap.Assigned(xxx);
    end);
end;

Gibt im Prinzip nur 3 Funktionen,
* Start = Ausgabe starten
* Stop = Ausgabe für Beendet erklären
* Check = Prüfen ob Aufgabe noch läuft (von außen), bzw. ob sie sich beenden soll (von innen)
denen man Threads oder Prozeduren, Methoden oder Anonyme geben kann, die dann im Hintergrund werkeln und die sich selbst zentral organisieren,
wobei Stop automatisch ausgelöst wird, wenn der Owner verschwindet. (über das Syncronize am Ende wird sichergestellt, dass zwischen der Check-Abfrage und der Anzeige nicht doch noch der Owner verschindet, da das alles im Hauptthread läuft)

Ansonsten fängst du selber an über globale oder gegenseitige Kreutreferenzen und eine Threadsichere Synchronisierung
jeweils beim Gegenüber die Referenz auf sich selbst zu entfernen, bzw. dem Anderen zu sagen dass es nun vorbei ist. und mit etwas Glück schaffst du es dass jeder auf den Anderen wartet und es hängen bleibt.
Drum hatte ich mir diese asynchrone Unterhaltung gebaut, die nur ganz kurz beim Zugriff auf die Liste gesperrt wird.

Wem das mit dem "über das Syncronize am Ende wird sichergestellt" nicht gefällt, der muß da noch ein Lock/Unlock veröffentlichen, um die Liste für länger zu sperren (sperren, checken, machen, entsperren), aber als Prevention, dass so niemand einen Deadlock einbauen kann, hatte ich es garnicht erst eingebaut.
Also externer Zugriff auf die zentrale CriticalSection, bzw. diesem TMonitor.
(Achtung: System.TMonitor, nicht Forms.TMonitor ... k.A. wer auf die kranke Idee kam und diese Benaumng blind aus'm .NET geklaut hat)

Zitat:

Delphi-Quellcode:

// Start
TBackgroundTasks.Start(Self, ...);

// Stopp
TBackgroundTasks.Stop(Self);

// Restart
TBackgroundTasks.Stop(Self);
TBackgroundTasks.Start(Self, ...);

// läuft noch?
running := TBackgroundTasks.Check(Self);

// Stopp über ID
ID := TBackgroundTasks.Start(OnwerOrNil, ...);
...
TBackgroundTasks.Stop(ID);

// Stopp über Klassenmethode (gleiches bei TThread-Zeiger)
TBackgroundTasks.Start(OnwerOrNil, ThreadMethod);
...
TBackgroundTasks.Stop(ThreadMethod);

// Funktion starten
TBackgroundTasks.Stop(Self);
TBackgroundTasks.Start(Self, ThreadProcedur, ...);

// Thread starten (Create mit Suspended=True und im TBackgroundTasks.Start wird Thread.Start aufgerufen)
TBackgroundTasks.Stop(Self);
TBackgroundTasks.Start(Self, TBeispielThread.Create(...));

TBackgroundTasks.Stop(Self);
Thread := TBeispielThread.Create(...);
TBackgroundTasks.Start(Self, Thread);

// Parameter (Start)
TBackgroundTasks.Start(OwnerOrNil, Thread);           // suspended erstellte TThread-Instanz
TBackgroundTasks.Start(OwnerOrNil, Thread, True);     // manuell aus TBackgroundTasks entfernen, wenn Thread beendet (wenn Thread.OnTerminate<>nil)
TBackgroundTasks.Start(OwnerOrNil, Proc);             // Klassenmethode, anonyme Methode oder Prozedur
TBackgroundTasks.Start<A>(OwnerOrNil, Proc, ParamA);  // ... mit Parameter
TBackgroundTasks.Start<A,B>(OwnerOrNil, Proc, ParamA, ParamB);
TaskID := TBackgroundTasks.Start...;                  // ID für Check/Stop

// Parameter (Check und Stop)
TBackgroundTasks.StopAll;            // ALLE Threads
TBackgroundTasks.Stop(Owner);        // irgendwas am Owner (Threads oder Prozeduren)
TBackgroundTasks.Stop(TaskID);       // bestimmte ID (Result der Start)
TBackgroundTasks.Stop(Thread);       // bestimmter Thread
TBackgroundTasks.Stop(Method);       // bestimmte Methode, auch mehrfach (nur Klassenmethoden, keine Prozeduren oder anonyme Methoden)
TBackgroundTasks.Stop<...>(Method);  // ...

// Beispiel-Prozedur (Alternativen als Kommentar)
TBackgroundTasks.Start(Self, Beispiel, {ParamA, ParamB});

procedure TIrgendwas.BeispielProc(ID: TTaskID; Owner: TObject; {ParamA, ParamB: TIrgendwas});
begin
  TThread.NameThreadForDebugging(AnsiString(Format('TBackgroundTasks:BeispielProc TaskID=%d', [TaskID])));  // falls nicht, wurde es vorher nur mit der TaskID bereits erledigt

  { berechnen }
  ...
  if not TBackgroundTasks.Check(ID) then
    Exit;
  ...

  //TThread.Synchronize(nil, procedure
  TBackgroundTasks.Synchronize(procedure
    begin
      if not TBackgroundTasks.Check(ID) then  // Aufgabe ist abgelaufen
        Exit;
      { anzeigen }
      ...
    end);
  //TBackgroundTasks.Synchronize(ID, SyncProc);  //procedure {TIrgendwas.}SyncProc(ID: TTaskID; Owner: TObject; Value: Pointer);
  //TBackgroundTasks.Synchronize(ID, SyncProc, Value);
end;

// Beispiel-Thread (Optionales und Alternativen als Kommentar)
TBackgroundTasks.Start(Self, TBeispielThread.Create{(ParamA, ParamB)});

type
  TBeispielThread = class(TTaskThread)  // es geht auch jede andere TThread-Klasse
  private
    //FParamA, FParamB: TIrgendwas;
    procedure SyncProc;
  protected
    procedure Execute; override;
  public
    constructor Create{(ParamA, ParamB: TIrgendwas)};
    destructor Destroy; override;
  end;

procedure TBeispielThread.SyncProc;
begin
  //if not TBackgroundTasks.Check(TaskID_or_Self) then
  if not TaskCheck then  // Aufgabe ist abgelaufen
    Exit;
  { anzeigen }
  ...
end;

procedure TBeispielThread.Execute;
begin
  inherited;  // oder TThread.NameThreadForDebugging(AnsiString(Format('TBeispielThread ID=%d ...', [TaskID])));

  { berechnen }
  ...
  //if not TBackgroundTasks.Check(TaskID_or_Self) then
  if not TaskCheck then  // Aufgabe ist abgelaufen
    Exit;
  ...

  Synchronize(SyncProc);
  {Synchronize(procedure
    begin
      //if not TBackgroundTasks.Check(TaskID_or_Self) then
      if not TaskCheck then  // Aufgabe ist abgelaufen
        Exit;
      { anzeigen }
      ...
    end);}
end;

constructor TBeispielThread.Create{(ParamA, ParamB: TIrgendwas)}
begin
  inherited Create;
  //FParamA := ParamA;
  //FParamB := ParamB:
end;

destructor TBeispielThread.Destroy;
begin
  //ParamA.Free;
  inherited;
end;

// mit TThread-Klasse, wo OnTerminate nicht überschreibbar ist (ICallStopOnTerminate=True)
TBackgroundTasks.Start(OwnerOrNil, TMyThread.Create, True);

procedure TMyThread.Execute;
begin
  TThread.NameThreadForDebugging(AnsiString(Format('TMyThread ID=%d ...', [TaskID])));
  try
    ...
  finally
    //TBackgroundTasks.Stop(TaskID_or_Self);
    TaskStop;  // Thread ist fertig (alternativ das TaskStop im Thread.OnTerminate aufrufen)
  end;
end;