1 Vorwort........................................... .................................................. ....................... 4
2 Einführung........................................ .................................................. ...................... 5
2.1 Geschichtliches................................... .................................................. .............. 5
2.2 Begriffsdefinition................................ .................................................. ............... 5
2.2.1 Was ist ein Prozess?.......................................... ............................................ 5
2.2.2 Threads, die arbeitende Schicht........................................... ........................... 6
2.2.3 Multitasking und Zeitscheiben...................................... ................................... 7
2.3 Wann sollte man Threads einsetzen und wann nicht?............................................ .... 7
3 Grundlagen........................................ .................................................. ..................... 9
3.1 Zur Veranschaulichung................................. .................................................. ...... 9
3.2 Die Thread-Funktion.......................................... ................................................. 10
3.3 Einen Thread abspalten......................................... ............................................. 10
3.4 Beenden eines Threads........................................... ............................................ 11
3.4.1 Die Thread-Funktion endet............................................. .............................. 11
3.4.2 ExitThread........................................ .................................................. ....... 12
3.4.3 TerminateThread................................... .................................................. .... 12
3.4.4 Vorgänge beim Beenden eines Threads........................................... ............... 13
4 Thread-Ablaufsteuerung................................... .................................................. ....... 15
4.1 Anhalten und Fortsetzen von Threads........................................... ........................ 16
4.1.1 Fortsetzen........................................ .................................................. ........ 16
4.1.2 Anhalten.......................................... .................................................. ........ 16
4.1.3 Zeitlich begrenztes Unterbrechen...................................... ............................ 17
4.2 Temporärer Wechsel zu einem anderen Thread............................................ .......... 17
4.3 Thread Ausführungszeiten, Beispielanwendung ThreadTimes....................................18
5 Thread-Prioritäten....................................... .................................................. ........... 20
5.1 Darstellung der Prioritäten....................................... ........................................... 20
5.1.1 Prozess-Prioritäten....................................... ............................................... 20
5.1.2 Thread-Prioritätsklassen................................. .............................................. 22
5.2 Programmieren von Prioritäten....................................... ..................................... 24
5.2.1 festlegen der Prioritätsklasse.................................. ...................................... 24
5.2.2 Festlegen der Thread-Priorität......................................... .............................. 25
5.2.3 Prioritätsanhebung durch das System............................................ ................ 26
5.3 Beispielanwendung "Priority-Demo"............................................. ......................... 27
6 Thread-Synchronisation................................... .................................................. ........ 29
6.1 Atomarer Variablenzugriff.................................. ................................................. 29
6.2 Kritische Abschnitte........................................ .................................................. . 31
6.2.1 Wie funktionieren kritische Abschnitte........................................ .................... 33
6.2.2 Kritische Abschnitte und SpinLocks......................................... ....................... 34
7 Thread-Synchronisation mit Kernel-Objekten (neu in Version 2.2)................................... 36
7.1 WaitForxxx-Funktionen........................................ ............................................... 36
7.1.1 WaitForSingleObject............................... .................................................. ... 36
7.1.2 WaitForMultipleObjects............................ .................................................. .. 38
7.1.3 MsgWaitForMultipleObject (neu in Version 2.3).............................................. .. 38
7.2 Ereignisobjekte................................... .................................................. ............. 39
8 Das
VCL Thread-Objekt............................................ ................................................. 41
8.1 Erzeugen, Eigenschaften, Methoden.......................................... ............................41
8.1.1 Erzeugen.......................................... .................................................. ....... 41
8.1.2 Eigenschaften..................................... .................................................. ...... 42
8.1.3 Methoden.......................................... .................................................. ....... 43
8.2 Beispiel einer Execute Methode........................................... ................................. 43
8.3 Synchronisation des Thread-Objektes.......................................... ......................... 44