ich weiß nicht ob es hilft aber so erstelle ich threads meist über die API, hier nur grob dargestellt

zusammenfalten · markieren

Delphi-Quellcode:

var
  ThreadHandle,
  ThreadId: TThreadID


procedure ThreadProc;
begin
  // mach was, auch GUI könnte man hier updaten etc...

  // thread wird beendet
  ExitThread(0);
end;

procedure foobar;
begin
  // einen thread wartend initialisieren
  ThreadHandle := CreateThread(nil, LongWord(0), @ThreadProc, nil, CREATE_SUSPENDED, ThreadId);
  // priorität festlegen
  SetThreadPriority(ThreadHandle, THREAD_PRIORITY_ABOVE_NORMAL);

  // thread starten
  ResumeThread(ThreadHandle);


  // einen thread abschießen
  if ((ThreadHandle <> 0) and (ThreadHandle <> INVALID_HANDLE_VALUE)) then
  begin
    TerminateThread(ThreadHandle, 0);
    WaitForSingleObject(ThreadHandle, 50);
    if ((ThreadHandle <> 0) and (ThreadHandle <> INVALID_HANDLE_VALUE)) then
      CloseHandle(ThreadHandle);
  end;
end;

There used to be an example in old versions of Delphi, which helped me to get started with threads. Apparently it is still available from here:
https://gist.github.com/jpluimers/8a...2ce7aaa8d4a2ea

Is ja die deutsche Seite . Also obiges Beispiel hat mir geholfen, als ich mit Threads angefangen habe.

Auf jeden Fall sollte dir erst mal klar sein was Synchronize() überhaupt macht:
- der aufrufende Thread wird angehalten
- Wenn der Hauptthread irgendwann mal nichts zu tun hat wird die übergebene Methode vom Hautpthread aufgerufen und abgearbeitet. Während der Abarbeitung der Methode kann der Hauptthread natürlich nichts anderes machen.
- nachdem der Hauptthread die Methode beendet hat, wird auch der aufrufende Thread fortgesetzt

Die Frage ist doch auch, ob du dich in Threads einarbeiten und sie verstehen oder ob du ein Problem lösen möchtest, sprich: eine konkrete Aufgabe mit Threads schneller abarbeiten möchtest. Im zweiten Fall könntest du dir einfach die OTL (OmniThreadLibrary von Primož Gabrijelčič) anschauen. Auch sonst erfährst du in seinem Online-Buch und in den Beispielen auch einiges über die Architektur von Threads.

Zitat von Blup:

Auf jeden Fall sollte dir erst mal klar sein was Synchronize() überhaupt macht:
- der aufrufende Thread wird angehalten
- Wenn der Hauptthread irgendwann mal nichts zu tun hat wird die übergebene Methode vom Hautpthread aufgerufen und abgearbeitet. Während der Abarbeitung der Methode kann der Hauptthread natürlich nichts anderes machen.
- nachdem der Hauptthread die Methode beendet hat, wird auch der aufrufende Thread fortgesetzt

Ich bin mit deiner Formulierung etwas unglücklich - genauer gesagt die Wortwahl "wird angehalten" und "wird fortgesetzt". Das könnte missverstanden werden.
Der aufrufende Thread blockiert, bis der Hauptthread die Methode abgearbeitet hat und das signalisiert.

#Benmik: Es ist eher das erste. Ich will mich in das spannende Thema "Threads" einarbeiten und habe aktuell kein zu lösendes Problem, wofür ich Threads einsetzen sollte.
Es ist die Spannung, die entstehen soll, wenn eine "neue Tür" aufgestoßen wird und Erbauung erwartet wird. Noch klemmt bei mir diese Tür, doch ich werde die Beiträge
und meine bisherigen Versuche nochmals durchgehen, in der Hoffnung auf Eingebung.
Ich danke euch für die Hinweise.

Also dann eine übersichtliche Aufgabe:

Zähle in einem Thread Zähler1 von 0 - 1Mio.
Dann erhöhe einen zweiten Zähler Zähler2 um eins und setze Zähler1 auf null zurück.
Gib den aktuellen Stand von Zähler2 in einem Label auf einem Formular aus (synchronisiert).
Beende den Thread vor dem Beenden der Anwendung.

Verwende keinen Timer, kein Sleep und kein Processmessage!

Setze im Formular ein paar Controls ein, mit denen Du irgendetwas tun kannst.
Verschiebe das Formular und ändere die Größe, um zu sehen, ob das flüssig läuft.

Die Zwischenstände kannst Du ja hier als Zip hochladen, so dass man mal schauen kann, wo es evtl. nicht passt...

Hallo Strahli, hier mein Versuch Deine Aufgabenstgellung zu lösen. Sicher nicht das Gelbe vom Osterei.

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, Vcl.ExtCtrls;

type
  TheThread = class(TThread)
  private
    procedure DoIt;
  public
    procedure Execute; override;
  end;


type
  TForm1 = class(TForm)
  CounterLabel: TLabel;
  StartThreadBtn: TButton;
  btnclose: TButton;
  procedure btncloseClick(Sender: TObject);
    procedure StartThreadBtnClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TheThread.DoIt;
var Zaehler1, Zaehler2, erg1: Integer;
begin
  for Zaehler1 := 0 to 1000000 do
  erg1:=Zaehler1;

  Zaehler2:=1;
  Zaehler2 := Zaehler2 + 1;
  Zaehler1:=0;

  begin
    Form1.counterlabel.Caption := Zaehler2.tostring;
  end;
end;

procedure TheThread.Execute;
begin
  Synchronize(DoIt);
end;

procedure TForm1.btncloseClick(Sender: TObject);
begin
  Close;
end;

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;

end.