Einführung in POSIX-Threads. WS 08/09 Universität Innsbruck

Transkript

1 Einführung in POSIX-Threads Betriebssysteme WS 08/09 Universität Innsbruck

2 Motivation für Nebenläufigkeit Klassischer Ansatz in Unix-Systemen Mehrere Prozesse durch fork()erzeugen Idee Vorteil Einfach Nachteile Verbraucht Ressourcen COW(Copy-on-write)-Verfahren reduziert diesen Verbrauch etwas Aufwändiger Context-Switch Nicht sehr flexibel (Rückgabe von Daten des Kindprozesses, IPC) Nur ein Prozess Aber mehrere Ausführungsstränge (Threads) Trennung Prozess entspricht einer Einheit für die Ressourcenverwaltung Thread entspricht einer Einheit für das Scheduling 2

3 Eigenschaften Threads allgemein (Wiederholung) Gemeinsame Ressourcen für alle Threads Adressraum OffeneDateien (Filedeskriptoren) Signal-Handler und -Einstellungen Benutzer- und Gruppenkennung Arbeitsverzeichnis Thread-eigene Elemente Eigene Thread-Kennung(Thread-ID) Eigene Kopie der Prozessorregister (einschließlich Programmzähler und Stackpointer Eigener Stack(für lokale Variablen und Rückgabeadressen) Eigene Signalmaske Eigene Priorität Eigene errno-variable 3

4 Arten von Threads Threads (Wiederholung) Benutzer-Threads (Green Threads) Kernel-Threads (Native Threads) Hybride Threads Anwendungen GUIs (Interaktion und Berechnungen im Hintergrund trennen) Server (z.b. ein Thread pro Aufruf) Multiprozessormaschinen ausnutzen Ereignisbasierte Systeme 4

5 Schnelle Erzeugung Vorteile von Threads (Wiederholung) Auch für fein-körnige Parallelisierung von kleinen Codeteilen geeignet Schnelles Context-Switching Gemeinsamer Speicher für schnelle Kommunikation Muss aber entsprechend synchronisiert werden Wenn ein Thread blockiert, können andere Threads weiterarbeiten (nur bei Kernel-Threads) Asynchrone Kommunikation mittels Threads ABER Kein Speicherschutz, d.h. Threads eines Prozesses sind nicht voneinander geschützt 5

6 POSIX-Threads In dieser Vorlesung werden die POSIX-Threads besprochen Der POSIX-Standard definiert eine einheitliche API für das Erzeugen und Manipulieren von Threads Unabhängig von der Implementierung Kann unterschiedlich sein (Kernel-Threads, Benutzer-Threads) Bibliotheken, die diese Threads implementieren, werden oft als Pthreads bezeichnet Verbreitung UNIX-Systeme wie Linux oder Solaris Auch Windows-Implementierung erhältlich Wichtige generelle Informationen Alle Thread-Funktionen und Datentypen sind in pthread.h deklariert Die Thread-Funktionen befinden sich nicht in der C-Standardbibliothek, sondern in libthread.so Daher muss man beim Linken lpthread angeben 6

7 Thread erzeugen int pthread_create( pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); Erzeugt und startet einen neuen Thread (Unterschied zu Java!) Nach erfolgreicher Erzeugung beginnt dieser Thread asynchron mit seiner Ausführung Return: 0 wenn ok, ansonsten Fehlercode (nicht-1 und nichtin errno gesetzt) threadzeigt auf die ID des neuen Threads attr spezifiziert bestimmte Attribute (Stackgröße, Priorität, ) - NULL wenn die Standardattribute benutzt werden start_routineist die Funktion, die der Thread aufruft wenn er gestartet wird. Nur ein Argument arg(void-pointer). 7

8 Zugriff auf ID pthread_t pthread_self(void); int pthread_equal(pthread_t t1, pthread_t t2); pthread_self retourniert die ID des aufrufenden Threads Hier sind keine Fehler definiert Ähnlich getpid() bei Prozessen pthread_equalgibt einen Wert ungleich 0 wenn Thread1 und Thread2 gleich sind, ansonsten 0 (keine Fehler definiert) 8

9 exit und cancel void pthread_exit(void *value_ptr); void pthread_cancel(pthread_t thread); pthread_exit terminiert die Ausführung des aktuellen Threads Explizites Terminieren Ein Thread terminiert immer, wenn er aus seiner Startroutine zurückkehrt value_ptrist der Rückgabewert des Threads (die von pthread_create aufgerufenen Funktion gibt void zurück!!) value_ptr kann von einem Thread, der pthread_join aufruft, benutzt werden pthread_cancel kann einen anderen Thread terminieren Vorsicht! 9

10 pthread_join int pthread_join(pthread_t thread, void **value_ptr); Auf Threads, die noch nicht detachaufgerufen haben, kann man mit pthread_joinwarten pthread_joinführt dazu, dass der Aufrufer auf das Beenden des angegebenen Threads wartet Ist vergleichbar mit waitpid bei Prozessen Der Rückgabewert des beendet Threads wird an die Adresse geschrieben auf die der Parameter value_ptrzeigt Wird nicht gewartet, dann bleiben die Thread-ID und der Exit- Status solange erhalten bis pthread_joinaufgerufen wird (vergleiche Zombie-Prozess) pthread_joinkann nur von einem Thread für eine bestimmte Thread-ID aufgerufen werden Nachfolgende Aufrufe resultieren in einem Fehler (von 0 verschiedener Rückgabewert) 10

11 pthread_detach int pthread_detach(pthread_t thread); Thread ist entweder verknüpfbar (joinable) oder eigenständig (detached) Wenn ein Thread beendet wird (Beendigung der ausgeführten Funktion), gibt er normalerweise noch nicht seine Ressourcen frei Dafür muss man detach aufrufen Dann werden die Thread-ID und der Exit-Status sofort freigegeben Aufruf von pthread_join nicht mehr möglich Um einen Thread bereits bei seiner Kreierung als abgehängten Thread festzulegen, steht das Thread-Attribut PTHREAD_CREATE_DETACHED zur Verfügung Wird auf einen Thread schon gewartet, dann hat dieser Funktionsaufruf keine Auswirkung 11

12 Beispiel (1) #include <stdio.h> #include <pthread.h> struct data { int nr; int zeit; }; void *rennen(void *arg) { int meter = 0, sek; struct data *data_zgr = (struct data *)arg; while (meter<50) { sleep( sek = rand()%3+1); data_zgr->zeit += sek; meter += 5; fprintf(stderr, "%*s%3d\n", data_zgr->nr * 15-7, " ", meter); } fprintf(stderr, "%*s\n", data_zgr->nr * 15, " "); } return arg; /* auch möglich: pthread_exit( arg ); */ 12

13 Beispiel (2) int main(void) { int i, j; pthread_t id[3]; Aufruf für Übersetzung (Programmname ist thread1.c) struct data *renner_daten[3]; gcc lpthread o thread1 thread1.c srand(time(null)); for (i=0; i<3; i++) renner_daten[i] = calloc( 1, sizeof(struct data) ); printf("%15s%15s%15s\n", "Laeufer 1", "Laeufer 2", "Laeufer 3"); printf(" \n"); for (i=0; i<3; i++) { renner_daten[i]->nr = i+1; pthread_create(&id[i], NULL, &rennen, renner_daten[i]); } for (i=0; i<3; i++) pthread_join(id[i], (void **)&renner_daten[i]); for (i=0; i<2; i++) for (j=i+1; j<3; j++) if (renner_daten[i]->zeit > renner_daten[j]->zeit) { struct data h = *renner_daten[i]; *renner_daten[i] = *renner_daten[j]; *renner_daten[j] = h; } fprintf(stderr, "Zieleinlauf:\n"); for (i=0; i<3; i++) fprintf(stderr, "%5d: Laeufer %d (%2d Sek.)\n", i+1, renner_daten[i]->nr, renner_daten[i]- >zeit); return 0; } 13

14 Ausgabe (Beipiele) Laeufer 1 Laeufer 2 Laeufer Zieleinlauf: 1: Laeufer 2 (14 Sek.) 2: Laeufer 3 (17 Sek.) 3: Laeufer 1 (20 Sek.) Laeufer 1 Laeufer 2 Laeufer Zieleinlauf: 1: Laeufer 1 (17 Sek.) 2: Laeufer 2 (20 Sek.) 3: Laeufer 3 (24 Sek.) 14

15 Nebenläufigkeit - Probleme Zugriff auf gemeinsame Ressourcen (z.b. Dateien oder globale Variablen) muss synchronisiert werden Ansonsten kann es zu Synchronisationsproblemen (raceconditions) kommen Dafür gibt es Mutexe Es existiert eine eigene Bibliothek dafür Wenn mehrere Threads mit der gleichen Funktion aufgerufen werden, dann führen sie den gleichen Code aus Wenn Funktionen in Threads aufgerufen werden, dann muss immer überprüft werden, ob diese thread-safe sind (man Seiten) 15

16 Mutexe Für die Synchronisation von Threads stehen sogenannte Mutexe zur Verfügung Mutexeerlauben es, Codeteile für andere Threads zu sperren, wenn ein Thread diesen Codeteilgerade ausführt (mutual exclusion) 2 Arten Statische Mutexe Dynamische Mutexe 16

17 Statische Mutexe int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); Ein Mutex hat den Datentyp pthread_mutex_t Ist eine Mutex-Variable statisch definiert, dann muss man diese mit der Konstante PTHREAD_MUTEX_INITIALIZER initialisieren pthread_mutex_lock Sperrt einen Mutex oder blockiert solange, bis der Mutex freigegeben wird pthread_mutex_unlock Gibt den Mutex wieder frei pthread_mutex_trylock Sperrt einen Mutex, wenn es frei ist Kehrt sofort wieder mit einem entsprechenden Fehlercode (EBUSY) zurück, wenn der Mutex schon gesperrt ist 17

18 int pthread_mutex_init( Dynamische Mutexe pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); int pthread_mutex_destroy(pthread_mutex_t *mutex); Dynamische Mutexewerden zum Beispiel benötigt, wenn sich die Mutex-Variable in einer Struktur befindet, zu der man sich mittels malloc einen Speicherbereich allokieren lassen möchte pthread_mutex_initinitialisiert den Mutexmutexmit den in mutexattr festgelegten Attributen Wird bei den Attributen NULLangegeben, dann werden die voreigenstellten Attribute verwendet pthread_mutex_destroylöscht einen mit pthread_mutex_initangelegten Mutexund gibt die belegten Ressourcen wieder frei 18

19 Einsatz von Mutexe Codeteile, die durch einen Mutexgeschützt werden, sollte nur so groß sein, wie notwendig 2 Punkte sollte man beachten Mutexemachen ein Programm langsamer Sperren und Freigeben kosten Zeit Mutexe serialisieren die Programmausführung Wenn Threads häufig auf Mutexezugreifen, werden Sie meist auch viel Zeit beim Zugreifen und Freigeben verbringen Es sollten nur notwendige Teile geschützt werden Mehreren kleinere Codeteile durch mehrere verschiedene Mutexe schützen Punkte 1 und 2 widersprechen sich Praktische Vorgehensweise Zuerst größere Codeteile durch Mutexe schützen Schrittweise Verkleinerung der Codeteile, wenn die Performance Probleme bereitet 19

20 Deadlocks und Backoff-Algorithmus Wenn zwei Threads gegenseitige Abhängigkeiten haben, dann können Deadlocks auftreten Threads versuchen nacheinander die gleichen Mutexe zu sperren Die Sperrreihenfolge unterscheidet sich, es gibt aber zyklische Abhängigkeiten Eine einfache Möglichkeit für die Vermeidung von Deadlocks bietet der sogenannte Backoff-Algorithmus Erster Mutex wird mit pthread_mutex_lock gesperrt Alle nachfolgenden Mutexe versucht man mit pthread_mutex_trylock zu sperren Ist ein Mutexgesperrt, dann werden rückwärtsalle zuvor gesperrten Mutexe wieder freigegeben 20

21 Beispiel (ohne Mutex) #include <pthread.h> #include <stdio.h> #define ANZAHL /* eventuell höher setzen */ int zaehler; /* wird durch die Threads hochgezählt */ void *zaehl_thread(void *); int main(void) { pthread_t id1, id2; pthread_create(&id1, NULL, &zaehl_thread, NULL); pthread_create(&id2, NULL, &zaehl_thread, NULL); pthread_join(id1, NULL); pthread_join(id2, NULL); fprintf(stderr, "zaehler = %d\n", zaehler); return 0; } void *zaehl_thread(void *unbenutzt) { int i, zahl; for (i=0; i<anzahl; i++) { zahl = zaehler; fprintf(stderr, "\r %7d", zahl+1); zaehler = zahl + 1; } fprintf(stderr, "... Thread %d fertig (zaehler = %d)\n", (int)pthread_self(), } zaehler); return NULL; Beispiel für Ausgabe: Thread fertig (zaehler = 48755) Thread fertig (zaehler = ) zaehler =

22 Beispiel (mit statischem Mutex) #include <pthread.h> #include <stdio.h> #define ANZAHL /* eventuell höher setzen */ int zaehler; /* wird durch die Threads hochgezählt */ pthread_mutex_t zaehler_mutex = PTHREAD_MUTEX_INITIALIZER; void *zaehl_thread(void *); int main(void) { pthread_t id1, id2; pthread_create(&id1, NULL, &zaehl_thread, NULL); pthread_create(&id2, NULL, &zaehl_thread, NULL); pthread_join(id1, NULL); pthread_join(id2, NULL); fprintf(stderr, "zaehler = %d\n", zaehler); return 0; } void *zaehl_thread(void *unbenutzt) { int i, zahl; for (i=0; i<anzahl; i++) { pthread_mutex_lock(&zaehler_mutex); zahl = zaehler; fprintf(stderr, "\r %7d", zahl+1); zaehler = zahl + 1; pthread_mutex_unlock(&zaehler_mutex); } } Beispiel für Ausgabe: Thread fertig (zaehler = ) Thread fertig (zaehler = ) zaehler = fprintf(stderr, "... Thread %d fertig (zaehler = %d)\n", (int)pthread_self(), zaehler); return NULL; 22

23 Bedingungsvariablen Mutexedienen nur zur Synchronisation des Zugriffs auf gemeinsame Ressourcen Manchmal möchte man beim Warten darüber informiert werden, dass eine bestimmte Bedingung eingetreten ist, durch die der Thread fortfahren kann Mit Bedingungsvariablen kann der Thread auf das Eintreten einer Bedingung warten Eine Bedingungsvariable hat immer den Typ pthread_cond_t Es gibt 2 Arten Statische Bedingungsvariablen Dynamische Bedingungsvariablen Ähnlich zu wait/notify in Java 23

24 Statische Bedingungsvariable Statische Bedingungsvariablen müssen mit PTHREAD_COND_INITIALIZER initialisiert werden int pthread_cond_wait( pthread_cond_t *cond, pthread_mutex_t *mutex); Der aufrufende Thread muss den Mutex mutex gesperrt haben Er gibt den Mutexfrei und wartet, bis die Bedingungvariableconderfüllt ist Beim Zurückkehren wird wieder automatisch die Sperre eingerichtet int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); Wartet nur eine bestimmte Zeitspanne Danach wird wieder die Sperre eingerichtet int pthread_cond_signal(pthread_cond_t *cond); Weckt einen wartenden Thread (für cond) auf (nach Priorität sortiert) int pthread_cond_broadcast(pthread_cond_t *cond); Weckt alle Threads auf, die auf cond warten 24

25 Wie bei Mutexe Dynamische Bedingungsvariable Wenn sich zum Beispiel die Bedingungsvariable in einer Struktur befindet 2 Funktionen int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr); Initialisierung der Bedingungsvariable cond attr legt die Attribute fest (NULL für Standardattribute) int pthread_cond_destroy(pthread_cond_t *cond); Löscht Bedingungsvariable Gibt belegte Ressourcen wieder frei 25

26 Beispiel (statische Bedingungsvariable) #include <pthread.h> #include <stdio.h> #include <unistd.h> #include <string.h> #define AMPEL_ZAHL 4 #define AMPEL_AUSGABE { \ int i; \ for (i=0; i<ampel_zahl; i++) \ fprintf(stderr, "%10s", farbe[i]); \ fprintf(stderr, "\n"); \ } pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER; char farbe[ampel_zahl][10]; void *ampel(void *kennung); int main(void) { pthread_t id[ampel_zahl]; int i; for (i=0; i<ampel_zahl; i++) { strcpy(farbe[i], "rot"); pthread_create(&id[i], NULL, &ampel, &i); } pthread_cond_signal(&cond); pthread_exit(null); } 26

27 Beispiel (statische Bedingungsvariable) void *ampel(void *kennung) { int i, nr = *(int *)kennung; for (i=1; i<=2; i++) { pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); } sleep(1); strcpy(farbe[nr], "gelb"); AMPEL_AUSGABE sleep(1); strcpy(farbe[nr], "gruen"); AMPEL_AUSGABE sleep(1); strcpy(farbe[nr], "gelb"); AMPEL_AUSGABE sleep(1); strcpy(farbe[nr], "rot"); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); } return NULL; Ausgabe: gelb rot rot rot gruen rot rot rot gelb rot rot rot rot gelb rot rot rot gruen rot rot rot gelb rot rot rot rot gelb rot rot rot gruen rot rot rot gelb rot rot rot rot gelb rot rot rot gruen rot rot rot gelb gelb rot rot rot gruen rot rot rot gelb rot rot rot rot gelb rot rot rot gruen rot rot rot gelb rot rot rot rot gelb rot rot rot gruen rot rot rot gelb rot rot rot rot gelb rot rot rot gruen rot rot rot gelb Beispiel aus: Helmut Herold, Linux/Unix Systemprogrammierung, Addison-Wesley, 3. Auflage (September 2004) ACHTUNG: Kann Deadlock produzieren! 27

28 Abbrechen von Threads (1) 3 Möglichkeiten für einen Thread auf eine Abbruchaufforderung zu reagieren Kein Abbruch Aufforderungen werden ignoriert, bleiben aber bestehen (später reagieren) pthread_setcancelstate(pthread_cancel_disable, ) pthread_setcancelstate(pthread_cancel_enable, ) Abbruch mit Verzögerung Thread läuft weiter und wird erst später (Abbruchpunkt) abgebrochen pthread_setcanceltype(pthread_cancel_deferred, ) Asynchroner Abbruch Thread beendet sich unmittelbar nach dem Empfang der Abbruchaufforderung pthread_setcanceltype(pthread_cancel_asynchronous, ) 28

29 2 Funktionen Abbrechen von Threads (2) int pthread_cancel(pthread_t id); Schickt Abbruchaufforderung an einen Thread void pthread_testcancel(void); Prüft ob Abbruchaufforderungen vorliegen Realisiert eigene Abbruchpunkte (weitere existieren bei bestimmten Funktionsaufrufen) Wenn ja, dann wird abgebrochen Exit-Handler Thread kann Exit-Handler installieren/deinstallieren (Aufräumarbeiten etc.) 2 Funktionen pthread_cleanup_push(void (*routine) (void *), void *arg); Installiert Funktion routine mit dem Argument arg pthread_cleanup_pop(int execute); Entfernt zuletzt installierten Exit-Handler Ist execute= 0, dann wird der Handler nur entfernt Ist execute!= 0, dann wird der Handler ausgeführt und entfernt 29

30 Notwendige POSIX-Erweiterungen Verwendung von Pthreadshat auch Auswirkung auf das traditionelle UNIX-Prozesskonzept fork Ruft ein Thread forkauf, dann existiert im Kindprozessnur der Thread, der fork aufrief Thread des Kindprozesseshat den selben Zustand wie der Thread im Elternprozess Hat zum Beispiel die gleichen Mutexe gesperrt Deadlock-Problematik bei Mutex-Variablen Anderer Thread hält eine Sperre auf einen Mutex Dieser Thread ist aber nach dem fork im Kindprozess nicht vorhanden Lösung Spezielle Funktion für das Registrieren von Handler-Funktionen 30

31 pthread_atfork( pthread_atfork void (*prepare)(void), void (*parent) (void), void (*child) (void)); Installiert Handler-Funktionen prepare Wird vom Elternprozess vor der Erzeugung des neuen Prozesses aufgerufen Hier sperrt man meist die betreffenden Mutexe parent Wird vom Elternprozess aufgerufen, unmittelbar bevor der fork-aufruf zurückkehrt Hier gibt man meist die in prepare geschlossenen Mutexe wieder frei child Wird vom Kindprozessaufgerufen, unmittelbar bevor der fork-aufruf zurückkehrt Meist identisch zu parent(mutexe freigeben) Mehrere Aufrufe prepare in LIFO-Ordnung parent und child in FIFO-Ordnung 31

32 exec Ersetzt den ganzen Prozess exec und exit Threads werden automatisch beendet Keine Exit-Handler werden ausgeführt Mutexe und Bedingungsvariablen verschwinden auch (außer das pshared- Attribut ist gesetzt) exit Alle Threads im entsprechenden Prozess werden beendet Wenn sich der main-thread beendet, werden auch alle Threads beendet 32

33 Thread-sichere und reentrant Funktionen C89-Funktionen wurden noch ohne Thread-Implementierung entwickelt Die meisten sind aber mittlerweile thread-sicher (thread-safe) gemacht worden Keine Prototyp-Änderung Können auch bei Threads verwendet werden Bei manchen Funktionen war eine thread-sichere Reimplementierungbei Beibehaltung der externen Schnittstelle nicht möglich Daher wurden thread-sichere Varianten eingeführt, die das Suffix _r am Ende ihres Namens haben Beispiele: strtok_r, rand_r etc. Diese Funktionen sind nicht nur thread-sicher sondern auch reentrant, da sie keine internen statischen Puffer verwenden Aufrufer muss Pufferadresse mitgeben, an die dann die Informationen geschrieben werden 33

34 Signale Jeder Thread kann eine eigene Signalmaske haben Setzen mit pthread_sigmask Beim Kreieren erbt ein Thread die Signalmaske des Threads, der ihn kreiert Vom main-thread können alle Threads erben Signal-Handler gelten aber prozessweit für alle Threads Signale, die von der Hardware geschickt werden, werden immer dem Thread geschickt, der sie auslöst Andere Signale werden einem beliebigen Thread geschickt An Threads können Signale mit pthread_kill geschickt werden Signale, die Auswirkung auf das Prozessverhalten haben, wirken sich bei pthread_kill immer auf den ganzen Prozess aus z. B. SIGKILL beendet den ganzen Prozess Um auf das Eintreffen eine Signals zu warten, stehen folgende Funktionen zur Verfügung sigwait, sigwaitinfo (setzt auch errno), sigtimedwait (setzt auch errno) 34

35 Semaphore Weitere Synchronisierungsmöglichkeiten Wurde schon in der IPC-Vorlesung kurz genannt In diesem Fall die Semaphore aus semaphore.h Read/Write-Sperren Mehrere gleichzeitige Leser erlaubt Nur ein Schreiber erlaubt Barrier Synchronisationspunkt, der erst dann freigegeben wird, wenn eine bestimmte Anzahl von Threads an dieser Barriere angekommen sind Spinlocks Zur Synchronisation auf Multiprozessorsystemen 35