 |
|||
| HSG |
|
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.
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.
lokal:
