Prozesse und Threads

1. Prozesse und Threads 2.1 Prozesse 2.2 Threads 2.3 Interprozesskommunikation 2.4 Klassische Probleme der Interprozesskommunikation 2.5 Scheduling Kapitel 2

2. ProzesseDas Prozessmodell Unterschied Prozess / Programm 􀂃Prozess ist eine Aktivität 􀂃Besteht aus Programm, Input, Output und Zustand a) Multiprogramming von vier Programmen b) Konzeptionelles Modell von vier unabhängigen sequentiellen Prozessen c) Zu einem Zeitpunkt ist nur ein Programm aktiv. Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

3. Prozesserzeugung • OS muss sicherstellen, dass alle wichtigen Prozesse existieren. • Manchmal: alle Prozesse die jemals benötigt werden, werden beim Startup erzeugt • Im allgemeinen: Möglichkeit zur Erzeugung / Beendigung erforderlich Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

4. Prozesserzeugung Ereignisse, die die Erzeugung eines Prozesses auslösen • Initialisierung des Systems (boot) • Systemaufruf zum Erzeugen eines Prozesses durch einen anderen Prozess • Benutzeranfrage, einen neuen Prozess zu erzeugen • Start eines Batch Jobs Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

5. Prozesserzeugung Booten Mehrere Prozesse werden gestartet • 􀂃Prozesse zur Interaktion mit Anwender • 􀂃Prozesse für bestimmte Funktionen • 􀂃Email-service • 􀂃Drucker-Warteschlange • 􀂃Firewall Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

6. Windows Taskmanager Prozessliste Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

7. Prozessbeendigung Bedingungen, die zum Beenden von Prozessen führen • Normales Beenden (freiwillig) • Beenden auf Grund eines Fehlers (freiwillig) • Beenden auf Grund eines schwerwiegenden Fehlers(unfreiwillig) • Beenden durch einen anderen Prozess (unfreiwillig) Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

8. Prozesshierarchien • Elternprozess erzeugt Kindprozess. Kindprozess kann weitere Prozesse erzeugen. In UNIX ist das eine Prozessfamilie • Unter Windows gibt es kein Konzept einer Prozesshierarchie, alle Prozesse sind gleichwertig. Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

9. Prozesszustände (1) • Prozess blockiert wegen Eingabe • Schedular wählt einen anderen Prozess • Schedular wählt diesen Prozess • Eingabe vorhanden • Mögliche Prozesszustände • rechnend (running) • blockiert (blocked) • rechenbereit (ready) • Es existieren die dargestellten Übergänge zwischen diesen Zuständen Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

10. Prozesszustände (2) • Die unterste Schicht eines prozessstrukturierten Betriebssystems behandelt Interrupts und Scheduling • Oberhalb befinden sich sequentielle Prozesse Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

11. Implementierung von Prozessen Einige Felder eines typischen Eintrags einer Prozesstabelle Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

12. Umschalten zwischen Prozessen Context Switch Aufgaben der untersten Schicht des Betriebssystems bei Auftreten einer Unterbrechung • Hardware sichert Befehlszähler etc • Hardware holt neuen Befehlszähler vom Interruptvektor • Assemblerfunktion speichert Register • Assemblerfunktion erzeugt neuen Stack • C-Unterbrechungsroutine läuft (puffert Ein/- Ausgaben) • Schedular sucht nächsten Prozess • C-Funktion kommt zur Assemblerfunktion zurück • Assemblerfunktion startet neuen aktuellen Prozess Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

13. Schritte für den Systemaufruf Adresse 0xFFFFFFFF Bibliotheks- programm read 10. 4. Benutzerraum Benutzerprogramm ruft read auf count = read (fd, buffer, nbytes 6. fd : filedescriptor buffer : Ziel nbytes : Länge 9. Kernadressraum 8. 7. Systemaufruf-behandlung Verteilung

14. ThreadsDas Threadmodell (1) • Traditionelles Modell: Prozess hat • einen Adressraum • einen Ausführungsfaden • Manchmal ist es wünschenswert, mehrere Ausführungsfäden zu haben Drei Prozesse mit jeweils einem Thread Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

15. ThreadsDas Threadmodell (2) • Traditionelles Modell: Prozess hat • einen Adressraum • einen Ausführungsfaden • Manchmal ist es wünschenswert, mehrere Ausführungsfäden zu haben • wie eigene Prozesse, aber gemeinsamer Adressraum Ein Prozess mit drei Threads Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

16. Das Threadmodell (3) 1. Spalte: Elemente werden zwischen den Threads eines Prozesses aufgeteilt 2. Spalte: Thread-eigene Elemente Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

17. Das Threadmodell (3) Jeder Thread hat seinen eigenen Stack Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

18. Einsatz von Threads (1) Ein Textprogramm mit drei Threads Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

19. Einsatz von Threads (2) Ein Web-Server mit mehreren Threads Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

20. Einsatz von Threads (3) • Grober Auszug des Codes zur vorherigen Folie. (a) Dispatcher thread (b) Worker thread Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

21. Einsatz von Threads (4) Drei Möglichkeiten, einen Server zu bauen: Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

22. Einsatz von Threads (5) • Sie ermöglichen es, das Konzept von sequenziellen Prozessen, die blockierende Systemaufrufe (z.B. für Platten E/A) machen, beizubehalten und troztdem Parallelität zu erzielen • Blockierende Systemaufrufe vereinfachen die Programmierung und die Parallelität verbessert die Performance • Der Einzel-Thread-Server behält die Einfachheit von blockierenden Systemaufrufen bei, gibt jedoch die Performance auf. • Der dritte Ansatz bringt hohe Performance durch Parallelität, benutzt aber nicht blockierende Aufrufe und ist deshalb schwieriger zu programmieren Was Threads zu bieten haben: Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

23. Realisierung von Threads im Benutzeradressraum (1) • Vorteile: • kann auch auf Betriebssystemen realisiert werden, die Threads nicht unterstützen • Umschalten zwischen Threads geht vergleichsweise schnell Ein Benutzer-Level Thread Paket Run-time system – Laufzeitsystem, enthält eine Sammlung von Prozeduren, die auch Threads verwalten (thread_create, thread_exit,...) Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

24. Realisierung von Threads im Benutzeradressraum (2) • Probleme: • Ruft ein Thread einen blockierenden Systemaufruf auf (z.B. read von Tastatur), werden alle Thread blockiert • Systemaufrufe müssten nicht blockierend implementiert werden und Anwendungsprogramme müssten dafür modifiziert werden (sehr aufwendig) • Seitenfehler eines Threads blockieren ebenso alle Threads • Startet ein Thread, kommt kein anderer an die Reihe, bis der erste von sich aus die CPU freigibt Ein Benutzer-Level Thread Paket Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

25. Realisierung von Threads im Kern(1) Kern hat Thread-Tabelle, die alle Threads im System verwaltet Zur Sicherheit: Exkurs über Betriebssystemkern! Ein Thread Paket, verwaltet vom Kern Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

26. Betriebssystemkern (1) Wikipedia: Ein Betriebssystemkern oder Systemkern (engl. kernel ) ist der zentrale Bestandteil eines Betriebssystems. In ihm ist die Prozess- und Datenorganisation festgelegt, auf der alle weiteren Softwarebestandteile des Betriebssystems aufbauen. Er ist meist in der untersten Softwareschicht, hat also Zugriff auf die Hardware. Die Konstruktion eines Betriebssystemkerns gehört zum Themenbereich der Informatik und des Softwareengineerings. Gängige Anforderungen an einen Systemkern sind Parallelverarbeitung verschiedener Aufgaben (Multitasking), Einhaltung zeitkritischer Grenzen, Offenheit für unterschiedlichste Anwendungen und Erweiterungen. Nicht zum Systemkern gehörende Teile werden als Userland bezeichnet. Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

27. Betriebssystemkern (2) • Bestandteile • Ein Systemkern ist in Schichten (oder Layer, siehe Schichtenmodell) aufgebaut, wobei die unteren (maschinennahen) Schichten die Basis für die darüberliegenden bilden. Die oberen Schichten können Funktionen der unteren Schichten aufrufen, aber nicht umgekehrt. • Folgende Schichten sind vorhanden (von unten nach oben): • Schnittstelle zur Hardware (Geräte, Speicher, Prozessoren) • Speicherverwaltung (evtl. einschließlich virtuellem Hauptspeicher) • Prozessverwaltung (auch Scheduler genannt) • Geräteverwaltung (auch Device Management genannt) • Dateisysteme • Wenn alle diese Funktionen im Systemkern selbst integriert sind, spricht man von einem monolithischen Kernel. Bei einem Mikrokernel finden wesentliche Teile in getrennten Prozessen statt. Daneben, bzw. zwischen den beiden liegend, gibt es noch den sogenannten Makrokernel. • Auf jeden Fall außerhalb des Kernels laufen die Anwenderprozesse, die sich der vom Kernel angebotenen Funktionen bedienen, um mit der Maschine zu kommunizieren. Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

28. Betriebssystemkern (3) • Aufgaben eines Kernels : • Schnittstelle zu Anwenderprogrammen (Starten, Beenden, Ein-/Ausgabe, Speicherzugriff) • Kontrolle des Zugriffs auf Prozessor, Geräte, Speicher (Scheduler, Gerätetreiber, Speicherschutz). Möglichst alleiniger Zugriff des Kernels auf diese Ressourcen. • Verteilung der Ressourcen, etwa der Prozessorzeit(en) (bzw. der Prozessoren) auf die Anwenderprogramme • Strukturierung der Ressourcen, etwa Abbildung von Dateisystemen auf blockorientierte Geräte wie Festplatten, Netzwerkprotokoll-Stack auf Netzwerkkarten. • Auflösung von Zugriffskonflikten, etwa Verriegelung bei Mehrprozessorsystemen, Warteschlangen bei knappen Ressourcen • Virtualisierung der Ressourcen (Prozessor: Prozesse, Festplatte: Dateien, Netzwerkkarte: z. B. Sockets, Speicher: virtueller Speicher, Geräte: Spezialdateien) • Überwachung von Zugriffsrechten auf Dateien und Geräte bei Mehrbenutzersystemen Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

29. Betriebssystemkern (4) Schichten eines Unix Betriebssystems UserInterface Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

30. Betriebssystemkern (5) Kernel Mode – User Mode Kernel und user space sind unterschiedliche Teile des Adressraumes. User space ist reservierter Bereich für applikationen (jede einen eigenen Bereich). Kernel space ist auch ein reservierter Bereich, jedoch nur einer für alle Anwendungen, die dort nicht schreiben können. Nur das Betriebssystem kann den Prozessor auf kernel mode umschalten und auf diesen Bereich zugreifen... Anwendungen laufen dagegen normalerweise nur im user mode des prozessors, und verwenden damit einen eingeschränkten Befehlssatz ist. Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

31. Betriebssystemkern (6) CPU- Betriebsarten: Kernel Mode – User Mode Das Programmstatuswort der CPU enthält die aktuelle Betriebsart: kernel mode, user mode Damit wird ein Schutzsystem realisiert kernel mode: - privilegierte Betriebsart (nur für Betriebssystem) - alle Instruktionen sind erlaubt, inbes. IO auf Hardware user mode:- nicht privilegierte Betriebsart - nicht alle Instruktionen sind erlaubt (z.B. Zugriff auf Ein-/Ausgabe) - nicht alle Register dürfen verändert werden (z.B. Register für Speicherkonfiguration) Umschaltung in Kernmodus: mittels Interrupt (über SW oder HW ausgelöst) Umschaltung in Benutzermodus: mittels Maschinenbefehl bzw. PSW-Modifikation Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

32. Realisierung von Threads im Kern(2) Kern hat Thread-Tabelle, die alle Threads im System verwaltet Thread-Tabelle enthält Informationen über Register, Zustand... der einzelnen Threads Alle Aufrufe, die blockieren können, sind als Systemaufrufe realisiert mit höheren Kosten als Aufrufe im Laufzeitsystem – aber:wenn ein Thread blockiert, hat der Kern die Möglichkeit, einen anderen (prozesseigegnen oder fremden) Thread zu starten Fazit: flexibel, aber teuer Ein Thread Paket, verwaltet vom Kern Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

33. Hybride Implementierung Multiplexen von Benutzer-Level-Threads in Kern-Threads = Versuch, die Vorteile beider Implementierungen zu verbinden Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

34. Scheduler Activations • Ziel: – Verbindung der Funktionalität von Kern-Threads mit der Performance von Benutzeradressraum Threads • Vermeiden von unnötigen user/kernel Umschaltungen • Kern ordnet jedem Prozess virtuelle Prozessoren zu und veranlasst das Laufzeitsystem (im Benutzeradressraum) den Prozessoren Threads zuzuordnen (geht auch bei Multiprozessorsystemen) • Grundidee: Wenn der Kern weiss, dass ein Thread durch einen blockierenden Systemaufruf oder Seitenfehler blockiert hat, benachrichtigt er das Laufzeitsystem (Upcall) Das Laufzeitsystem kann seine Threads darauf hin neu schedulen, also den gegenwärtigen Thread als blockiert markieren und einen anderen starten • Problem: Fundamental reliance on kernel (lower layer) calling procedures in user space (higher layer) Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

35. Pop-Up Threads Erzeugen eines neuen Threads, wenn eine Nachricht eintrifft (a) bevor die Nachricht eintrifft (b) nachdem die Nachricht eintrifft Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

36. Multithreading • Üblich: zuerst nur ein Thread • Startet weitere threads(z.B. thread_create (proc_name)) • Manchmal hierarchisch, manchmal flach • Wenn thread fertig: thread_exit • Warten auf thread-Ende: thread_wait • CPU freiwillig hergeben: thread_yield Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

37. Posix Thread Beispiel – 1Main 1 PROGRAM ForThreads ! ! Funktionsbeschreibung: ! Thread Testprogramm ! ! Programm kreiert und startet mehrere Threads: ! - einThread wird mehrmals kreiert (Master-Worker) und gestartet. ! Diese Workerthreads arbeiten periodisch mit Hilfe eines Timers. ! Sie stoßen wiederum alle den selben Thread an ! - Thread2 ist der mittels pthread_cond_signal von einThread ange- ! stossene Thread, der in einer Endlosschleife mit pthread_cond_wait ! auf Aufträge wartet. Er muss vom Hauptprogramm mit pthread_cancel ! explizit beendet werden ! - Thread3 läuft als unabhängiger Thread und führt eine Anzahl Ite- ! rationen aus. Für ihn werden Scheduling-Parameter (Priorität) ! gesetzt. ! - Das Programm endet erst, wenn alle Threads abgearbeitet oder beendet sind. ! Geprüft wird dies mit pthread_join. ! ! Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

38. Posix Thread Beispiel – 2benutzte Posix Funktionen ! Functions: ! pthread_cond_init Conditionvariable erzeugen und mit ! Defaultwert initialisieren ! pthread_cond_broadcast Alle Thread, die auf eine bestimmte ! Condition-Variable hören, benachrichtigen ! pthread_cond_signal Einen Thread, der auf eine bestimmte ! Condition-Variable hört, benachrichtigen ! pthread_create Einen Thread erzeugen ! pthread_join Synchronisieren mehrerer Threads ! pthread_mutex_init Mutexvariable erzeugen und mit ! Defaultwert initialisieren ! pthread_mutex_lock Mutex locken vor broadcast ! pthread_mutex_unlock Mutex unlocken nach broadcast ! pthread_setschedparam Scheduling Verfahren und Priorität ! für einen Thread festlegen ! !D- Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

39. Posix Thread Beispiel – 3Datendeklaration INCLUDE 'GEN_INCL:ST(PThreads)' EXTERNAL Test_Thread1 EXTERNAL Test_Thread2 EXTERNAL Test_Thread3 PARAMETER PTHREAD_MUTEX_DEFAULT = 0 PARAMETER anzworkers = 4 INTEGER *4 ThrCount , SchedNr INTEGER *4 INDX , IStatus INTEGER *4 thrnum /1/ INTEGER *4 ThreadCancelNum INTEGER *4 ThreadStackSize /819200/ !size_t INTEGER *4 exitval RECORD /pthread_mutex_t/ SlowMutex, WeckMutex, CountMutex, RECORD /pthread_cond_t/ WeckCond, CountCond COMMON /COM_Threads/ SlowMutex, WeckMutex, CountMutex, WeckCond, 1 CountCond, ThrCount REAL *4 x /1.0/ RECORD /pthread_t/ einThread (anzworkers) RECORD /pthread_t/ Thread2 RECORD /pthread_t/ Thread3 RECORD /pthread_attr_t/s_gl_pthread_attr RECORD /pthread_attr_t/s_gl_pthread_attr2 RECORD /sched_param/schedparam Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

40. Posix Thread Beispiel – 4Threads erzeugen ThrCount = 0 schedparam.sched_priority = 9 !PRI_FG_MIN_NP 8 - 15! CALL pthread_mutex_init(CountMutex,%VAL(PTHREAD_MUTEX_DEFAULT)) CALL pthread_mutex_init(WeckMutex,%VAL(PTHREAD_MUTEX_DEFAULT)) ! Thread Condition Varibale initialisieren IStatus = pthread_cond_init(WeckCond, ) IStatus = pthread_cond_init(CountCond,) IStatus = pthread_attr_init(s_gl_pthread_attr) IStatus = pthread_attr_init(s_gl_pthread_attr2) IStatus = pthread_attr_setstacksize(s_gl_pthread_attr, ThreadStackSize) IStatus = pthread_attr_setstacksize(s_gl_pthread_attr2, ThreadStackSize) DO INDX = 1,anzworkers ! Eine Prozedur mehrmals als Thread erzeugen (anzworkers) IStatus = pthread_create(einThread(INDX), %VAL(PTHREAD_CREATE_JOINABLE), 1 test_thread1, %VAL(thrnum)) ThrNum = ThrNum + 1 ENDDO ThreadCancelNum = ThrNum IStatus = pthread_create(Thread2, %VAL(PTHREAD_CREATE_JOINABLE), test_thread2, %VAL(thrnum)) ThrNum = ThrNum + 1 IStatus = pthread_create(Thread3, %VAL(PTHREAD_CREATE_JOINABLE), test_thread3, %VAL(thrnum)) ThrNum = ThrNum + 1 IStatus = pthread_create(ReqThread1, s_gl_pthread_attr, req_thread1, %VAL(thrnum)) ThrNum = ThrNum + 1 IStatus = pthread_create(ReqThread2, s_gl_pthread_attr2, req_thread2, thrnum) Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

41. Posix Thread Beispiel – 5benachrichten und beenden ! ! Prioritäten der Threads festlegen ! IStatus = pthread_setschedparam (%VAL(Thread3.Pointer), %VAL(Sched_Other), schedparam) ! ! Mittels Broadcast alle Threads der Variante einThread wecken ! IStatus = pthread_cond_broadcast (%REF(WeckCond)) PRINT*,'alle Threads aktiviert, Main wartet noch auf Rückmeldung ' ! ! Mittels Signal Thread2 wecken ! IStatus = pthread_cond_signal(%REF(CountCond)) ! ! Ende aller Threads abwarten/oder herbeiführen ! DO INDX = 1, anzworkers IStatus = pthread_join32(%VAL(einThread(INDX).Pointer),exitval) ENDDO IStatus = pthread_join32(%VAL(Thread3.Pointer),exitval) IStatus = pthread_cancel (%VAL(Thread2.Pointer)) IStatus = pthread_join32(%VAL(Thread2.Pointer),exitval) IStatus = pthread_join32(%VAL(ReqThread1.Pointer),exitval) IStatus = pthread_join32(%VAL(ReqThread2.Pointer),exitval) END Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

42. Posix Thread Beispiel – 6test_Thread1,arbeitet periodisch, terminiert selbst SUBROUTINE test_thread1(thrnum) IMPLICIT NONE ! ! Thread wird mehrfach (Anzahl= anzworkers), konkurrierend in MAIN erzeugt ! und mittels Broadcast geweckt. ! ! Verwendete Prozeduren: ! ! pthread_cond_wait Warten auf Ereignis und aufwachen des Threads mit Mutex ! pthread_cond_timedwait Warten auf Ereignis mit Timeout (verwendbar als Timer bei Threads) ! pthread_cleanup_push Aufsetzen eines Exithandlers für einen Thread (Cleanuphandler) ! pthread_cleanup_pop Ausführen eines Exithandlers (Cleanup) Handlers ! pthread_get_expiration_np Bestimmung der Ablaufzeit des Timers indem zur Systemzeit ein ! Delta in Sek kunden addiert wird ! pthread_mutex_lock WeckMutex locken für pthreadcond_wait ! INCLUDE 'GEN_INCL:ST(PThreads)' INTEGER *4 ThrCount RECORD /pthread_mutex_t/ SlowMutex RECORD /pthread_mutex_t/ WeckMutex RECORD /pthread_mutex_t/ CountMutex RECORD /pthread_cond_t/ WeckCond RECORD /pthread_cond_t/ CountCond COMMON /COM_Threads/ SlowMutex, WeckMutex, CountMutex, WeckCond, 1 CountCond, ThrCount CHARACTER * 8 CTime INTEGER *4 a , thrnum, Error, INDX /0/, IStatus RECORD /PThread_TimeSpec_T/ WaitTime, ResWaitTime Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

43. Posix Thread Beispiel – 7test_Thread1,arbeitet periodisch, terminiert selbst CALL TIME (CTime) a = %LOC(thrnum) PRINT *, a,%LOC(a), ' thread ',a,' gestartet um:',CTime,%LOC(CTime), 1 %LOC(WaitTime.tv_sec) WaitTime.tv_sec = 4 WaitTime.tv_nsec = 0 ! Synchronisierung der Threads mit dem Hauptprogramm mittels einer ! Condition Variablen IStatus = pthread_mutex_lock(WeckMutex) IStatus = pthread_cond_wait(WeckCond, WeckMutex) IStatus = pthread_mutex_unlock (WeckMutex) ! ! Timer definieren ! IStatus = pthread_get_expiration_np (%REF(waittime),%REF(reswaittime)) DO INDX = 1,4 IStatus = pthread_mutex_lock(CountMutex) thrCount = thrCount + 1 IStatus = pthread_mutex_unlock(CountMutex) Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

44. Posix Thread Beispiel – 8test_Thread1,arbeitet periodisch, terminiert selbst ! ! Für sauberes Arbeiten des Condition Wait muss der ! Mutex vorher gelockt werden. ! IStatus = pthread_mutex_lock (WeckMutex) CALL TIME (CTime) PRINT*,a,%LOC(a),' Timer aufgesetzt thread ',a,' Lauf ',INDX,' ',CTime PRINT*,a,%LOC(a),' Ende erwartet um ',reswaittime.tv_sec,':',reswaittime.tv_nsec IStatus = pthread_cond_timedwait(WeckCond, WeckMutex, 1 reswaittime) Error = pthread_mutex_unlock (WeckMutex) CALL TIME (CTime) IF (IStatus .EQ. 0)THEN PRINT*,a,%LOC(a),' ', IStatus,' über Mutex/Condition rausgekommen' ELSEIF (IStatus .EQ. ETIMEDOUT) THEN PRINT*,a,%LOC(a),' Timer abgelaufen thread ',a,' Lauf:',INDX,' ',CTime ELSE PRINT*,a,%LOC(a),' Ende von Condition Wait Lauf ',INDX,' um',CTime,' Fehler ', IStatus ENDIF IStatus = pthread_get_expiration_np (%REF(waittime),%REF(reswaittime)) IStatus = pthread_cond_signal(CountCond) ENDDO PRINT*,a,%LOC(a), ' Fertig....thread',a RETURN ENDd Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

45. Posix Thread Beispiel – 9Endlos Thread, wird von main gestoppt SUBROUTINE test_thread2(thrnum) IMPLICIT NONE ! ! Endlos-Thread sitzt in ConditionWait und wird von anderen Threads ! via SIGNAL geweckt um dann irgendeinen Unsinn zu machen ! Zusätzlich: Sperren und Freigeben einer globalen Variablen mittels ! Mutex Lock und Unlock ! Beenden des Endlos-Threads via PTHREAD_CANCEL in MAIN ! ! Verwendete Prozeduren: ! ! pthread_mutex_init Initialisierung der Mutexvariablen ! für pthread_cond_wait ! pthread_cond_wait Aufwachen des Threads mit Mutex ! pthread_mutex_lock WeckMutex locken für pthread_cond_wait ! pthread_mutex_unlock WeckMutex freigeben nach ! pthread_cond_wait INCLUDE 'GEN_INCL:ST(PThreads)' INTEGER *4 ThrCount RECORD /pthread_mutex_t/ SlowMutex RECORD /pthread_mutex_t/ WeckMutex RECORD /pthread_mutex_t/ CountMutex RECORD /pthread_cond_t/ WeckCond RECORD /pthread_cond_t/ CountCond COMMON /COM_Threads/ SlowMutex, WeckMutex, CountMutex, WeckCond, 1 CountCond, ThrCount RECORD /pthread_mutex_t/ WaitMutex Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

46. Posix Thread Beispiel – 10Endlos Thread, wird von main gestoppt CHARACTER * 8 CTime REAL *4 count /3.0/, x, y INTEGER *4 a, thrnum, I, IStatus IStatus = pthread_mutex_init(WaitMutex,) a = %LOC(thrnum) IStatus = 0 DO WHILE (IStatus .EQ. 0) x = SIN(count) Count = Count + 1 CALL Time (CTime) IStatus = pthread_mutex_lock(WaitMutex) IStatus = pthread_cond_wait(CountCond, WaitMutex) IStatus = pthread_mutex_unlock(WaitMutex) ! Bereich der globalen Variablen thrcount schuetzen IStatus = pthread_mutex_lock(CountMutex) thrCount = INT(Count) + 1 DO I =2,3 y = y+(y*(i+1)/(i-1)) ENDDO PRINT*,a,' y in Thread Typ 2',y PRINT*,a,' Absolute Anzahl in Thread Typ 2 ',thrcount IStatus = pthread_mutex_unlock(CountMutex) ENDDO RETURN END Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

47. Posix Thread Beispiel – 11test_thread3 - 1 SUBROUTINE test_thread3 (thrnum) IMPLICIT NONE ! ! Thread wird in MAIN gestartet und führt Berechnungen mit ! vielen Iterationsschritten durch. Getestet (demontriert) wird die ! Prioriätssteuerung (Scheduling) dieses Threads im Verhältnis ! zu den konkurrierenden Threads. ! INCLUDE 'GEN_INCL:ST(PThreads)' LOGICAL *4 Thread_Hold INTEGER *4 ThrCount RECORD /pthread_mutex_t/ SlowMutex RECORD /pthread_mutex_t/ WeckMutex RECORD /pthread_mutex_t/ CountMutex RECORD /pthread_cond_t/ WeckCond RECORD /pthread_cond_t/ CountCond COMMON /COM_Threads/ SlowMutex, WeckMutex, CountMutex, WeckCond, 1 CountCond, ThrCount CHARACTER *8 CTime REAL *4 x REAL *4 y /1.0/ INTEGER *4 a INTEGER *4 count1 /1/ INTEGER *4 count /3/ INTEGER *4 I INTEGER *4 thrnum Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

48. Posix Thread Beispiel – 12test_thread3 - 2 a = %LOC(thrnum) CALL TIME (CTime) PRINT *, a,' thread ',a,' gestartet um:',CTime DO count = 1, 999999 y = 1.0 x = sin(float(count)) DO I =3, 5 y = y+(y*(i+1)/(i)) ENDDO IF(MOD (count,10000) .EQ. 0) THEN PRINT*,a,' x = sin(float(count))',x,' count ',count PRINT*,a,' y in Thread Typ 3 ',y ENDIF ENDDO PRINT*,a,' y in Thread Typ 3 ',y PRINT*,a,' Fertig!..thread ',a RETURN END Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

49. Singlethread-Programme multithread-fähig machen (1) Konflikte zwischen Threads beim Gebrauch globaler Variablen Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads

50. Singlethread-Programme multithread-fähig machen (2) Threads können private globale Variablen haben Betriebssysteme und nebenläufige Anwendugen - Prozesse und Threads