Thread initialisieren

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Thread-Objekte definieren - Index

Wenn Sie Initialisierungscode für die neue Thread-Klasse schreiben möchten, müssen Sie die Methode Create überschreiben. Fügen Sie der Deklaration Ihrer Thread-Klasse einen neuen Konstruktor hinzu und definieren Sie den Initialisierungscode zu dessen Implementierung. Hier können Sie dem Thread eine Standard-Priorität zuordnen und festlegen, ob er automatisch freigegeben werden soll, wenn er seine Ausführung beendet.

Eine Standard-Priorität zuweisen

Die Priorität ist maßgebend für den Anteil der CPU-Zeit, die dem Thread vom Betriebssystem zugeordnet wird. Verwenden Sie Threads mit hoher Priorität zur Ausführung zeitkritischer Aufgaben und Threads mit niedriger Priorität für andere Aufgaben. Zur Festlegung der Priorität dient die Eigenschaft Priority.

Die Werte dieser Eigenschaft liegen (bei reinen Windows-Anwendungen) auf einer siebenstufigen Skala, wie die folgende Tabelle zeigt.

Prioritätsstufen für Threads:



Wert Priorität

tpIdle

Der Thread wird nur dann ausgeführt, wenn sich das System im Leerlauf befindet. Windows unterbricht niemals einen anderen Thread zugunsten eines Threads mit der Prioritätsstufe tpIdle.

tpLowest

Die Priorität des Threads liegt zwei Stufen unter der normalen Ebene.

tpLower

Die Priorität des Threads liegt eine Stufe unter der normalen Ebene.

tpNormal

Der Thread besitzt normale Priorität.

tpHigher

Die Priorität des Threads liegt eine Stufe über der normalen Ebene.

tpHighest

Die Priorität des Threads liegt zwei Stufen über der normalen Ebene.

tpTimeCritical

Der Thread besitzt höchste Priorität.


Warnung:  Wenn eine rechenintensive Operation hohe Priorität erhält, kann dies die Ausführung der anderen Threads in der Anwendung blockieren. Es sollten nur solche Threads höchste Prioritätsstufen erhalten, die den Großteil der Zeit auf externe Ereignisse warten.

Der folgende Quelltext zeigt den Konstruktor eines Threads mit niedriger Priorität, der im Hintergrund Verarbeitungsschritte ausführen soll, ohne die Leistung der übrigen Anwendung zu vermindern:



 constructor TMyThread.Create(CreateSuspended: Boolean);
 begin
   inherited Create(CreateSuspended);
 Priority := tpIdle;
 end;



 //---------------------------------------------------------------------------
 __fastcall TMyThread::TMyThread(bool CreateSuspended): TThread(CreateSuspended)
 {
 Priority = tpIdle;
 }
 //---------------------------------------------------------------------------



Den Freigabezeitpunkt von Threads festlegen

Wenn die Ausführung eines Threads abgeschlossen ist, kann er normalerweise freigegeben werden. In diesem Fall ist es am einfachsten, die Freigabe dem Thread-Objekt selbst zu überlassen. Dazu setzen Sie einfach die Eigenschaft FreeOnTerminate auf True.

Es gibt jedoch Situationen, in denen die Beendigung eines Threads mit anderen Threads koordiniert werden muss. Das ist beispielsweise der Fall, wenn mit der Ausführung eines Threads gewartet werden muss, bis ein anderer Thread einen bestimmten Ergebniswert geliefert hat. Dann darf der erste Thread erst freigegeben werden, wenn der zweite den betreffenden Wert übernommen hat. Zu diesem Zweck setzen Sie FreeOnTerminate auf False und nehmen dann eine explizite Freigabe des ersten Threads vor.

Siehe auch