Delphi	Komponenten freie Komponenten Konsolenanwendungen Styleguide Ereignisse Threads Pfad: Startseite / Fächer / Informatik / Material / Delphi / Threads
Autor: mk 03.11.2007 12:23:57 27965	Threads

Was ist ein Thread?

• Multithreading - The Delphi Way. von Martin Harvey
• Multithreading - deutsches Tutorial
• Thread bei wikipedia

Einführungsbeispiel

Aufgabe

Ein Timer soll mit Hilfe eines Threads geschrieben werden, der nach Ablauf einer übergebenen Wartezeit piepst.

Lösungsplan

Es sind folgende Teilaufgaben zu lösen:

• Schreiben der Klasse 'TPiepsThread'
  • eigene 'Model'-Unit
  • erben von TThread
  • Konstruktor für automatische Freigabe nach Ablauf und für 'suspendierten' Beginn
  • Attribut dt : integer für die Wartezeit in ms, Set/Get dazu
  • Überschreiben der Methode execute, Verwendung von sleep(dauer) (sysUtils) und windows.beep(frequenz,dauer) (windows), der Parameter dauer ist vom Typ integer und gibt die Dauer in ms an, der Parameter frequenz ist vom Typ integer und gibt die Frequenz des Tons in Hertz an
• Einbinden der Klasse in die 'Control/View'-Unit und Benutzen von Objekten der Klasse

Lösung

Folgende 'Model'-Unit wurde mit UMLEd im Verein mit Delphi erzeugt. Dabei ist zu beachten, dass die Methode execute override gesetzt wird.

UNIT mTPiepsThread;

interface

//--------------------  ggf Uses-Liste anpassen !  --------------------
uses
  classes,  // für TThread
  sysUtils, // für sleep
  windows;  // für windows.beep

type
   TPiepsThread = CLASS(TThread)

     // weitere Attribute
     private
        dt : integer;

     // weitere Methoden
     protected
        procedure execute; override;
     public
        constructor create; virtual;
        procedure SetDt (pDt: integer); virtual;
        function GetDt : integer; virtual;

   end;

implementation

//+---------------------------------------------------------------------
//|         TPiepsThread: Methodendefinition
//+---------------------------------------------------------------------

//-------- execute (protected) -----------------------------------------
procedure TPiepsThread.execute;
begin
  sleep(dt);
  windows.beep(1000,500);
end;

//-------- create (public) ---------------------------------------------
constructor TPiepsThread.create;
begin
  inherited create(true); // CreateSuspended = true
  freeOnTerminate := true;
end;

//-------- SetDt (public) ----------------------------------------------
procedure TPiepsThread.SetDt (pDt: integer);
begin
  dt := pDt;
end;

//-------- GetDt (public) ----------------------------------------------
function TPiepsThread.GetDt : integer;
begin
  result := dt;
end;

end.

Es folgt die zugehörige GUI-Unit:

unit uPiepsThread;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, mtPiepsThread;

type
  TForm1 = class(TForm)
    eDt: TEdit; lDd: TLabel; bLos: TButton;
    procedure bLosClick(Sender: TObject);
  private
    Pieps : TPiepsThread;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.bLosClick(Sender: TObject);
begin
  Pieps := TPiepsThread.create;
  Pieps.SetDt(StrToInt(eDt.Text));
  Pieps.Resume;
end;

end.

PiepsThread.zip

Beispiel 2

Das Beispiel zeigt - aufbauend auf dem ersten Beispiel - wie ein Thread in einer Dauer-Schleife arbeiten kann und wie man ihn beenden kann. Über ein wechselseitiges Sperren der Buttons in der GUI kann man ein mehrmaliges Erzeugen des Threads verhindern. Warum ist das wichtig?

Model-Unit:

UNIT mTPiepsThreadBeende;

interface

//--------------------  ggf Uses-Liste anpassen !  --------------------
uses
  classes,  // für TThread
  sysUtils, // für sleep
  windows;  // für windows.beep

type
   TPiepsThreadBeende = CLASS(TThread)

     // weitere Attribute
     private

     // weitere Methoden
     protected
        procedure execute; override;
     public
        constructor create; virtual;
   end;

implementation

//+---------------------------------------------------------------------
//|         TPiepsThread: Methodendefinition
//+---------------------------------------------------------------------

//-------- execute (protected) -----------------------------------------
procedure TPiepsThreadBeende.execute;
begin
  while not Terminated do;
  windows.beep(1000,500);
end;

//-------- create (public) ---------------------------------------------
constructor TPiepsThreadBeende.create;
begin
  inherited create(true); // CreateSuspended = true
  freeOnTerminate := true;
end;

end.

GUI-Unit:

unit uPiepsThreadBeende;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, mtPiepsThreadBeende;

type
  TForm1 = class(TForm)
    bStart: TButton;
    bEnde: TButton;
    procedure bStartClick(Sender: TObject);
    procedure bEndeClick(Sender: TObject);
  private
    Pieps : TPiepsThreadBeende;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.bStartClick(Sender: TObject);
begin
  bStart.Enabled := false; bEnde.Enabled := true;
  Pieps := TPiepsThreadBeende.create;
  Pieps.Resume;
end;

procedure TForm1.bEndeClick(Sender: TObject);
begin
  bStart.Enabled := true; bEnde.Enabled := false;
  Pieps.Terminate;
end;

end.

PiepsThreadBeende.zip

lokal: