Einführung in POSIX Threads
|
|
- Hans Esser
- vor 5 Jahren
- Abrufe
Transkript
1 Einführung in POSIX Threads Radu Prodan Institut für Informatik, Universität Innsbruck Verteilte und Parallele Systeme R. Prodan, Betriebssysteme, Sommersemester
2 Motivation für Nebenläufigkeit Klassischer Ansatz in UNIX-Systemen Mehrere Prozesse durch fork()erzeugen Vorteil: Einfach Nachteile o Verbraucht Ressourcen COW (Copy-on-Write)-Verfahren reduziert diesen Verbrauch etwas o Aufwändiger Context-Switch o Nicht sehr flexibel Rückgabe von Daten des Kindprozesses, IPC R. Prodan, Betriebssysteme, Sommersemester
3 Threadidee Nur ein Prozess Aber mehrere Ausführungsstränge (Threads) Trennung o Prozess entspricht einer Einheit für die Ressourcenverwaltung o Thread entspricht einer Einheit für das Scheduling R. Prodan, Betriebssysteme, Sommersemester
4 Thread Eigenschaften Gemeinsame Ressourcen für alle Threads o Adressraum o Offene Dateien (Filedeskriptoren) o Signal-Handler und Einstellungen o Benutzer- und Gruppenkennung o Arbeitsverzeichnis Thread-eigene Elemente o Eigene Thread-Kennung (Thread-ID) o Eigene Kopie der Prozessorregister (einschließlich Programmzähler und Stackpointer) o Eigener Stack (für lokale Variablen und Rückgabeadressen) o Eigene Signalmaske o Eigene Priorität o Eigene errno-variable R. Prodan, Betriebssysteme, Sommersemester
5 Threads (Wiederholung) Arten von Threads o Benutzer-Threads (Green Threads) o Kernel-Threads (Native Threads) o Hybride Threads Anwendungen o GUIs (Interaktion und Berechnungen im Hintergrund trennen) o Server (z.b. ein Thread pro Aufruf) o Multiprozessormaschinen ausnutzen o Ereignisbasierte Systeme R. Prodan, Betriebssysteme, Sommersemester
6 Vorteile von Threads Schnelle Erzeugung o Auch für fein-körnige Parallelisierung von kleinen Codeteilen geeignet Schnelles Context-Switching Gemeinsamer Speicher für schnelle Kommunikation o Muss aber entsprechend synchronisiert werden Wenn ein Thread blockiert, können andere Threads weiterarbeiten o Nur bei Kernel-Threads Asynchrone Kommunikation mittels Threads Nachteile o Kein Speicherschutz o Threads eines Prozesses sind nicht voneinander geschützt R. Prodan, Betriebssysteme, Sommersemester
7 POSIX-Threads Der POSIX-Standard definiert eine einheitliche API für das Erzeugen und Manipulieren von Threads o Unabhängig von der Implementierung o Kann unterschiedlich sein (Kernel-Threads, Benutzer-Threads) Bibliotheken, die diese Threads implementieren, werden oft als Pthreads bezeichnet Verbreitung o UNIX-Systeme wie Linux oder Solaris o Auch Windows-Implementierung erhältlich Wichtige generelle Informationen o Alle Thread-Funktionen und Datentypen sind in pthread.h deklariert o Die Thread-Funktionen befinden sich nicht in der C-Standardbibliothek, sondern in libpthread.so o Daher muss man beim Linken lpthread angeben R. Prodan, Betriebssysteme, Sommersemester
8 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!) o Nach erfolgreicher Erzeugung beginnt dieser Thread asynchron mit seiner Ausführung Rückgabewert o 0 wenn ok, ansonsten Fehlercode (nicht -1 und nicht in errno gesetzt) thread zeigt auf die ID des neuen Threads attr spezifiziert bestimmte Attribute o Stackgröße, Priorität, o NULL wenn die Standardattribute benutzt werden start_routine ist die Funktion, die der Thread aufruft wenn er gestartet wird o Nur ein void * Argument arg R. Prodan, Betriebssysteme, Sommersemester
9 Zugriff auf Thread-ID pthread_t pthread_self(void); int pthread_equal(pthread_t t1, pthread_t t2); pthread_self retourniert die ID des aufrufenden Threads o Hier sind keine Fehler definiert o Ähnlich getpid() bei Prozessen pthread_equal gibt einen Wert ungleich 0 wenn die Threads t1 und t2 gleich sind, ansonsten 0 o Keine Fehler definiert R. Prodan, Betriebssysteme, Sommersemester
10 exit und cancel void pthread_exit(void *value_ptr); void pthread_cancel(pthread_t thread); pthread_exit terminiert die Ausführung des aktuellen Threads o Explizites Terminieren o Ein Thread terminiert immer, wenn er aus seiner Startroutine zurückkehrt value_ptr ist der Rückgabewert des Threads o 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 o Vorsicht! R. Prodan, Betriebssysteme, Sommersemester
11 pthread_join int pthread_join(pthread_t thread, void **value_ptr); Auf Threads, die noch nicht detach aufgerufen haben, kann man mit pthread_join warten o pthread_join führt dazu, dass der Aufrufer auf das Beenden des angegebenen Threads wartet o Ist vergleichbar mit waitpid bei Prozessen o Der Rückgabewert des beendeten Threads wird an die Adresse geschrieben auf die der Parameter value_ptr zeigt Wird nicht gewartet, dann bleiben die Thread-ID und der Exit-Status solange erhalten bis pthread_join aufgerufen wird (vergleiche Zombie-Prozess) pthread_join kann nur von einem Thread für eine bestimmte Thread-ID aufgerufen werden o Nachfolgende Aufrufe resultieren in einem Fehler (von 0 verschiedener Rückgabewert) R. Prodan, Betriebssysteme, Sommersemester
12 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 o Dann werden die Thread-ID und der Exit-Status sofort freigegeben o 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 R. Prodan, Betriebssysteme, Sommersemester
13 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 ); */ R. Prodan, Betriebssysteme, Sommersemester
14 Beispiel (2) int main(void) { int i, j; pthread_t id[3]; struct data *renner_daten[3]; 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]); Aufruf für Übersetzung (Programmname ist thread1.c) gcc lpthread o thread1 thread1.c } 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; R. Prodan, Betriebssysteme, Sommersemester
15 Ausgabe (Beispiele) 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.) R. Prodan, Betriebssysteme, Sommersemester
16 Nebenläufigkeitsprobleme Zugriff auf gemeinsame Ressourcen (z.b. Dateien oder globale Variablen) muss synchronisiert werden Ansonsten kann es zu Synchronisationsproblemen kommen o Race conditions o Dafür gibt es Mutexe o 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 R. Prodan, Betriebssysteme, Sommersemester
17 Mutual Exclusion Für die Synchronisation von Threads stehen sogenannte Mutexe zur Verfügung Mutexe erlauben es, Codeteile für andere Threads zu sperren, wenn ein Thread diesen Codeteil gerade ausführt Zwei Arten o Statische Mutexe o Dynamische Mutexe R. Prodan, Betriebssysteme, Sommersemester
18 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 o Sperrt einen Mutex oder blockiert solange, bis der Mutex freigegeben wird pthread_mutex_unlock o Gibt den Mutex wieder frei pthread_mutex_trylock o Sperrt einen Mutex, wenn es frei ist o Kehrt sofort wieder mit einem entsprechenden Fehlercode (EBUSY) zurück, wenn der Mutex schon gesperrt ist R. Prodan, Betriebssysteme, Sommersemester
19 Dynamische Mutexe int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); int pthread_mutex_destroy(pthread_mutex_t *mutex); Dynamische Mutexe werden zum Beispiel benötigt, wenn sich die Mutex-Variable in einer Struktur befindet, zu der man sich mittels malloc einen Speicherbereich allozieren lassen möchte pthread_mutex_init initialisiert den Mutex mutex mit den in mutexattr festgelegten Attributen o Wird bei den Attributen NULL angegeben, dann werden die voreigenstellten Attribute verwendet pthread_mutex_destroy löscht einen mit pthread_mutex_init angelegten Mutex und gibt die belegten Ressourcen wieder frei R. Prodan, Betriebssysteme, Sommersemester
20 Einsatz von Mutexe Codeteile, die durch einen Mutex geschützt werden, sollte nur so groß sein, wie notwendig Mutexe machen ein Programm langsamer o Sperren und Freigeben kosten Zeit Mutexe serialisieren die Programmausführung o Wenn Threads häufig auf Mutexe zugreifen, werden Sie meist auch viel Zeit beim Zugreifen und Freigeben verbringen o Es sollten nur notwendige Teile geschützt werden o Mehreren kleinere Codeteile durch mehrere verschiedene Mutexe schützen Praktische Vorgehensweise o Zuerst größere Codeteile durch Mutexe schützen o Schrittweise Verkleinerung der Codeteile, wenn die Performanz Probleme bereitet R. Prodan, Betriebssysteme, Sommersemester
21 Deadlocks und Backoff-Algorithmus Wenn zwei Threads gegenseitige Abhängigkeiten haben, dann können Deadlocks auftreten o Threads versuchen nacheinander die gleichen Mutexe zu sperren o 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 o Erster Mutex wird mit pthread_mutex_lock gesperrt o Alle nachfolgenden Mutexe versucht man mit pthread_mutex_trylock zu sperren o Ist ein Mutex gesperrt, dann werden rückwärts alle zuvor gesperrten Mutexe wieder freigegeben R. Prodan, Betriebssysteme, Sommersemester
22 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; } } Beispiel für Ausgabe: Thread fertig (zaehler = 48755) Thread fertig (zaehler = ) zaehler = fprintf(stderr, "... Thread %d fertig (zaehler = %d)\n", (int) pthread_self(), zaehler); return NULL; R. Prodan, Betriebssysteme, Sommersemester
23 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; R. Prodan, Betriebssysteme, Sommersemester
24 Bedingungsvariablen Mutexe dienen 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 zwei Arten o Statische Bedingungsvariablen o Dynamische Bedingungsvariablen Ähnlich zu wait/notify in Java R. Prodan, Betriebssysteme, Sommersemester
25 Statische Bedingungsvariable Müssen mit PTHREAD_COND_INITIALIZER initialisiert werden int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); o Der aufrufende Thread muss den Mutex mutex gesperrt haben o Er gibt den Mutex frei und wartet, bis die Bedingungsvariable cond erfüllt ist o 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); o Wartet nur eine bestimmte Zeitspanne, danach wird wieder die Sperre eingerichtet int pthread_cond_signal(pthread_cond_t *cond); o Weckt einen wartenden Thread (für cond) auf (nach Priorität sortiert) int pthread_cond_broadcast(pthread_cond_t *cond); o Weckt alle Threads auf, die auf cond warten R. Prodan, Betriebssysteme, Sommersemester
26 Statische Bedingungsvariable: Schlechtes Beispiel #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, &el, &i); } pthread_cond_signal(&cond); pthread_exit(null); } R. Prodan, Betriebssysteme, Sommersemester
27 Statische Bedingungsvariable: Schlechtes Beispiel (2) 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_mutex_unlock(&mutex); pthread_cond_signal(&cond); } 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 R. Prodan, Betriebssysteme, Sommersemester
28 Dynamische Bedingungsvariable Wie bei Mutexe o Wenn sich zum Beispiel die Bedingungsvariable in einer Struktur befindet int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr); o Initialisierung der Bedingungsvariable cond o attr legt die Attribute fest (NULL für Standardattribute) int pthread_cond_destroy(pthread_cond_t *cond); o Löscht Bedingungsvariable o Gibt belegte Ressourcen wieder frei R. Prodan, Betriebssysteme, Sommersemester
29 Abbruchaufforderungen von Threads Kein Abbruch o Aufforderungen werden ignoriert, bleiben aber bestehen (später reagieren) o pthread_setcancelstate(pthread_cancel_disable, ) o pthread_setcancelstate(pthread_cancel_enable, ) Abbruch mit Verzögerung o Thread läuft weiter und wird erst später (Abbruchpunkt) abgebrochen o pthread_setcanceltype(pthread_cancel_deferred, ) Asynchroner Abbruch o Thread beendet sich unmittelbar nach dem Empfang der Abbruchaufforderung o pthread_setcanceltype(pthread_cancel_asynchronous, ) R. Prodan, Betriebssysteme, Sommersemester
30 Abbruchfunktionen von Threads int pthread_cancel(pthread_t id); o Schickt Abbruchaufforderung an einen Thread void pthread_testcancel(void); o Prüft ob Abbruchaufforderungen vorliegen o Realisiert eigene Abbruchpunkte (weitere existieren bei bestimmten Funktionsaufrufen) o Wenn ja, dann wird abgebrochen R. Prodan, Betriebssysteme, Sommersemester
31 Exit-Handler Eine Thread kann einen Exit-Handler installieren oder deinstallieren Der Exit-Handler wird zum Beispiel für Aufräumarbeiten verwendet pthread_cleanup_push(void (*routine) (void *), void *arg); o Installiert Funktion routine mit dem Argument arg pthread_cleanup_pop(int execute); o Entfernt zuletzt installierten Exit-Handler o Ist execute = 0, dann wird der Handler nur entfernt o Ist execute!= 0, dann wird der Handler ausgeführt und entfernt R. Prodan, Betriebssysteme, Sommersemester
32 Notwendige POSIX-Erweiterungen Verwendung von Pthreads hat auch Auswirkung auf das traditionelle UNIX-Prozesskonzept fork o Ruft ein Thread fork auf, dann existiert im Kindprozess nur der Thread, der fork aufrief o Thread des Kindprozesses hat den selben Zustand wie der Thread im Elternprozess Hat zum Beispiel die gleichen Mutexe gesperrt o 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 o Spezielle Funktion für das Registrieren von Handler-Funktionen o Hier gibt man meist die in prepare geschlossenen Mutexe wieder frei R. Prodan, Betriebssysteme, Sommersemester
33 pthread_atfork pthread_atfork (void (*prepare) (void), void (*parent) (void), void (*child) (void)); prepare o Wird vom Elternprozess vor der Erzeugung des neuen Prozesses aufgerufen o Hier sperrt man meist die betreffenden Mutexe parent o Wird vom Elternprozess aufgerufen, unmittelbar bevor fork zurückkehrt o Die von prepare gesperrte Mutexe werden freigegeben child o Wird vom Kindprozess aufgerufen, unmittelbar bevor der fork-aufruf zurückkehrt o Meist identisch zu parent (Mutexe freigeben) Mehrere Aufrufe o prepare in LIFO-Ordnung o parent und child in FIFO-Ordnung R. Prodan, Betriebssysteme, Sommersemester
34 exec und exit exec o Ersetzt den ganzen Prozess o Threads werden automatisch beendet o Keine Exit-Handlers werden ausgeführt o Mutexe und Bedingungsvariablen verschwinden auch (außer das pshared-attribut ist gesetzt) exit o Alle Threads im entsprechenden Prozess werden beendet o Wenn sich der main-thread beendet, werden auch alle Threads beendet R. Prodan, Betriebssysteme, Sommersemester
35 Thread-Sichere und Reentrant Funktionen C89-Funktionen wurden noch ohne Thread-Implementierung entwickelt Die meisten sind aber mittlerweile Thread-sicher gemacht worden o Keine Prototyp-Änderung o Können auch bei Threads verwendet werden Bei manchen Funktionen war eine Thread-sichere Reimplementierung bei Beibehaltung der externen Schnittstelle nicht möglich o Daher wurden Thread-sichere Varianten eingeführt, die das Suffix _r am Ende ihres Namens haben o Beispiele: strtok_r, rand_r, etc. o Diese Funktionen sind nicht nur Thread-sicher sondern auch reentrant, da sie keine internen statischen Puffer verwenden o Aufrufer muss Pufferadresse mitgeben, an die dann die Informationen geschrieben werden R. Prodan, Betriebssysteme, Sommersemester
36 Signale Jeder Thread kann eine eigene Signalmaske haben o Setzen mit pthread_sigmask o Beim Kreieren erbt ein Thread die Signalmaske des Threads, der ihn kreiert o 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 o An Threads können Signale mit pthread_kill geschickt werden o 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 o Um auf das Eintreffen eine Signals zu warten, stehen die sigwait, sigwaitinfo (setzt auch errno), sigtimedwait (setzt auch errno) zur Verfügung R. Prodan, Betriebssysteme, Sommersemester
37 Weitere Synchronisierungsmöglichkeiten Semaphore o Wurde schon in der IPC-Vorlesung kurz genannt o In diesem Fall die Semaphore aus semaphore.h Read/Write-Sperren o Mehrere gleichzeitige Leser erlaubt o Nur ein Schreiber erlaubt Barrier o Synchronisationspunkt, der erst dann freigegeben wird, wenn eine bestimmte Anzahl von Threads an dieser Barriere angekommen sind Spinlocks o Zur Synchronisation auf Multiprozessorsystemen R. Prodan, Betriebssysteme, Sommersemester
Einführung in POSIX-Threads. WS 08/09 Universität Innsbruck
Einführung in POSIX-Threads Betriebssysteme WS 08/09 Universität Innsbruck Motivation für Nebenläufigkeit Klassischer Ansatz in Unix-Systemen Mehrere Prozesse durch fork()erzeugen Idee Vorteil Einfach
MehrPThreads. Pthreads. Jeder Hersteller hatte eine eigene Implementierung von Threads oder light weight processes
PThreads Prozesse und Threads Ein Unix-Prozess hat IDs (process,user,group) Umgebungsvariablen Verzeichnis Programmcode Register, Stack, Heap Dateideskriptoren, Signale message queues, pipes, shared memory
MehrThreads Einführung. Zustände von Threads
Threads Einführung Parallelität : Zerlegung von Problemstellungen in Teilaufgaben, die parallelel ausgeführt werden können (einfachere Strukturen, eventuell schneller, Voraussetzung für Mehrprozessorarchitekturen)
MehrTafelübung zu BS 2. Threadsynchronisation
Tafelübung zu BS 2. Threadsynchronisation Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrTafelübung zu BS 2. Threadsynchronisation
Tafelübung zu BS 2. Threadsynchronisation Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrTafelübung zu BS 2. Threadsynchronisation
Tafelübung zu BS 2. Threadsynchronisation Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrU9-3 Vergleich von Thread-Konzepten. U9-2 Motivation von Threads. U9-3 Vergleich von Thread-Konzepten (2) U9-1 Überblick
U9 9. Übung U9 9. Übung U9-1 Überblick Besprechung Aufgabe 6 (printdir) Posix-Threads U9.1 User-Level Threads: Federgewichtige Prozesse Realisierung von Threads auf Anwendungsebene innerhalb eines Prozesses
MehrSoftwaresysteme I Übungen Jürgen Kleinöder Universität Erlangen-Nürnberg Informatik 4, 2007 U9.fm
U9 9. Übung U9 9. Übung U9-1 Überblick Besprechung Aufgabe 6 (printdir) Posix-Threads U9.1 U9-2 Motivation von Threads U9-2 Motivation von Threads UNIX-Prozesskonzept: eine Ausführungsumgebung (virtueller
MehrPOSIX-Threads. Aufgabe 9 SP - Ü U10.1
U10 10. Übung U10 10. Übung POSIX-Threads Aufgabe 9 U10.1 U10-1 Motivation von Threads U10-1 Motivation von Threads UNIX-Prozesskonzept: eine Ausführungsumgebung (virtueller Adressraum, Rechte, Priorität,...)
MehrI 7. Übung. I-1 Überblick. Besprechung Aufgabe 5 (mysh) Online-Evaluation. Posix Threads. Ü SoS I I.1
I 7. Übung I 7. Übung I-1 Überblick Besprechung Aufgabe 5 (mysh) Online-Evaluation Posix Threads I.1 I-2 Evaluation I-2 Evaluation Online-Evaluation von Vorlesung und Übung SOS zwei TANs, zwei Fragebogen
MehrShared-Memory Programmiermodelle
Shared-Memory Programmiermodelle mehrere, unabhängige Programmsegmente greifen direkt auf gemeinsame Variablen ( shared variables ) zu Prozeßmodell gemäß fork/join Prinzip, z.b. in Unix: fork: Erzeugung
MehrBetriebssysteme. Tafelübung 2. Thread-Synchronisation. Olaf Spinczyk.
Betriebssysteme Tafelübung 2. Thread-Synchronisation http://ess.cs.tu-dortmund.de/de/teaching/ss2016/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware
MehrBesprechung Aufgabe 1: Prozesse verwalten Fortsetzung Grundlagen C-Programmierung Aufgabe 2: Threadsynchronisation
Betriebssysteme Tafelübung 2. Thread-Synchronisation http://ess.cs.tu-dortmund.de/de/teaching/ss2016/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware
MehrThreads. Foliensatz 8: Threads Folie 1. Hans-Georg Eßer, TH Nürnberg Systemprogrammierung, Sommersemester 2015
Sep 19 14:20:18 amd64 sshd[20494]: Accepted rsa for esser from ::ffff:87.234.201.207 port 61557 Sep 19 14:27:41 amd64 syslog-ng[7653]: STATS: dropped 0 Sep 20 01:00:01 amd64 /usr/sbin/cron[29278]: (root)
MehrU8-1 Motivation von Threads. U8-2 Vergleich von Thread-Konzepten. U8-2 Vergleich von Thread-Konzepten (2) Motivation
U8 POSIX-Threads U8 POSIX-Threads U8-1 Motivation von Threads U8-1 Motivation von Threads Motivation Thread-Konzepte UNIX-Prozesskonzept: eine Ausführungsumgebung (virtueller Adressraum, Rechte, Priorität,...)
MehrU8 POSIX-Threads U8 POSIX-Threads
U8 POSIX-Threads U8 POSIX-Threads Motivation Thread-Konzepte pthread-api pthread-koordinierung U8.1 U8-1 Motivation von Threads U8-1 Motivation von Threads UNIX-Prozesskonzept: eine Ausführungsumgebung
MehrPthreads. David Klaftenegger. Seminar: Multicore Programmierung Sommersemester
Seminar: Multicore Programmierung Sommersemester 2009 16.07.2009 Inhaltsverzeichnis 1 Speichermodell 2 3 Implementierungsvielfalt Prioritätsinversion 4 Threads Speichermodell Was sind Threads innerhalb
MehrÜbungen zu Systemprogrammierung 1
Übungen zu Systemprogrammierung 1 Ü5 Threads und Koordinierung Sommersemester 2018 Christian Eichler, Jürgen Kleinöder Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl
MehrLinux Prinzipien und Programmierung
Linux Prinzipien und Programmierung Dr. Klaus Höppner Hochschule Darmstadt Sommersemester 2014 1 / 28 Kritische Bereiche bei Threads Deadlocks Conditions/Semaphore 2 / 28 Beispiel aus der letzten Vorlesung
MehrConcurrency and Processes of Pthreads
Concurrency and Processes of Pthreads Pthreads Pthreads is a POSIX standard for describing a thread model, it specifies the API and the semantics of the calls. POSIX: Portable Operating System Interface
MehrPOSIX Solaris thread management pthread_create thr_create pthread_exit thr_exit pthread_kill thr_kill pthread_self thr_self
Kapitel 5 threads Unter einem thread versteht die Folge von Anweisungen (Adressen im Programmspeicher) die einem Programm entsprechen. Im Normalfall ist dies ein gleichbleibender Strom von Anweisungen.
MehrVorlesung Betriebssysteme I
1 / 22 Vorlesung Betriebssysteme I Thema 8: Threads (Aktivitäten, die zweite) Robert Baumgartl 25. Januar 2018 Threads (Leichtgewichtsprozesse) 2 / 22 Prozess = Container für Ressourcen + (ein) identifizierbarer
MehrEchtzeitbetriebssysteme (am Beispiel QNX) Dr. Stefan Enderle HS Esslingen
Echtzeitbetriebssysteme (am Beispiel QNX) Dr. Stefan Enderle HS Esslingen 3. QNX Neutrino Microkernel 3.1 Einführung Der Neutrino-Kernel (Betriebssystemkern) implementiert (nur) die wichtigsten Teile des
MehrÜbungen zu Systemprogrammierung 1 (SP1)
Übungen zu Systemprogrammierung 1 (SP1) Ü5 Threads und Koordinierung Andreas Ziegler, Stefan Reif, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
MehrÜbungen zu Systemprogrammierung 1 (SP1)
Übungen zu Systemprogrammierung 1 (SP1) Ü7 Threads und Koordinierung Jens Schedel, Christoph Erhardt, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
MehrÜbungen zu Systemnahe Programmierung in C (SPiC) Sommersemester 2018
Übungen zu Systemnahe Programmierung in C (SPiC) Sommersemester 2018 Übung 10 Benedict Herzog Sebastian Maier Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl für
MehrInhalt. Übungen zu Systemnahe Programmierung in C (SPiC) Inhalt. Motivation
Übungen zu Systemnahe Programmierung in C (SPiC) Sebastian Maier (Lehrstuhl Informatik 4) Übung 0 Inhalt vs. Prozesse POSIX Stoppuhr Sommersemester 206 Lehrstuhl Informatik 4 Übungen zu SPiC (SS 206) 2
MehrThreads. Netzwerk - Programmierung. Alexander Sczyrba Jan Krüger
Netzwerk - Programmierung Threads Alexander Sczyrba asczyrba@cebitec.uni-bielefeld.de Jan Krüger jkrueger@cebitec.uni-bielefeld.de Übersicht Probleme mit fork Threads Perl threads API Shared Data Mutexes
MehrAufgabe 9: recgrep rekursive, parallele Suche (letzte Aufgabe)
U6 6. Übung (Mathematik / Technomathematik) U6 6. Übung (Mathematik / Technomathematik) Besprechung Aufgabe 4 (halde) Besprechung Aufgabe 5 (crawl) Besprechung der Mini-Klausur POSIX-Threads Motivation
MehrÜbungen zu Systemnahe Programmierung in C (SPiC)
Übungen zu Systemnahe Programmierung in C (SPiC) Sebastian Maier (Lehrstuhl Informatik 4) Übung 10 Sommersemester 2016 Inhalt Threads Motivation Threads vs. Prozesse Kritische Abschnitte Speedup & Amdahl
MehrÜbungen zu Systemnahe Programmierung in C (SPiC) Inhalt. Sebastian Maier (Lehrstuhl Informatik 4) Übung 10. Sommersemester 2016
Übungen zu Systemnahe Programmierung in C (SPiC) Sebastian Maier (Lehrstuhl Informatik 4) Übung 10 Sommersemester 2016 Inhalt Motivation vs. Prozesse Kritische Abschnitte Speedup & Amdahl s Gesetz POSIX
MehrBesprechung Aufgabe 5 (crawl) POSIX-Threads. Problem: UNIX-Prozesskonzept ist für viele heutige Anwendungen unzureichend
U7 6. Übung U7 6. Übung U7-1 Motivation von Threads U7-1 Motivation von Threads Besprechung Aufgabe 5 (crawl) OSIX-Threads Motivation Thread-Konzepte pthread-ai Koordinierung UNIX-rozesskonzept: eine Ausführungsumgebung
MehrU6-1 Organisatories. U6-2 Motivation von Threads. U6-3 Vergleich von Thread-Konzepten. Organisatorisches
U6 6. Übung U6 6. Übung U6-1 Organisatories U6-1 Organisatories Organisatorisches Zusätzliche Tafelübung zur S1-Klaurvorbereitung Besprechung Aufgabe 5 (crawl) OSIX-Threads Motivation Thread-Konzepte am
MehrMultithread Programming
Vorlesung Rechnerarchitektur 2 Seite 150 Threads versus Processes Processes execute in separate address spaces (schwergewichtige Prozesse) communicate via IPC mechanisms (sockets, pipes, signals) Thread
MehrBetriebssysteme. Agenda. Tafelübung 3. Deadlock. Olaf Spinczyk.
Betriebssysteme Tafelübung 3. Deadlock http://ess.cs.tu-dortmund.de/de/teaching/ss2016/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware Informatik
MehrSystemnahe Programmierung in C Übungen Jürgen Kleinöder, Michael Stilkerich Universität Erlangen-Nürnberg Informatik 4, 2011 U7.fm
U7 POSIX-Prozesse U7 POSIX-Prozesse Prozesse POSIX-Prozess-Systemfunktionen Aufgabe 7 U7.1 U7-1 Prozesse: Überblick U7-1 Prozesse: Überblick Prozesse sind eine Ausführumgebung für Programme haben eine
MehrÜbungen zu Systemprogrammierung 1 (SP1)
Übungen zu Systemprogrammierung 1 (SP1) Ü5 Threads und Koordinierung Christian Eichler, Andreas Ziegler, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
MehrMarkus Klußmann, Amjad Saadeh Institut für Informatik. Pthreads. von Markus Klußmann und Amjad Saadeh. Pthreads
Markus Klußmann, Amjad Saadeh Institut für Informatik Pthreads von Markus Klußmann und Amjad Saadeh Pthreads Inhalt - Was sind Threads? - Prozess vs. Thread - Kurzer Überblick POSIX - Threads im Betriebssystem
MehrU7 POSIX-Prozesse U7 POSIX-Prozesse
U7 POSIX-Prozesse U7 POSIX-Prozesse Prozesse POSIX-Prozess-Systemfunktionen Aufgabe 6 U7.1 U7-1 Prozesse: Überblick U7-1 Prozesse: Überblick Prozesse sind eine Ausführumgebung für Programme haben eine
MehrEine Mini-Shell als Literate Program
Eine Mini-Shell als Literate Program Hans-Georg Eßer 16.10.2013 Inhaltsverzeichnis 1 Eine Mini-Shell 1 1.1 Einen Befehl parsen......................... 2 1.2 Was tun mit dem Kommando?...................
MehrKlausur Betriebssysteme I
Prof. Dr. Michael Jäger FB MNI Klausur Betriebssysteme I 18.3.2011 Bitte bearbeiten Sie die Aufgaben auf den Aufgabenblättern. Die Benutzung von Unterlagen oder Hilfsmitteln ist nicht erlaubt. Die Bearbeitungszeit
MehrUser-Level-Threads (Koroutinen) Realisierung von Threads auf Benutzerebene innerhalb eines Prozesses
52 Überblick über die 12. Übung Überblick über die 12. Übung 54 Vergleich von Prozeß und Thread-Konzepten mehrere UNIX-Prozesse mit gemeinsamen Speicherbereichen POSIX-Threads Bewertung: + echte Parallelität
MehrPROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN
PROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN 2. UNIX/Linux-Prozessverwaltung und zugehörige Systemaufrufe Wintersemester 2016/17 2. Die UNIX/LINUX-Prozessverwaltung Aufgaben: 1. Erzeugen neuer Prozesse
MehrLeseprobe. Kapitel 12:»Threads« Inhaltsverzeichnis. Index. Die Autoren. Leseprobe weiterempfehlen.
Wissen, wie s geht. Leseprobe»Linux-Unix-Programmierung«deckt alle Bereiche ab, die für die Entwicklung von Anwendungen für die Linux-Welt wichtig sind, C-Kenntnisse vorausgesetzt. Diese Leseprobe enthält
MehrAufgabenblatt 5 Musterlösung
Prof. Dr. rer. nat. Roland Wismüller Aufgabenblatt 5 Musterlösung Vorlesung Betriebssysteme I Wintersemester 2017/18 Aufgabe 1: Implementierung von Threads (Bearbeitung zu Hause) Der größte Vorteil ist
MehrAlle Fäden in der Hand
Alle Fäden in der Hand Thread Programmierung unter Linux in C und C++ (Teil 1) Wolfgang Schreiner Threads (zu deutsch "Fäden") ermöglichen die gleichzeitige Ausführung von mehreren Programmpfaden innerhalb
MehrOperating Systems Principles. Eventund. Threadbasierte Programmierung
Humboldt University Computer Science Department Operating Systems Principles Eventund Threadbasierte Programmierung Aufgabe 2 Wochen Zeit zum Lösen der Aufgaben Aufgabenstellung auf der SAR Website Abgabe
MehrHomogene Multi-Core-Prozessor-Architekturen
Homogene Multi-Core-Prozessor-Architekturen Praktikum Parallele Rechnerarchitekturen Stefan Potyra Lehrstuhl für Informatik 3 (Rechnerarchitektur) Friedrich-Alexander-Universität Erlangen-Nürnberg WS 2009
MehrLinux Prinzipien und Programmierung
Linux Prinzipien und Programmierung Dr. Klaus Höppner Hochschule Darmstadt Wintersemester 2010/2011 1 / 18 2 / 18 fork und Daten Nach dem fork teilen sich Eltern- und Kindprozess zwar den Programmbereich
MehrÜbungen zu Systemprogrammierung 2 (SP2)
Übungen zu Systemprogrammierung 2 (SP2) Ü6 Mehrfädige Programme Christoph Erhardt, Jens Schedel, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
Mehre) Welche Aussage zu Speicherzuteilungsverfahren ist falsch?
Aufgabe 1: (1) Bei den Multiple-Choice-Fragen ist jeweils nur eine richtige Antwort eindeutig anzukreuzen. Auf die richtige Antwort gibt es die angegebene Punktzahl. Wollen Sie eine Multiple-Choice-Antwort
Mehrfork () Hans-Georg Eßer, Hochschule München Betriebssysteme I, SS 2008 2. Prozesse (2/2) Folie 4
Sep 19 14:20:18 amd64 sshd[20494]: Accepted rsa for esser from ::ffff:87.234.201.207 port 61557 Sep 19 14:27:41 amd64 syslog-ng[7653]: SAS: dropped 0 Sep 20 01:00:01 amd64 /usr/sbin/cron[29278]: (root)
MehrAufgabenblatt 6 Musterlösung
Prof. Dr. rer. nat. Roland Wismüller Aufgabenblatt 6 Musterlösung Vorlesung Betriebssysteme I Wintersemester 2018/19 Aufgabe 1: Implementierung von Threads (Bearbeitung zu Hause) Der größte Vorteil ist
MehrLehrstuhl für Datenverarbeitung. Technische Universität München. Leistungskurs C++ Multithreading
Leistungskurs C++ Multithreading Threading mit Qt Plattformübergreifende Thread-Klasse Sehr einfach zu benutzen Leider etwas schlecht dokumentiert Leistungskurs C++ 2 QThread Plattformübergreifende Thread-Klasse
MehrLehrstuhl für Datenverarbeitung. Technische Universität München. Leistungskurs C++ Multithreading
Leistungskurs C++ Multithreading Threading mit Qt Plattformübergreifende Thread-Klasse Sehr einfach zu benutzen Leider etwas schlecht dokumentiert Leistungskurs C++ 2 QThread Plattformübergreifende Thread-Klasse
MehrTafelübung zu BS 1. Prozesse, Shell
Tafelübung zu BS 1. Prozesse, Shell Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2012/bs/
MehrLehrstuhl für Datenverarbeitung. Technische Universität München. Leistungskurs C++ Multithreading
Leistungskurs C++ Multithreading Zeitplan 16.10. Vorlesung 23.10. Vorlesung, Gruppeneinteilung 30.10. Vorlesung, HA1 06.11. Vorlesung, HA2 13.11. Vorlesung entfällt wegen SVV 20.11. Präsentation Vorprojekt
Mehr(Ausnahmebehandlung)
16. Exceptions (Ausnahmebehandlung) 16-1 Objektorientierte Programmierung (Winter 2010/2011) Kapitel 16: Exceptions (Ausnahmebehandlung) Motivation Throw und Catch 16. Exceptions (Ausnahmebehandlung) 16-2
MehrPthreads. David Klaftenegger. Seminar: Multicore Programmierung Sommersemester
Pthreads David Klaftenegger Seminar: Multicore Programmierung Sommersemester 2009 16.07.2009 1 Inhaltsverzeichnis 1 Einführung 3 1.1 Pthreads.............................. 3 1.2 Speichermodell..........................
MehrSequentielle Programm- / Funktionsausführung innerhalb eines Prozesses ( thread = Ausführungsfaden )
Threads Sequentielle Programm- / Funktionsausführung innerhalb eines Prozesses ( thread = Ausführungsfaden ) Ein thread bearbeitet eine sequentielle Teilaufgabe innerhalb eines Prozesses Mehrere nebenläufige
MehrGlobale Variablen Diverses. Globale Variablen. Globale Variablen
lokale Variablen Variablen bisher nur am Anfang von Funktionen auch erlaubt: am Anfang innerer Codeblöcke (innerhalb geschweifter Klammern) in C99 und als gcc-erweiterung: an beliebiger Stelle innerhalb
MehrAufgabe 6: palim rekursive, parallele Suche nach einer Zeichenkette
U6 6. Übung U6 6. Übung Besprechung Aufgabe 4 (halde) OSIX-Threads Motivation Thread-Konzepte pthread-ai Koordinierung Aufgabe 6: palim rekursive, parallele Suche nach einer Zeichenkette U6.1 U6-1 Motivation
MehrParallele Prozesse. Prozeß wartet
Parallele Prozesse B-66 Prozeß: Ausführung eines Programmes in seinem Adressraum (zugeordneter Speicher) Parallele Prozesse: gleichzeitig auf mehreren Prozessoren laufende Prozesse p1 p2 verzahnte Prozesse:
MehrTafelübung zu BS 1. Prozesse, Shell
Tafelübung zu BS 1. Prozesse, Shell Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2012/bs/
MehrWas ist ein Prozess?
Prozesse unter UNIX Definition Was ist ein Prozess? Zeitliche Abfolge von Aktionen Ein Programm, das ausgeführt wird Prozesshierachie Baumstruktur INIT-Prozess ist die Wurzel (pid=1) und wird beim Booten
MehrTafelübung zu BSRvS 1 1. Prozesse, at
Tafelübung zu BSRvS 1 1. Prozesse, at Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os http://ess.cs.tu-dortmund.de/de/teaching/ss2009/bsrvs1/
MehrTesten nebenläufiger Objekte
Testen nebenläufiger Objekte Threads in Java Julian Lambertz Seminar Tests in Informatik und Statistik im SS 2004 Universität Ulm J.L., Juni 2004 1 Themenüberblick Einleitung Begriff der Nebenläufigkeit
MehrJavakurs für Fortgeschrittene
Javakurs für Fortgeschrittene Einheit 07: Nebenläufigkeit Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme Heutige Agenda Einführung in die Nebenläufigkeit und Java Thread Konzept: Motivation
MehrÜbungen zu Systemnahe Programmierung in C (SPiC) Inhalt. Moritz Strübe, Rainer Müller (Lehrstuhl Informatik 4) Sommersemester 2014
Übungen zu Systemnahe Programmierung in C (SPiC) Moritz Strübe, Rainer Müller (Lehrstuhl Informatik 4) Sommersemester 2014 Inhalt Prozesse System-Schnittstelle Aufgabe 7 Einlesen von der Standard-Eingabe
MehrTafelübung zu BSRvS 1 3. Kreuzung
Tafelübung zu BSRvS 1 3. Kreuzung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2009/bsrvs1/
MehrEinführung in die Programmiersprache C
Einführung in die Programmiersprache C 4 Storage classes Alexander Sczyrba Robert Homann Georg Sauthoff Universität Bielefeld, Technische Fakultät Compilation units Compilierung eines mehrteiligen Programms:
MehrInhaltsverzeichnis. Carsten Vogt. Nebenläufige Programmierung. Ein Arbeitsbuch mit UNIX/Linux und Java ISBN:
Inhaltsverzeichnis Carsten Vogt Nebenläufige Programmierung Ein Arbeitsbuch mit UNIX/Linux und Java ISBN: 978-3-446-42755-6 Weitere Informationen oder Bestellungen unter http://www.hanser.de/978-3-446-42755-6
Mehr2A Basistechniken: Lösungen 2A.1 Wissens- und Verständnisfragen
2A Basistechniken: Lösungen 2A.1 Wissens- und Verständnisfragen 1.a.) Application Programming Interface 1.b.) Multiprogramming 1.c.) Mehreren Prozessoren, die über einen Bus miteinander verbunden sind
MehrObjektorientierte Programmierung
Objektorientierte Programmierung Ausnahmebehandlung und Nebenläufigkeit 9. Vorlesung am 15. Dezember 2010 Ausnahmebehandlung in Java class A { void foo() throws Help, SyntaxError {... class B extends A
MehrRTEMS- Echtzeitbetriebssystem
RTEMS- Echtzeitbetriebssystem Name: Hussein Hammoud Matrikel- Nr.: 230768 Studiengang: Technische Informatik Fach: Projekt Eingebettete Kommunikation Technische Universität Berlin Sommersemester 2006 RTEMS-
Mehr6 Speicherorganisation
Der Speicher des Programms ist in verschiedene Speicherbereiche untergliedert Speicherbereiche, die den eigentlichen Programmcode und den Code der Laufzeitbibliothek enthalten; einen Speicherbereich für
MehrÜbung zu Grundlagen der Betriebssysteme. 10. Übung 18.12.2012
Übung zu Grundlagen der Betriebssysteme 10. Übung 18.12.2012 Aufgabe 1 a) Was versteht man unter einem kritischen Abschnitt oder kritischen Gebiet (critical area)? b) Welche Aufgabe hat ein Semaphor? c)
MehrInstitut für Informatik der Ludwig-Maximilians-Universität München Systempraktikum Wintersemester 2009/2010 Prof. Dr. Dieter Kranzlmüller Dr. Thomas S
Institut für Informatik der Ludwig-Maximilians-Universität München Systempraktikum Wintersemester 2009/2010 Prof. Dr. Dieter Kranzlmüller Dr. Thomas Schaaf, Dr. Nils gentschen Felde Blatt 3 Grundlagen
MehrU3 UNIX-Signale U3 UNIX-Signale
U3 UNIX-Signale U3 UNIX-Signale Besprechung der Aufgabe 2: sister Nebenläufigkeit durch Signale Aktives Warten auf Ereignisse Probleme beim passiven Warten (auf Signale) Nachtrag zur Signalbehandlungsschnittstelle
Mehr1 Fehler in Bibliotheksfunktionen. 1 Überblick. 2 Ziele der Aufgabe. Besprechung der 1. Aufgabe
U3 3. Übung U3 3. Übung U3-1 Fehlerbehandlung U3-1 Fehlerbehandlung Besprechung der 1. Aufgabe Fehlerbehandlung Infos zur Aufgabe 3: malloc-implementierung U3.1 Fehler können aus unterschiedlichsten Gründen
MehrWas machen wir heute? Betriebssysteme Tutorium 3. Organisatorisches. Prozesskontrollblock (PCB) Programmieraufgaben. Frage 3.1.a
Was machen wir heute? Betriebssysteme Tutorium 3 Philipp Kirchhofer philipp.kirchhofer@student.kit.edu http://www.stud.uni-karlsruhe.de/~uxbtt/ Lehrstuhl Systemarchitektur Universität Karlsruhe (TH) 1
MehrEinführung in die Programmiersprache C
Einführung in die Programmiersprache C 4 Storage classes Alexander Sczyrba Robert Homann Georg Sauthoff Universität Bielefeld, Technische Fakultät Compilation units Compilierung eines mehrteiligen Programms:
MehrG 5. Übung. G-1 Überblick. Besprechung 3. Aufgabe. Infos zur Aufgabe 5: fork, exec. Rechenzeiterfassung. Ü SoS I G.1
G 5. Übung G 5. Übung G-1 Überblick Besprechung 3. Aufgabe Infos zur Aufgabe 5: fork, exec Rechenzeiterfassung G.1 G-2 Hinweise zur 5. Aufgabe G-2 Hinweise zur 5. Aufgabe Prozesse fork, exec exit wait
MehrSystemprogrammierung
Systemprogrammierung 3Vom C-Programm zum laufenden Prozess 6. November 2008 Jürgen Kleinöder Universität Erlangen-Nürnberg Informatik 4, 2008 SS 2006 SOS 1 (03-Pro.fm 2008-11-06 08.52) 3 Vom C-Programm
MehrProgrammiertechnik. Teil 4. C++ Funktionen: Prototypen Overloading Parameter. C++ Funktionen: Eigenschaften
Programmiertechnik Teil 4 C++ Funktionen: Prototypen Overloading Parameter C++ Funktionen: Eigenschaften Funktionen (Unterprogramme, Prozeduren) fassen Folgen von Anweisungen zusammen, die immer wieder
MehrTafelübung zu BS 1. Prozesse, ToothBrush
Tafelübung zu BS 1. Prozesse, ToothBrush Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrHeap vs. Stack vs. statisch. 6 Speicherorganisation. Beispiel Statische Variablen. Statische Variablen
Heap vs. vs. statisch Der Speicher des Programms ist in verschiedene Speicherbereiche untergliedert Speicherbereiche, die den eigentlichen Programmcode und den Code der Laufzeitbibliothek enthalten; einen
Mehreinlesen n > 0? Ausgabe Negative Zahl
1 Lösungen Kapitel 1 Aufgabe 1.1: Nassi-Shneiderman-Diagramm quadratzahlen Vervollständigen Sie das unten angegebene Nassi-Shneiderman-Diagramm für ein Programm, welches in einer (äußeren) Schleife Integer-Zahlen
MehrÜbungen zu Systemprogrammierung 1
Übungen zu Systemprogrammierung 1 Ü1-2 Speicherverwaltung Sommersemester 2018 Christian Eichler, Jürgen Kleinöder Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl
MehrKlausur Betriebssysteme I
Prof. Dr. Michael Jäger FB MNI Klausur Betriebssysteme I 14.3.2008 Bitte bearbeiten Sie die Aufgaben auf den Aufgabenblättern. Die Benutzung von Unterlagen oder Hilfsmitteln ist nicht erlaubt. Die Bearbeitungszeit
MehrHeap vs. Stack vs. statisch. 6 Speicherorganisation. Beispiel Statische Variablen. Statische Variablen
Heap vs. vs. statisch Der Speicher des Programms ist in verschiedene Speicherbereiche untergliedert Speicherbereiche, die den eigentlichen Programmcode und den Code der Laufzeitbibliothek enthalten; einen
MehrLinux Prinzipien und Programmierung
Linux Prinzipien und Programmierung Dr. Klaus Höppner Hochschule Darmstadt Sommersemester 2014 1 / 28 2 / 28 Motivation für Betrachten Sie folgendes Programm: #include #include
MehrProgrammierung mit C Zeiger
Programmierung mit C Zeiger Zeiger (Pointer)... ist eine Variable, die die Adresse eines Speicherbereichs enthält. Der Speicherbereich kann... kann den Wert einer Variablen enthalten oder... dynamisch
MehrPROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN
PROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN 2. UNIX/Linux-Prozessverwaltung und zugehörige Systemaufrufe Wintersemester 2015/16 2. Die UNIX/LINUX-Prozessverwaltung Aufgaben: 1. Erzeugen neuer Prozesse
MehrBetriebssysteme. G: Parallele Prozesse. (Teil B: Klassische Problemstellungen, Mutual Exclusion, kritische Regionen)
Betriebssysteme G: Parallele Prozesse (Teil B: Klassische Problemstellungen, Mutual Exclusion, kritische Regionen) 1 Allgemeine Synchronisationsprobleme Wir verstehen ein BS als eine Menge von parallel
MehrDynamische Speicherverwaltung
Dynamische Speicherverwaltung 1/ 23 Dynamische Speicherverwaltung Tim Dobert 17.05.2013 Dynamische Speicherverwaltung 2/ 23 Gliederung 1 Allgemeines zur Speichernutzung 2 Ziele und Nutzen 3 Anwendung in
Mehr6 Speicherorganisation
6 Speicherorganisation Der Speicher des Programms ist in verschiedene Speicherbereiche untergliedert Speicherbereiche, die den eigentlichen Programmcode und den Code der Laufzeitbibliothek enthalten; einen
Mehr