vielen Dank für eure Geduld #Stahli und #hentschman. Ihr habt mir zurückliegend schon öfter mal geholfen.
Aktuell gebe ich auf, denn ich verstehe es einfach nicht.
Nun habe ich vor kurzer Zeit das aktuelle Buch von Marcu Cantu für mich übersetzt, gelesen und doch wohl wieder kaum was dazugelernt. Jedenfalls zeigt
es mir die aktuelle Praxis.
Ich bin so was von gefrustet wegen meiner Stümperei und werde wohl Delphi für einige Zeit oder auch länger in die Ecke werfen.

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.

Zitat:

Versuche mal an die Aufgabenstellung erst mal anders ranzugehen.

Ich würde auch diesen Quatsch mit DoIt weglassen. Geb den Dingern entweder richtige Namen oder lass die besser jetzt erstmal komplett weg.

Hallo zusammen,

ich habe mich seit gestern mal tiefer mit Threads beschäftigt und da kam das Beispiel von Stahli hier genau richtig.

Nun habe ich mal eine "Demo" erstellt, mit den 2 verschiedenen Varianten von Stahli und Haentschmann.
In meiner VM-Entwickler-Maschine laufen beide Thread-Varianten so wie erwartet. Man sieht wie das Label refresht wird und das Hochzählen der Zahlen anzeigt.
Auf meinem Haupt-PC läuft es nicht so wie ich es erwarten würde. Das Programm wird blockiert (evtl. selbes Problem wie bei KodeZwerg?), sobald das Programm den Fokus hat oder man mit der Maus nur über das Programm drüber gleitet. Wenn man ein anderes Programm in den Vordergrund holt, zeigt das Label wieder das Hochzählen an und die Blockade ist weg.
Ich hoffe, ich konnte ausdrücken was das Problem ist.

Hier die Hauptunit:

zusammenfalten · markieren

Delphi-Quellcode:

UNIT uMain;

INTERFACE

USES
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls;

TYPE
  TOnChangeEvent = PROCEDURE( Sender: TObject; MaxValue: Integer; CurrentValue: Integer ) OF OBJECT; { mein Event-Hanlder für den 2. Thread }

  Tfrm_Main = CLASS( TForm )
    Btn_Start_Thread1: TButton;
    CounterLabel1: TLabel;
    Btn_End_Thread1: TButton;
    Label1: TLabel;
    Bevel1: TBevel;
    Btn_Start_Thread2: TButton;
    Btn_End_Thread2: TButton;
    Counterlabel2: TLabel;
    PROCEDURE FormClose( Sender: TObject; VAR Action: TCloseAction );
    PROCEDURE Btn_Start_Thread1Click( Sender: TObject );
    PROCEDURE Btn_End_Thread1Click( Sender: TObject );
    PROCEDURE DoOnChange( Sender: TObject; MaxValue: Integer; CurrentValue: Integer );
    PROCEDURE Btn_Start_Thread2Click( Sender: TObject );
    PROCEDURE Btn_End_Thread2Click( Sender: TObject );
    PROCEDURE FormCreate( Sender: TObject );

  PRIVATE
    { Private-Deklarationen }

  PUBLIC
    { Public-Deklarationen }
  VAR
    gb_ist_Thread1_aktiv, gb_ist_Thread2_aktiv: Boolean;

  END;

VAR
  frm_Main: Tfrm_Main;

IMPLEMENTATION

{$R *.dfm}


USES
  uThread_mit_Erzeugung_Controls_fuer_Zugriff_auf_VCL_im_Hauptthread, uThread_mit_Businesslogic_kennt_somit_nicht_den_HauptThread;


{ mein Event-Handler von dem 2. Thread }
PROCEDURE Tfrm_Main.DoOnChange( Sender: TObject; MaxValue: Integer; CurrentValue: Integer );
BEGIN
  frm_Main.CounterLabel2.Caption := CurrentValue.ToString;
END;

PROCEDURE Tfrm_Main.FormCreate( Sender: TObject );
BEGIN
  gb_ist_Thread1_aktiv := False;
  gb_ist_Thread2_aktiv := False;
END;

PROCEDURE Tfrm_Main.Btn_Start_Thread1Click( Sender: TObject );
BEGIN
  Btn_Start_Thread1.Enabled := False;
  Btn_Start_Thread2.Enabled := False;
  Btn_End_Thread2.Enabled := False;

  FMy_Thread1 := TTheThread.Create( CounterLabel1 );
END;

PROCEDURE Tfrm_Main.Btn_End_Thread1Click( Sender: TObject );
BEGIN
  IF frm_Main.gb_ist_Thread1_aktiv THEN FMy_Thread1.Terminate;
  Btn_Start_Thread1.Enabled := True;
  Btn_End_Thread1.Enabled := True;
  Btn_Start_Thread2.Enabled := True;
  Btn_End_Thread2.Enabled := True;
END;

PROCEDURE Tfrm_Main.Btn_Start_Thread2Click( Sender: TObject );
BEGIN
  Btn_Start_Thread1.Enabled := False;
  Btn_End_Thread1.Enabled := False;
  Btn_Start_Thread2.Enabled := False;

  FMy_Thread2 := TTheThread2.Create;
  FMy_Thread2.OnChange := DoOnChange; { ! }
END;

PROCEDURE Tfrm_Main.Btn_End_Thread2Click( Sender: TObject );
BEGIN
  IF frm_Main.gb_ist_Thread2_aktiv THEN FMy_Thread2.Terminate;
  Btn_Start_Thread1.Enabled := True;
  Btn_End_Thread1.Enabled := True;
  Btn_Start_Thread2.Enabled := True;
  Btn_End_Thread2.Enabled := True;
END;

PROCEDURE Tfrm_Main.FormClose( Sender: TObject; VAR Action: TCloseAction );
BEGIN
  IF frm_Main.gb_ist_Thread1_aktiv THEN FMy_Thread1.Terminate;
  IF frm_Main.gb_ist_Thread2_aktiv THEN FMy_Thread2.Terminate;
END;

END.

Und hier die Unit eines der beiden Thread-Beispiele:

zusammenfalten · markieren

Delphi-Quellcode:

UNIT uThread_mit_Businesslogic_kennt_somit_nicht_den_HauptThread;

INTERFACE

USES
  Winapi.Windows, Winapi.Messages, System.Classes, System.SysUtils, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, uMain;

TYPE

  TTheThread2 = CLASS( TThread )
  PRIVATE
    FOnChange: TOnChangeEvent; { Event-Handler in uMain }
  PUBLIC
    PROPERTY OnChange: TOnChangeEvent READ FOnChange WRITE FOnChange;
    PROCEDURE Execute; OVERRIDE;
  END;

VAR
  FMy_Thread2: TTheThread2;

IMPLEMENTATION

PROCEDURE TTheThread2.Execute;
VAR
  I1, I2: Cardinal;
BEGIN
  I1 := 0;
  I2 := 0;
  TRY
    frm_Main.gb_ist_Thread2_aktiv := True;
    TRY
      WHILE ( NOT Terminated ) DO
      BEGIN
        Inc( I1 );
        IF ( I1 >= 1000 ) THEN
        BEGIN
          Inc( I2 );

          Synchronize(
            PROCEDURE
            BEGIN
              IF Assigned( FOnChange ) THEN
              BEGIN
                FOnChange( Self, I1, I2 ); // Beispiel
              END;
            END );

          I1 := 0;
          IF I2 > 4200000000 THEN I2 := 0; // wegen Gefahr eines Überlaufs wenn jemand mal den Thread laufen lässt...

          // ================================= !!! um Fehler zu testen im(!) Thread ===============================
          // I2 := I2 DIV I1;
        END;
      END;
    FINALLY
      frm_Main.gb_ist_Thread2_aktiv := False;
    END;
  EXCEPT
    /// Wird benötigt, weil eine Exception im(!) Thread diesen Thread beendet und eine Exception im Hauptthread nicht "angezeigt" werden kann
    ON E: Exception DO
    BEGIN
      Queue(
        PROCEDURE
        BEGIN
          MessageBox( Application.MainFormHandle, PChar( Exception.Classname + ' : ' + E.Message ), 'Thread-Error!', MB_OK OR MB_ICONERROR );
        END );
    END;
  END;
END;

END.

Ich würde mich freuen wenn dieses Mysterium aufgeklärt werden könnte.
Vielen Dank schon mal vorab!