[Luckie]

Threads mit Delphi
Thema: Threadprogrammierung mit Delphi

Version: 2.4 vom 2005-10-29

Inhaltsverzeichnis:

Zitat:

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

Insgesamt 45 Seiten

Das Tutorial liegt als PDF vor und kann hier: http://delphitutorials.michael-puff.de runtergeladen bzw. online eingesehen werden. In dem dazugehörigen Zip Archiv (Threads_mit_Delphi.zip) befinden sich noch zusätzlich Demos.

Zitat von Luckie:

Zitat von Motzi:

Seite 5: du schreibst du zuerst die C-Deklaration der Thread-Funktion, dann den Hinweis, dass die Aufrufkonvention in Delphi stdcall sein muss und dann die Delphi-Threadfunktion - ABER: die Delphi-Threadfunktion ist nicht als stdcall deklariert, da dieser TThreadFunc-Typ nur im Zusammenhang mit BeginThread verwendet wird und diese eine eigene Wrapper-Funktion verwendet.
Ich finde diese Kombination aus dem Hinweis auf die Aufrufkonvention und der Delphi-Deklaration ohne stdcall doch irgendwie irreführend...

Ja, das müßte ich noch irgendwie klarer machen. Evenzuell in dem ich erst noch die Delphi Deklaration von CreateThread aufführe.

Ja.. zuerst die Delphi-Deklaration von CreateThread und dann der Übergang auf BeginThread, wobei ich das nicht nur in einem kleinen Hinweis machen würde! Vielleicht auch noch mit der Deklaration von BeginThread...

Zitat:

Zitat:

Seite 16:

Zitat:

Windows stellt keine Funktion zur Verfügung, mit der sich die Prioritätsstufe eines Threads ermitteln lässt. [..]

Funktion gibt es keine, aber ich hab trotzdem eine interessante Doku dazu gefunden: http://msdn.microsoft.com/library/de...priorities.asp

Mal kucken. Halt, das sind die Prioritätesklassen. Die Prioritätsstufe eines Threads wird aus der Basispriorität des Prozesses und der relativen Priorität des Threads gebildet. Sie Tabelle Seite 15. Die Tabelle im MSDN liefert zwar eine Zuordnung, man kann sie aber nicht abfragen. Im Endeffekt ist es die gleiche Tabelle wie bei mir auf Seite 15.

Ja, es gibt keine Funktion um sie abzufragen, und die Tabelle ist (mit ein paar Unterschieden) fast dieselbe wie in deinem PDF (bzw dieselbe wie im Buch von Jeffrey Richter), nur dass sie noch ein bisschen detailierter ist. Aber die Tatsache, dass MS sich vorbehält den Algo jederzeit zu ändern hat mich davon ausgehen lassen, dass es keine offiziellen Dokus dazu gibt. Aber anscheinend hab ich mich geirrt...

Zitat:

Zitat:

Abgesehen von ein paar kleinen Tipp-Fehlern hab ich sonst nix mehr gefunden... 8)

Die will ich auch. Die Rechtschreibüberprüfung von OpenOffice scheint nicht so das ware zu sein.

Ok... *nochmalaufdiesuchemach*

Der Algorithmus, wie die Tabelle zustandekommt ist nicht dokumentiert. MS will sich vorbehalten diesen jeder Zeit zuänder. Und wenn du dein Programm jetzt von den Stufen abhängig machst, kann das ins Auge gehen in Zukünftigen Versionen.

Ich weiß.. und genau deswegen dachte ich auch das es keine offiziellen Dokus darüber gibt. Aber ich hab mich anscheinend getäuscht...

Wegen Tippfehlern:
Seite 6:

Zitat:

Man sollte möglichst keine globalen variablen verwenden, [..]

Seite 9:

Zitat:

Beim preemtiven Multitasking - im Gegensatz zum kooperativen Mutlitasking, wie Windows eins ist, [...]

Diese Satzkonstruktion is nicht ganz glücklich...
Seite 16:

Zitat:

Nachträglich kann dir Prioritätsklasse mit der Funktion SetPriorityClass geändert werden

Seite 16:

Zitat:

Das Gegenstück dazu ist die Funktion GetPriorityClass, welchen die Prioritätsklasse von dem mit hProcess angegebenen Prozess zurück gibt

Seite 17:

Zitat:

Da diese dynamische Anhebung kann laut einiger Entwickler zu einem nachteiligen Leistungsverhalten der eigenen Anwendung führen

Seite 17:

Zitat:

Bemerkt das System, dass ein Thread über drei bis vier Sekunden derart blockiert wird, setzt es die Prioritätsstufe des Threads für zweit aufeinanderfolgende Zeitscheiben auf die Stufe 15 und senkt sie danach sofort wieder auf die Basispriorität ab

Seite 19:

Zitat:

[..]nicht mehr 2 sondern 1! das Ergebnis hängt[..]

Kapitel 4.2 - Kritische Abschnitte:
kritische Abschnitte sollten immer in einem Resource-Schutz-Block gekapselt sein, damit auch im Falle eines Fehlers die critical section wieder verlassen wird!
Seite 22:

Zitat:

So bald die kritischen Abschnitte nicht mehr gebraucht werden [..]

Seite 22:

Zitat:

EnterCriticalSection untersucht dabei die Elementvariablen der CRITICAL_SECTION-Struktur und entnimmt ihnen den Zustand der Resourcen

Seite 22:

Zitat:

Zeigt das Element an, dass der aufrufende Thread schon Zugang zu den Resourcen hat, wird der Zähler erhöht,d er festhält wie oft[..]

Generell hast du relativ viele Fehler mit "zuviel" Leerzeichen.. jetzt mal ohne Seitenangaben:
wie viel -> wieviel
in sofern -> insofern (zB Seite 12)
so bald -> sobald

Mehr ist mir momentan nicht aufgefallen...

Die Leertaste ist eben so groß, die trifft man so leicht.

Und den Button um hier zu posten trifft man auch immer gerne doppelt, gelle?

Seite 5:

Zitat:

Sie können den selbe Code ausführen...

Zitat:

..., wird auch der Prozess beendet und der Adressraum des Prozesses freigegeben..

Seite 11:

Zitat:

Oft findet man zu diesem Zweck Code wie diesem:

Seite 14:

Zitat:

..."Anhaben der Zeitplanungspriorität" verfügt. Standardmäßig haben diese Berechtigung Mitglieder Gruppe Administratoren und Hauptbenutzer.

Seite 15:
In der Tabelle würde ich den Normalfall (Normal / Normal. Priorität 8 ) noch herausheben.

Seite 17, Kontext:

Zitat:

In Folge eines Tastendrucks, welcher dazu führt, dass eine WM_KEYDOWN Nachricht in die 'Warteschlange eingereiht wird.

Der Satz hört imho ein wenig zu unvermittelt auf.

Zitat:

Da diese dynamische Anwendung kann zu (...) führen.

Auf Seite 18 gehört der Hinweis mit dem Problemen beim starten aus der IDE imho nicht in das Tut, sondern gelöst

Seite 22, oben:
Im Code auf Seite 21 heisst der Datentyp RTL_CRITICAL_SECTION, im Text wird auf Seite 22 nur CRITICAL_SECTION genannt. Was ist nun richtig?

Seite 23:

Zitat:

... da es nutzlos ist in diesem Fall einen SpinLockzähler zusetzten:

Seite 24:
Das Stichwortverzeichnis hat eine Gliederungsebene zu viel (nie mehr als 2, lernt man recht früh wenn man professionelle Dokus macht). Zudem sind die Gliederungsebenen ungleichmäsig eingerückt.

Selbst wenn Du auf 3 Ebenen bestehst (die machen imho nur wenig Sinn) sollte jede Ebene auf der ganzen Seite gleich weit eingezogen sein. Vor allem unter Synchronisation fällt das extrem auf und macht den Index unübersichtlich und somit unnütz. (Sorry, ich beschäftige mich gerade mit dem Layout professioneller technischer Dokumentationen ).

Aber das wars dann auch von mir. Hab ne Menge draus gelernt

Puh, danke, dann werde ich mich gleich mal ransetzten und die Fehler ausbügeln.

Was das Demo angeht: Na dann mach mal. Es hat schon mal aus der IDE funktioniert.

So, ich darf euch eine überarbeitet Fassung meines Threading Tutorials präsentieren. Es wurde grundlegend überarbeitet und ergänzt mit ein paar Worten zum dem VCL Thread-Objekt.

aus dem Inhalt:
– Grundlagen der Thread Programmierung
– Thread-Ablaufsteuerung
– Thread-Prioritäten
– Thread-Synchronisation
– Das Thread Objekt der VCL

Demos:
- CriticalSection
- InterLockedExchangeAdd
- Priority
- SpinLock
- ThreadTimes
- TThreadObject

Es ist jetzt insgesamt 33 Seiten stark.

Hier die Links:
Thread Tutorial Hauptseite
Download des Tutorials (PDF mit Demos / 393 KB)
Tutorial (PDF / 371 KB) zum online lesen.

Ich habe das Threading Tutorial für Delphi erweitert und überarbeitet.

Es umfasst nun mehr 45 Seiten und 9 Demos (VCL, nonVCL, Konsole) zu den Kapiteln. Aus dem Inhalt:

• Grundlagen der Thread Programmierung (BeginThread, ...)
• Thread-Ablaufsteuerung (ResumeThread, SuspendThread)
• Thread-Prioritäten (SetPriorityClass, SetThreadPriority, ...)
• Thread-Synchronisation (CriticalSections, InterLockedExchangeXXX, ...)
• Thread-Synchronisation mit Kernelobjekten (neu in 2.2) (WaitForXXX, CreateEvent, SetEvent)
• Das Thread Objekt der VCL

Downloadlink: http://tutorials.luckie-online.de

Fragen, Anregungen und Probleme könne entweder hier oder in meinem Support-Forum gestellt werden.

Hallo Michael,

ein wirklich schönes Tutorial! Da kann ich wirklich einiges an Honig für mein Projekt draus ziehen!
Ich habe im Thread gelesen, dass du auch möglichst alle Vertipper genannt haben möchtest..
leider würde sich mein Post dann hier ziemlich in die Länge ziehen, daher ein Vorschlag: Wenn du mir eine Word-/RTF- oder andere bearbeitbare Version zur Verfügung stellst, korrigiere ich sie kurz durch und sende sie zurück. Ist glaube ich einfacher für alle Beteiligten;
es sein denn, die anderen möchten die Korrekturen auch alle "in situ" sehen...

Bei Interesse einfach melden.

Grüße aus Hamburg.

Peter

Ui. So viele Vertipper? Ich könnte es höchstens als OpenOffice Dokumnet zur Verfügung stellen.