Das wird schon.

Im MyThread.Execute muss in einem einzelnen Schritt oder in einer Schleife ein Problem gelöst werden.
Wenn Execute verlassen wird, ist der Thread fertig.

Währenddessen können andere Threads oder eben auch die VCL ihre eigenständigen Aufgaben erledigen.
Im Grunde ist jeder Thread ein eigenständiges Programm.

Die VCL-Anwendung ist das, was der Nutzer sieht. Da läuft auch eine Dauer-Schleife:
- FormularZeichnen,
- TastaturPrüfen,
- MausPrüfen,
- EreignisseAbarbeiten,
- GuckenObEinThreadEtwasTunMöchte, // dann dessen Code dazwischen schieben
- WennNichtProgrammendeSchleifeVonVorn

Man darf nicht zwischen verschiedenen Threads (auch die VCL ist ein Thread) untereinander auf Daten zugreifen. Deshalb müssen die Threads sich gegenseitig abstimmen und den eigenen Ablauf ggf. anhalten. Für die VCL funktioniert das mit Synchronize.

Ich würde da noch nicht aufgeben an Deiner Stelle. Ist normal, dass man etwas Zeit braucht.

#stahli Was meinst Du mit Deinem Hinweis "Im Create kannst Du ein Label übergeben und in fLabel speichern (Constructor entsprechend überschreiben)."
Damit kann ich nichts anfangen.

Setze ich den ganzen Prozess so wie bei mir geschrieben mit

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.StartThreadBtnClick(Sender: TObject);
var
  Thread: TheThread;
  I: integer;
begin
  try
    Thread := TheThread.Create(True);
    Thread.FreeOnTerminate := true;
    Thread.Start;
    Thread.ShutdownThread;
  except
    on E:Exception do
    begin
       MessageDlg(E.Message, mtError, [mbOK], -1);
    end;
  end;
end;

in Gang?

Schreibe ich die Thread-Class um in:

markieren

Delphi-Quellcode:

type
  TheThread = class(TThread)
  private
    fLabel : TLabel;
  public
    procedure Execute; override;
    property Labelcount : TLabel read FLabel write FLabel;
  end;

Ich bin weiterhin ratlos.
Das mit der Synchronisierung der einzelnen Threads glaube ich verstanden zu haben, doch wie es nun praktisch realisiert wird, da scheitert es.

Zitat von stahli:

Das wird schon.

Man darf nicht zwischen verschiedenen Threads (auch die VCL ist ein Thread) untereinander auf Daten zugreifen. Deshalb müssen die Threads sich gegenseitig abstimmen und den eigenen Ablauf ggf. anhalten. Für die VCL funktioniert das mit Synchronize.

Das ist, denke ich, der wichtigste Punkt. Das Problem ist u.a. vereinfacht folgendes:

Thread 1 liest aus einem Speicherbereich Daten aus (z.B. ein Array das in einem Objekt steckt), während Thread 2 gerade in genau diesem Array hinten Daten drin ändert und dort reinschreibt.
Am Ende hat Thread 1 halb alte und halb neue Daten gelesen, die in sich halt nicht zusammenpassen, und hat damit dann natürlich Rotz gelesen.

Wenn gerade kein anderer Thread in die Daten schreibt, dürfen aber natürlich beliebig viele Threads gleichzeitig lesen, denn die stören sich untereinander ja nicht.

Für diese Zugriffe gibt es (grundsätzlich, das hat erstmal nichts speziell mit Delphi zu tun) einige Methoden damit sich die Programmteile nicht in die Quere kommen. Das sind zum einen Locks, Mutexe, Semaphore und Monitore.

Für das obige Szenario kann z.B. ein Reader/Writer-Lock verwendet werden. Jeder Thread der gerade Lesen will, holt sich einen Reader-Lock, liest die Daten, und gibt den Reader-Lock wieder frei.
Reader-Locks können beliebig oft gehalten werden.
Ein Thread der Schreiben will, versucht sich einen Writer-Lock zu holen. Das geht nicht, weil es noch Reader-Locks gibt die gehalten werden. Der Thread der das probiert blockiert nun an dieser Stelle bis er den Writer-Lock erhalten kann. Das hat insbesondere zur Folge, das weitere Threads keinen neuen Reader-Lock mehr holen können und hier auch blockieren, bis das wieder geht.
Wenn alle Threads die gerade lesen ihre Reader-Locks zurück gegeben haben, dann gibt das Betriebssytem den Writer-Lock frei und der schreibende Thread darf weiterlaufen. Der bekommt also den Writer-Lock, jetzt ist sichergestellt das gerade keiner mehr liest, und darf seine Daten schreiben. Danach gibt er den Writer-Lock wieder frei. Das erlaubt im Umkehrschluss wieder allen anderen Threads die lesen wollen, ihren gewünschten Reader-Lock jetzt endlich bekommen zu können, und diese können auch weiterlaufen.

Wenn Du Dich mit Thread-Synchronisation auseinandersetzen willst, solltest Du vielleicht ein paar Artikel zu den Konzepten, insbesondere Mutex, Lock und Sempahor (beinhaltet meist schon Monitor) lesen (Wikipedia ist schon ganz okay-ish), und dann von dort aus weiter arbeiten.

Eine noch ganz wichtige Sache in Windows (bzw. nahezu jeder anderen UI-Technologie) ist, das nur genau ein einziger Thread auserkoren ist, UI-Elemente (Forms, Controls etc.) zu aktualisieren. Damit müssen dann andere Threads eben die Daten mittels mindestens einer der oben genannten Synchronisationsmethoden wohin schreiben, wo der UI-Thread dann lesen darf und am besten auch mitbekommt, das er diese Daten jetzt irgendwie anzeigen muss.

Das Synchronize in dem oben genannten Beispiel schreibt den Code (Update das Label mit diesem neuen Text) sozusagen als Daten auf den UI-Thread (im Prinzip schiebt er einen Zeiger auf den Code dorthin) und blockiert dann, bis der UI-Thread beim abarbeiten seiner Nachrichten diesen Zeiger liest, und den Code auf den der Zeiger zeigt selber ausführt (also das Label aktualisiert). Wenn der UI-Thread das gemacht hat, wird dem anderen Thread der auf das abarbeiten des Synchronize-Blcos wartet gesagt: Lauf weiter. Intern arbeitet das Synchronize auch mit nichts anderem als die oben genannten Mechanismen. Ist alles keine Magie Sobald Du die Konzepte verstanden hast macht das auf einmal alles Sinn

Geht noch einfacher...

zusammenfalten · markieren

Delphi-Quellcode:

type
  TheThread = class(TThread)
  private
    fLabel : TLabel;
  public
    constructor Create(aLabel: TLabel); overload;
    procedure Execute; override;
  end;

...

  constructor TTheThread.Create(aLabel: TLabel);
  begin
    fLabel := aLabel;
    inherited Create(False);
  end;

und wie bekomme ich den Prozess zum Laufen und zur Anzeige des Hochzählens bzw. der Synchronisation?
muß ich ggf. mit dem FormCreate arbeiten und das Label zur Anzeige bringen oder mit dem StartButton?
Noch passiert überhaupt nichts.
folgender Quelltext liegt nun vor:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TheThread = class(TThread)
  private
    fLabel : TLabel;
  public
    constructor Create(aLabel: TLabel); overload;
    procedure Execute; override;
  end;


type
  TForm1 = class(TForm)
  CounterLabel: TLabel;
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}


constructor TheThread.Create(aLabel: TLabel);
begin
  fLabel := aLabel;
    inherited Create(False);
end;

procedure TheThread.Execute;
 var
    I1, I2: Cardinal;
  begin
    I1 := 0;
    I2 := 0;
    try
      while (not Terminated) do
        begin
          Inc(I1);
          if (I1 >= 1000000) then
            begin
              Inc(I2);
              Synchronize(
                procedure
                  begin
                    FLabel.caption := I2.ToString;
                  end);
              I1 := 0;
            end;
        end;
    except
      raise;
// on e: exception do begin
// mache hier irgendetwas mit dem Fehler.
    end;
  end;

end.

Jetzt musst Du in Deinem Formular noch eine Variable vom Typ Deines Threads anlegen und dem Dein Label übergeben, wo er seine Ergebnisse darstellen soll.

Im Formular im Private-Abschnitt:
- fTheThread: TTheThread;

Im OnCreate:
- fTheThread := TTheThread.Create(CounterLabel);

Im OnClose:
- fTheThread.Terminate;

(Bei der Freigabe kann es sein, dass man erst noch auf die tatsächliche Beendigung warten muss und es sonst zu Konflikten kommen kann.)

so sieht das Ergebnis nun aus:

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,
  Vcl.WinXCtrls, System.UITypes, Vcl.ExtCtrls;

type
  TTheThread = class(TThread)
  private
    fLabel : TLabel;
  public
    constructor Create(aLabel: TLabel); overload;
    procedure Execute; override;
  end;


type
  TForm1 = class(TForm)
  CounterLabel: TLabel;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    { Private-Deklarationen }
    fTheThread: TTheThread;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}


constructor TTheThread.Create(aLabel: TLabel);
  begin
    fLabel := aLabel;
    inherited Create(False);
  end;

procedure TTheThread.Execute;
 var
    I1, I2: Cardinal;
  begin
    I1 := 0;
    I2 := 0;
    try
      while (not Terminated) do
        begin
          Inc(I1);
          if (I1 >= 1000) then
            begin
              Inc(I2);
              Synchronize(
                procedure
                  begin
                    FLabel.caption := I2.ToString;
                  end);
              I1 := 0;
            end;
        end;
    except
      raise;
// on e: exception do begin
// mache hier irgendetwas mit dem Fehler.
    end;
  end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
   fTheThread.Terminate;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  fTheThread := TTheThread.Create(CounterLabel);
end;
end.

Ich sehe also auf dem Formular das stets unterbrochene Hochzählen (also die Synchronisation zwischen I1 und I2)
Vielen vielen Dank für die Ausdauer mit mir Plinse.
Ich denke das war es also.

Freut mich!

Moin...

Zitat:

Im Create kannst Du ein Label übergeben

...keine gute Idee die Oberfläche mit Businesslogic zu mischen. Der Thread sollte die VCL nicht kennen!
Was passiert wenn das Label nicht mehr existiert? Bumm.

Damit ist auch gemeint, daß der Thread in eine separate Unit gehört und nicht in die Form Unit.

PS: Zum Testen/Lernen ist es OK.

Besser:
Der Thread hat ein Event. Dieses Event ist in der Oberfläche an einen Eventhandler gebunden. Der Thread gibt den Wert (was auch immer) über das Event an den Eventhander der Oberfläche weiter.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TOnChangeEvent = procedure(Sender: TObject; MaxValue: Integer; CurrentValue: Integer) of object;

  TTheThread = class(TThread)
  private
    FOnChange: TOnChangeEvent;
  public
    property OnChange: TOnChangeEvent read FOnChange write FOnChange;
    procedure Execute; override;
  end;

...
if (I1 >= 1000) then
begin
  Inc(I2);
  Synchronize(
    procedure
    begin
      if Assigned(FOnChange) then
      begin
        FOnChange(Self, I1, I2); //Beispiel
      end;
    end);
  I1 := 0;
end;
...
procedure TForm1.FormCreate(Sender: TObject);
begin
  FTheThread := TThread.Create;
  FTheThread.OnChange := DoOnChange;
end;
...
procedure TForm1.DoOnChange(Sender: TObject; MaxValue: Integer; CurrentValue: Integer);
begin
  CounterLabel.Caption := CurrentValue.ToString;
end;

Danke auch an #haentschman. Ich habe Deine früheren strengen Hinweise noch immer im Ohr - Trennung von Businesslogic und Form; nimm immer klar bezeichnete Variablen und
bennenne sie möglichst englisch usw. Habe Deine Hinweise stets befolgt.
Diese nun in zwei units aufgeteilte Modellanwendung funktioniert ebenso wie die von gestern. Vielen Dank für die Hilfe.
Noch eine kurze Frage habe ich: Wie würde man die Threads bezeichnen (Was ist der Hauptthread und was die Sub-Threads) oder ist das uniteressant?
Grüsse nach Seifhennersdorf - war unlängst in Johnsdorf und frohes Osterfest an alle hier!