Simulation mechatronischer Systeme 2

Transkript

1 Simulation mechatronischer Systeme 2 Prof. Dr.-Ing. habil. G.P. Ostermeyer, Institut für Dynamik und Schwingungen, Technische Universität Braunschweig,2010 Die Windows API Threads mit der Windows API erzeugen Threads mit dem Borland C++ Builder Zusammenfassung Borland Thread-Objekte PLAN und Threads

2 Die Windows API Der Ausdruck API (Application Programming Interface) bezeichnet die Programmierschnittstelle, die Applikationen unter Windows zur Verfügung steht. Um darauf zuzugreifen, muss man die Datei <Windows.h> mittels #include in den Quellcode einbeziehen. Danach stehen viele Datentypen und Funktionen des Betriebssystems zur Verfügung. Für einige dieser Funktionen müssen noch zusätzlich Libraries hinzugefügt werden. Da von verschiedenen Programmiersprachen und Compilern aus ein Zugriff auf die Windows API möglich sein soll, hat diese eigene Datentypen definiert, die der Anwender dann in seiner speziellen Programmierumgebung benutzen muss. Windows Datentypen sind meistens groß geschrieben. Hier einige Beispiele, deren Pendant in C++ und Typenerklärung Windows Datentyp C++ Datentyp Bedeutung LONG long Ganzzahlig, 32bit, Wertebereich negativ und positiv DWORD unsigned long Double Word, 32bit, nur positive Werte HANDLE void* Ein HANDLE wird verwendet um auf ein Betriebssystem- Objekt zuzugreifen LPCTSTR const char* Zeiger auf einen nullterminierten C-String LPVOID void* LP steht im Allgemeinen für Long-Pointer Betriebssystemobjekte Datenstrukturen, die intern vom Betriebssystem gebraucht werden, z.b für die Bildschirmausgabe oder das Dateihandling werden als Betriebssystemobjekte bezeichnet. Ein Bildschirmfenster oder eine Datei sind solche Betriebssystem-Objekte. Auf diese Betriebssystem-Objekte wird über den Datentyp HANDLE zugegriffen. Für die meisten Betriebssystem-Objekte gibt es Create-Funktionen, die als Rückgabewert ein solches HANDLE liefern. Die HANDLES werden, nachdem sie nicht mehr gebraucht werden, mit der API-Funktion CloseHandle wieder zerstört und freigegeben. Auch die im nächsten Kapitel beschriebenen Threads sind Betriebssystem-Objekte.

3 Threads mit der Windows-API erzeugen Ein Thread wird verwendet um mehrere Dinge in einem Programm parallel ablaufen zu lassen. Normalerweise startet unser Programm in einer main-funktion und wird von dort aus schrittweise abgearbeitet, Eingriffe von außen sind praktisch nicht möglich. Ein Beispiel ist das Lesen von einer Schnittstelle, wie der seriellen Schnittstelle. Solange das Programm auf Daten wartet, die Schnittstelle aber nicht sendet, bleibt der Aufruf hängen. Um das zu verhindern, bietet Windows dem Programmierer die Möglichkeit parallele Verarbeitungsstränge, so genannte Threads zu erzeugen. Dazu muss dem Betriebssystem eigentlich nur mitgeteilt werden welche Eintrittsfunktion durch den neu erzeugten Thread aufgerufen wird. Diese Funktion ist wie eine Art zweite main-funktion zu sehen. Damit das Betriebssystem eine Funktion als weitere main-funktion identifizieren kann, muss diese folgende Form haben: DWORD WINAPI ThreadFunktion(LPVOID param); Der Typ der Funktion ist DWORD, d.h. sie liefert einen Rückgabewert. WINAPI bezeichnet die Aufrufkonvention, das heißt die Art wie der Compiler Argumente und Rückgabewerte behandelt. Das Argument ist ein neutraler Zeiger mit dem wir der Funktion ein selbst gewähltes Argument übergeben können. Die Funktion selbst kann einen beliebigen Namen haben. Diesen Namen müssen wir einer weiteren API-Funktion namens CreateThread übergeben. Der Aufruf von CreateThread Die CreateThread-API hat wie viele Funktionen jede Menge Parameter, wobei wir bei den meisten die default Werte übernehmen können HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpthreadattributes, SIZE_T dwstacksize, LPTHREAD_START_ROUTINE lpstartaddress, LPVOID lpparameter, DWORD dwcreationflags, LPDWORD lpthreadid); Das erste Argument ermöglicht es einen Thread als ein bestimmter Benutzer oder mit bestimmten Benutzerrechten auszuführen. Mit 0 als Argument, wird der Defaultwert, d.h. der aktuelle Benutzer gewählt. Zweites Argument ist die Stack-Größe. Jeder Thread hat einen eigenen Stack, auf dem lokale Variablen erzeugt werden! Wenn wir hier eine 0 einsetzen wird eine default - Größe gewählt. Der dritte Parameter ist die Thread-Funktion, die ausgeführt werden soll (s.o.). Der lpparameter ist ein void*-zeiger. Er wird der Thread- Funktion als Argument übergeben. Über den zweitletzten Parameter, den Creation-Flag Parameter ist es möglich, zu steuern wie der Thread erzeugt wird. Z.B. den Thread zu erzeugen aber nicht sofort zu starten. Der letzte Parameter ist ein Zeiger auf eine Variable vom Datentyp DWORD. Das Betriebssystem füllt diesen Wert mit der so genannten ThreadId. Die ThreadId dient ähnlich wie der Funktionsrückgabewert vom Typ HANDLE zur Identifikation des Threads.

4 Hier ein erstes Beispiel: #include <windows.h> DWORD WINAPI MeineThreadFunktion(LPVOID param){ // vorläufig leer return 0; int main(){ DWORD threadid = 0; HANDLE MeinthreadHANDLE = CreateThread(0,0, MeineThreadFunktion,0,0, &threadid); return 0; Dieses Beispiel wird nichts Sinnvolles (die Thread Funktion ist leer) machen, es zeigt lediglich die Verwendung der CreateThread-API Funktion. Synchronisierung von Threads Die Synchronisierung zwischen Threads ist dann nötig, wenn Threads Daten miteinander austauschen oder sonst miteinander in Kontakt treten. Die erste Art der Synchronisierung ist das Warten des Hauptthread auf die Beendigung des zweiten. So wird sichergestellt, dass vor dem Beenden der main-funktion alle erzeugten Threads gelöscht wurden. Passiert das nicht werden diese durch den Hauptthread automatisch beendet, ohne nötige interne Aufräumarbeiten zu erledigen. Wichtig ist eine Synchronisation auch dann, wenn Threads auf die gleichen Variablen oder Methoden zugreifen. Ein Beispiel wäre die parallele Ausgabe auf den Bildschirm. Je nachdem welcher Threads gerade dran ist werden die Ausgaben bunt gemischt! Eine Steuerungsmöglichkeit ist, mit einer Betriebssystem-Funktion auf bestimmte Signale von HANDLES zu warten. HANDLES von Threads werden z.b. signalisiert, wenn der zugehörige Thread beendet wurde! Die API-Funktion zum Warten auf Signale heißt : DWORD WaitForSingleObject(HANDLE handle, DWORD timeout); Das erste Argument ist das HANDLE auf das gewartet werden soll, das zweite Argument gibt an wie viele Millisekunden gewartet werden soll. Es gibt aber auch die vordefinierte Konstante INFI- NITE mit der man unbegrenzt warten kann. Der Rückgabewert ist eine vordefinierte Konstante, welche angibt wieso die Wartefunktion beendet wurde. Tabellen dieser vordefinierten Konstanten findet man z.b. in der windows.h. Einerseits könnte das HANDLE ausglöst sein, andererseits könnte die timeout Zeit abgelaufen sein.

5 Beispiel Warten auf Thread-Beendigung : #include <windows.h> DWORD WINAPI MeineThreadFunktion(LPVOID param){ return 0; int main(){ DWORD threadid = 0; HANDLE threadhandle = CreateThread(0, 0, MeineThreadFunktion,0, 0, &threadid ); DWORD wait = WaitForSingleObject(threadHANDLE, 10000); if(wait == WAIT_TIMEOUT){ // Das Time-out ist eingetreten else if(wait == WAIT_OBJECT_0){ // Das HANDLE wurde ausgelöst // Der Thread wurde also beendet return 0; In diesem Beispiel warten wir ms, also 10 Sekunden. Falls dieses TIME-OUT eintritt ist die erste Bedingung erfüllt, falls aber der Thread vorher beendet wird ist der Rückgabewert der Funktion WAIT_OBJECT_0 und die zweite Bedingung ist erfüllt. Signale mittels Events Um einem Thread mitzuteilen, dass er eine Aktion durchführen oder sich beenden soll, könnte man eine globale Variable definieren, die vom Hauptthread gesetzt wird und vom zweiten Thread ausgelesen wird. Der zweite Thread müsste dann gelegentlich überprüfen, ob die Variable verändert wurde. Diese Art der Kommunikation ist aber unsicher, denn man kann nicht verhindern das die Variable genau dann gelesen wird, wenn sie vom Hauptthread geschrieben wird, was eine Kollision verursacht. Globale Variablen sind im allgemeinen nicht für die Kommunikation von Threads geeignet. Eine verlässliche Lösung unter Windows zur Kommunikation von Prozessen sind sogenannte Events. Events sind Signale, die entweder gesetzt oder nicht gesetzt sind. Das Wichtigste dabei ist, dass man mit WaitForSingleObject abfragen kann, ob ein solches Event gesetzt ist. Hier die dazu nötigen Funktionen: HANDLE CreateEvent(LPSECURITY_ATTRIBUTES Security, BOOL ManualReset, BOOL InitialState,LPCTSTR Name); BOOL SetEvent(HANDLE Event); BOOL ResetEvent(HANDLE Event); Mit dem ersten Aufruf wird ein Event-Objekt erzeugt. Das erste Argument hat mit Zugriffsrechten zu tun. Das zweite Argument bestimmt ob ein Event mit ResetEvent zurückgesetzt werden muss. Wird hier FALSE verwendet, wird das Event automatisch in den nicht gesetzten Zustand zurückgesetzt, sobald ein Thread mit WaitForSingleObject (o.ä) erfolgreich auf das Event gewartet hat. Weitere Threads, die auch auf das Event warten, werden nicht benachrichtigt. Das dritte Argument gibt an, ob das Event mit gesetztem Zustand erzeugt wird. Mit dem vierten Argument gibt

6 man dem Event einen Namen. Wir sehen im folgenden Beispiel, wie man ein Event einsetzen kann. Beispiel: Bildschirmausgabe von zwei verschiedenen Threads #include <windows.h> #include <string> #include <iostream> using namespace std; // Datenstruktur, die dem Thread als Argument übergeben wird struct ThreadData{ HANDLE stopevent; string data; ThreadData() : stopevent(0){ ; DWORD WINAPI ThreadFunc(LPVOID param){ ThreadData* threaddata = (ThreadData*)param; while(1) { DWORD wait = 0; // wir warten hier darauf, dass das Event gesetzt wird // Falls das innerhalb von 500ms nicht geschieht, haben // wir ein Timeout, sonst wird der Thread beendet wait = WaitForSingleObject(threadData->stopEvent, 500); if (WAIT_TIMEOUT == wait){ cout << threaddata->data << endl; //Schleife verlassen und somit den Thread beenden else { break; return 69; int main() { ThreadData* threaddata = new ThreadData; threaddata->data = "Hallo Thread"; // Hier wird das Event erzeugt threaddata->stopevent = CreateEvent(0,FALSE,FALSE,"StopEvent"); DWORD threadid = 0; // Hier wird der Thread erzeugt, als Argument wird die Struktur // threaddata übergeben HANDLE h= CreateThread(0,0,ThreadFunc,(void*) threaddata, 0, &threadid); for(int i = 0; i < 8; ++i){ cout << "Main Thread" << endl;

7 Sleep(1000); // 1 Sekunde warten // Zeit bis zur Beendigung des Thread messen DWORD startwait = GetTickCount(); // Signal setzen damit der Thread merkt,dass er beenden soll SetEvent(threadData->stopEvent); DWORD wait = WaitForSingleObject(h, INFINITE); DWORD diff = GetTickCount() - startwait; cout << "Wartezeit : " << diff << " ms" << endl; // da der Thread nun sicher beendet ist, können wir // die Daten sicher löschen delete threaddata; return 0; Wir haben hier aber eines der häufigsten Probleme beim Programmieren mit Threads. Es kann geschehen, dass sowohl main-funktion als auch Thread gleichzeitig etwas auf cout ausgeben wollen. Dadurch kann der Text unterbrochen werden und komisch aussehen. Critical Sections Die API-Funktionen bieten Möglichkeiten, den Zugriff auf gemeinsame Ressourcen zu regeln. Dabei geht es darum, dass zu einem Zeitpunkt immer nur ein einzigerthread auf die gemeinsame Ressource zugreifen kann. Während dieser Zeit wird den anderen Threads der Zugriff verwehrt. Dies wird dadurch erreicht, dass wenn ein Thread einen so genannten kritischen Abschnitt betreten will, er eine Funktion aufruft, welche andere Threads solange warten lässt, bis der nächste den kritischen Abschnitt betreten darf. Beim Verlassen des kritischen Abschnittes gibt der verlassende Thread ein Signal, damit der nächste wartende Thread in den kritischen Abschnitt gelangen kann. Mit warten ist gemeint, dass der Thread vom Scheduler pausiert wird und so keinerlei Rechenzeit beansprucht. Der Scheduler ist der Teil des Betriebssystems, welcher sich um die Zuteilung von Rechenzeit an die verschiedenen Threads kümmert. Dieses Verfahren garantiert einen gegenseitigen Ausschluss. Nur ein Thread kann zeitgleich den kritischen Abschnitt betreten.

8 Beispiel Critical Section Abschnitt : #include <windows.h> CRITICAL_SECTION CS void main() {... // Initialisieren der Critical Section InitializeCriticalSection(&CS);...hier den Code eingeben // Freigeben der Critical Section DeleteCriticalSection(&CS) DWORD WINAPI ThreadFunc(LPVOID param) {... // Versuchen die Critical Section zu betreten EnterCriticalSection(&CS); // den kritischen Code ausführen... // Verlassen und freigeben der Critical Section LeaveCriticalSection(&CS);...

9 Threads mit dem Borland C++Builder Einige Programmiersprachen, wie der C++ Builder von Borland kapseln die Windows API Funktionen in eigenen Typen und vereinfachen so deren Benutzung. Borland stellt dazu die Klassen TThread und TCriticalSection zur Verfügung. Das Arbeiten mit der Klasse TThread soll im Folgenden beschrieben werden : Starten Sie den C++Builder und wählen Sie Datei->Neue Anwendung. In der Objektgalerie vom finden Sie eine Vorlage Thread-Objekt, die man per Mausklick in das Programm einfügen kann Von dem Objekt TThread wird keine Instanz gebildet, vielmehr wird eine Nachfahrklasse erzeugt und implementiert. Als nächster Schritt erfolgt die Angabe eines Namens für die neue von TThread abgeleitet Klasse per Dialog : Wir erhalten als Resultat vier Dateien, je eine Implementationsdatei mit der Endung *.cpp und eine Header Datei mit der Endung *.h für das Formblatt und genauso für unser Thread-Objekt. Die Klassendeklaration in der Thread-Header-Datei enthält einen Konstruktor und eine Implementierung der virtuellen Methode Execute(). In der Thread-CPP-Datei weist ein Informationstext auf die Problematik der Synchronsation hin. Es wird empfohlen die API -Funktion

10 Synchronize(...) zu verwenden Diese bietet eine vergleichbare Funktionalität, wie die Critical Sections unter windows. Der Zugriff auf Komponenten des Formblatts (Buttons usw.) durch mehrere Threads wird synchronisiert. Das nachfolgende Programm soll die Eingriffsmöglichkeiten des Anwenders bei einer quasi- Endlosschleife demonstrieren. Durch die Verwendung von Threads ist jederzeit ein Zugriff des Anwenders möglich, d.h. er kann das Formular schließen oder ähnliches. Ohne Thread ist erst nach Ablauf der Schleife wieder ein Eingreifen möglich. Für das Formular benötigen wir: 2 TButton Komponenten (ButtonohneThread, ButtonmitThread) 1 TLabel Komponente (DisplayLabel) Per Doppelklick auf den Schalter Bsp. Ohne Thread erscheint die zugehörige Ereignisroutine, die folgendermaßen zu füllen ist : void fastcall TForm1::StartButtonClick(TObject *Sender){ int i = 1; do { DisplayLabel->Caption = IntToStr(i); i++; while (i < ); Erzeugen Sie nun das Programm und führen es aus. Klicken Sie einmal auf den Button Bsp.ohneThread und versuchen Sie nun während das Programm rechnet das Fenster zu verschieben bzw. es in der Größe zu verändern. Achten Sie dabei auf die Anzeige des DisplayLabel. Während das Programm rechnet kann weder das Formblatt verschoben noch in der Größe verändert werden, auch an der Anzeige des DisplayLabel tut sich überhaupt nichts. Erst nach Ende der Berechnung zeigt der DisplayLabel den aktuellen Wert von i an, nämlich

11 Jetzt wird dieselbe Funktionalität innerhalb einer Thread-Methode implementiert. Wechseln Sie zur Klassendeklaration des neuen, abgeleiteten Threads und ergänzen Sie diese folgendermaßen: class TMyThread : public TThread { private: int FCount; // Zähler für die Ausgabe im Label protected: void fastcall Execute(); void fastcall AusgabeForm(); // Zusatzmethode für Synchronize! public: fastcall TMyThread(bool CreateSuspended); ; Unsere Deklaration der Thread-Klasse wird um die Variable FCount und die Methode GuiElements()ergänzt. Die Variable benötigen wir als Durchlaufzähler und GuiElements()verwenden wir für die Aktualisierung der Anzeige des DisplayLabel auf Form1. In der CPP-Datei wird im Konstruktor des Threads die Eigenschaft FreeOnTerminate = true gesetzt. Dadurch wird der Thread freigegeben sobald die Methode Terminate() aufgerufen wird. // Konstruktor fastcall TMyThread::TMyThread(bool CreateSuspended) : TThread(CreateSuspended) { FreeOnTerminate = true; // Methode void fastcall TMyThread::AusgabeForm(){ // Da wir uns nicht im Gültigkeitsbereich von Form1 befinden müssen // wir den Zeiger auf Form1 verwenden Form1->DisplayLabel->Caption = IntToStr(FCount); Die Methode Execute() hat der Assistent bereits für uns angelegt, es handelt sich hierbei um das Hauptprogramm des Thread. Execute ist eine virtuelle Methode die folgendermaßen gefüllt wird : void fastcall TMyThread::Execute(){ FCount = 1; do { Synchronize(AusgabeForm); FCount++; while (FCount <= ); Wichtig ist der Aufruf von Synchronize(). Die Funktion erfüllt den gleichen Zweck wie Critical Sections bei Konsolenanwendungen, gleichzeitiger Zugriff mehrerer threads auf den Label des Formblatts wird verhindert!

12 Wir wechseln nun zum Formblatt und fügen per Doppelklick auf den Button Bsp. mit Thread der Unit eine neue Ereignis-Routine hinzu: void fastcall TForm1::StartThreadButtonClick(TObject *Sender){ new TMyThread(false); Sobald jetzt der Konstruktor aufgerufen wird und diesem der Parameter false (für CreateSuspended) übergeben wird startet der Thread mit seiner Methode Execute(). Wenn Sie jetzt das Programm kompilieren und starten, können Sie bei laufender Berechnung problemlos das Formular verschieben und in der Größe ändern, die Berechnung wird fortgesetzt und die Anzeige ist immer aktuell. Ein Klick auf das Schließen-Symbol beendet die Anwendung unmittelbar. Der Prozessor teilt jetzt also die Zeit zwischen dem Hauptthread (Formular) und dem zweiten Thread auf und wechselt so schnell hin und her, dass beide Anwendungen scheinbar parallel laufen. Um den Wechsel am Bildschirm sichtbar zu machen, erweitern wir die Button-Routine folgendermaßen : void fastcall TForm1::StartThreadButtonClick(TObject *Sender){ new TMyThread(false); ShowMessage("VCL-Mainthread"); ShowMessage("VCL-Mainthread2"); Nach dem Start sehen Sie, dass sowohl der Thread als auch das Hauptprogramm ausgeführt wird (da während der Thread läuft, nacheinander beide MessageBoxen ausgegeben werden). Damit der Thread nach Beendigung wieder gelöscht wird, ergänzen wir die Methode noch um folgende Zeile: void fastcall TForm1::StartThreadButtonClick(TObject *Sender){ // Instanz auf die in der Klasse zugegriffen werden kann erzeugen FNewThread = new TMyThread(false); FNewThread->OnTerminate = DeleteThread; In der Methode, die dem Ereignis OnTerminate zugewiesen wird, kann der gesamte Code zum Aufräumen ausgeführt werden. void fastcall TForm1::DeleteThread(TObject* Sender) { //Der Thread wird terminiert und freigegeben (FreeOnTerminate). FNewThread->Terminate();

13 Mit diesen Zeilen stellen wir nun sicher, dass der Thread ordnungsgemäß entsorgt wird, sobald die Zählervariable Fcount den Wert erreicht hat. Wird die Anwendung aber beendet bevor dies geschehen ist, wird der Thread nicht freigegeben. Für diesen Fall erweitern wir das OnClose- Ereignis des Formulars: void fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action){ if (FNewThread) FNewThread->Terminate(); Somit wäre dafür Sorge getragen, dass der Thread in jedem Fall gelöscht wird.

14 Zusammenfassung Borland Thread-Objekt Ein Programm kann theoretisch beliebig viele weitere Threads enthalten, allerdings sagt der Thread-Guidline das ein Programm nicht mehr als 16 weitere Threads enthalten sollte, die auf keinen Fall aber alle gleichzeitig ablaufen sollten (ausprobieren! ). Ein Thread ist ein eigener Prozess der im selben Prozessbereich wie das Hauptprogramm abläuft. Somit kann ein Thread auf dieselben Daten zugreifen wie das Hauptprogramm und der Anwender muss für Thread-Sicherheit sorgen (Critical Section oder Funktion Synchronize). Die Priorität eines Threads lässt sich einstellen (z.b. über die Instanz des VCL Thread- Objekts). Die Zuteilung der Zeit an die einzelnen laufenden Threads auf dem System nimmt der Scheduler vor. Der Scheduler entscheidet anhand der Priorität eines Threads wann und wie lange oder ob überhaupt dieser Thread Prozessorzeit zugeteilt bekommt. Ein VCL Thread-Objekt verwendet man, indem man einen Nachfahren der Klasse TThread erzeugt und dessen vordefinierte Methode TThread::Execute() überschreibt. Diese Methode ist sozusagen das Hauptprogramm des Threads, sie wird sofort nach dem Aufruf des Konstruktors gestartet. Stoppen kann man den Thread durch Aufruf der Methode TThread::Terminate(). Übergibt man dem Konstruktor den booleschen Parameter false, startet der Thread unmittelbar, die Übergabe von true erzeugt zwar die Instanz, der Thread jedoch wird noch nicht gestartet. Den Start kann man dann bei Bedarf mit der Methode TThread::Resume() nachholen. Ein Thread der auf Formblatt-Elemente (Buttons, Labels, usw.) zugreift muss mit dem Hauptthread synchronisiert werden. Hierzu stellt das Thread-Object die Methode TThread::Synchronize(...) zur Verfügung. Dieser Funktion wird als einziger Parameter der Name der Methode übergeben, die alle Zugriffe auf Formblatt-Elemente erledigt. Diese Methode, wird im Kontext des Formblatt-Hauptthreads ausgeführt, was Probleme verhindert, die entstehen würden, wenn auf Variablen der Formblatt-Elemente von zwei verschiedenen Stellen aus zugegriffen würde (vergleichbar mit Critical Sections in Konsolenanwendungen) Von TThread wird das Event TThread::OnTerminate geerbt, in der Methode die Sie diesem Event zuweisen können Sie den gesamten zum Aufräumen notwendigen Code implementieren.

15 PLAN und Threads Die Verwendung von Threads in der PLAN-Umgebung unterscheidet sich kaum von der Vorgehensweise im letzten Kapitel. Bei der PLAN-Oberfläche handelt es sich im Grunde auch um ein Formblatt. Wir können also unser PLAN-Projekt öffnen und mit Datei->Neu das Thread-Objekt auswählen. Im Beispiel ist der Name des Threads PlanThread Unser Projekt besteht jetzt aus drei Quellcodedateien. user.cpp für PLAN, PlanThread.cpp und PlanThread.h für den Thread. Wenn wir in den Thread-Dateien auf PLAN zugreifen möchten, muss die Klasse TUser dort bekannt sein. Wir erzeugen also mit Datei->Neu->Headerdatei eine user.h in die wir die Klassendeklaration von TUser verschieben. Diese user.h können wir dann per #include überall einfügen wo wir die Klasse TUser benutzen möchten.

16 user.h : #include "Plan.h" #include "PlanThread.h" // mit den folgenden 2 Zeilen wird verhindert,dass der folgende Code // mehrmals includiert wird #ifndef UserH #define UserH class PlanThread; class TUser : public TPlan { public: PlanThread *pt; void Init(void); void Run(void); void Finish(void); ; #endif PlanThread.h, hier wird user.h includiert: // #ifndef PlanThreadH #define PlanThreadH #include <Classes.hpp> #include "User.h" class PlanThread : public TThread { private: protected: void fastcall Execute(); void fastcall Kreis(); public: fastcall PlanThread(bool CreateSuspended); fastcall PlanThread(bool CreateSuspended,TUser *p); ; #endif In der Header-Datei des PlanThread gibt es einen zweiten Konstruktor, dem ein Zeiger auf TUser übergeben wird, um auf die Klasse TUser zugreifen zu können. Außerdem erzeugen wir noch eine Funktion Kreis(), die alle Zugriffe auf das Formblatt von PLAN kapselt. Mit der TThread- Methode Synchronize(Kreis), die wir im letzten Kapitel schon kennen gelernt haben, kann unser Thread jetzt kollisionsfrei auf die Zeichenfläche von PLAN zugreifen.

17 Jetzt werden die Funktionen Execute() und Kreis(), wie folgt gefüllt. Der im Init() gestartete Thread soll mit höchster Priorität Kreise auf die linke Seite der Grafikfläche zeichnen, im Run()soll gleichzeitig Text auf der rechten Seite ausgegeben werden. Beachten Sie auch, dass die Änderung von BrushColor in der Run() Funktion für beide Anwendungen gültig ist. PlanThread.cpp : // #include <vcl.h> #include "User.h" #include "PlanThread.h" #pragma hdrstop #pragma package(smart_init) // Wichtig: Methoden und Eigenschaften von Objekten der VCL können // nur in Methoden verwendet werden, die Synchronize aufrufen, z.b.: // // Synchronize(UpdateCaption); // wobei UpdateCaption so aussehen könnte: // // void fastcall Unit1::UpdateCaption(){ // Form1->Caption = "In Thread aktualisiert"; // // // lokaler Zeiger auf eine Instanz von TUser TUser *PLan; // die beiden Konstruktoren fastcall PlanThread::PlanThread(bool CreateSuspended) : TThread(CreateSuspended){ // Thread in der Terminate-Funktion löschen FreeOnTerminate = true; fastcall PlanThread::PlanThread(bool CreateSuspended, TUser *p) : TThread(CreateSuspended){ PLan = p; FreeOnTerminate = true; void fastcall PlanThread::Execute(){ for (int i= 0; i<100000; i+=10) // quasi EndlosSchleife Synchronize(Kreis); // synchronisieren der Threads Terminate();

18 void fastcall PlanThread::Kreis(){ // an zufällige Positionen im Bereich x(0,500) und y(0,1000) Kreise // zeichnen int i,k; PLan->BrushColor = Rot; i = random(500); k = random(1000); PLan->Circle(i,k,50); und hier die zugehörige user.cpp //==================================================================== // Simulation dynamischer Systeme (PLAN 7.0) //==================================================================== // Threads in PLAN #include <vcl.h> #pragma hdrstop #include <vcl.h> #pragma hdrstop #include "PlanThread.h" #include "User.h" void TUser::Init(void){ // Instanz von PlanThread erzeugen und noch nicht starten pt = new PlanThread (true); // höchste Priorität setzen pt->priority = tptimecritical; // Thread starten pt->resume(); // void TUser::Run(void){ // beim Drücken auf die Run-Taste Farbe ändern Text ausgeben SetTextSize(50); SetBrushColor (FarbSkala(CallRunCount%100)); Text (600,400,"PLAN ist auch noch aktiv!"); // void TUser::Finish(void){ // Beim Beenden von PLAN thread löschen if (pt) pt->terminate(); // #pragma argsused int main(int argc, char* argv[]) { TUser a;a.execute();return 0;

19 wenn Sie das Programm jetzt starten, werden rote Kreise auf der linken Seite der Grafikfläche gezeichnet. Parallel können Sie durch Drücken auf die Run-Taste Text ausgeben und die BrushColor ändern. Auch das Schließen von PLAN ist jederzeit möglich, dabei wird der Thread über die finish()funktion gelöscht!