Alle Tabs der Lerneinheit (Erklärung · Interaktiv verstehen · Praxis-Übung · Klausur-Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Teil 1·Erklärung
Diese Lerneinheit wurde für typische Bachelor-Klausuren konzipiert. So prüfen wir · Fehler entdeckt? Melde ihn uns oder markiere die fragliche Stelle direkt im Text oben.
Alle Tabs der Lerneinheit (Erklärung · Interaktiv verstehen · Praxis-Übung · Klausur-Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Warum stürzt bei einem Browser-Tab-Crash nicht der ganze Browser ab, aber bei einem Thread-Crash schon? Weil das eine Prozesse (isoliert) und das andere Threads (geteilter Speicher) sind. Klausurpflicht in 6/10 Betriebssysteme-Modulen, das Kern-Konzept der Nebenläufigkeit.
Klausur-Tipp: Merke die Speicher-Aufteilung: Threads teilen Heap + Code + Daten (gemeinsam), aber Stack + Register sind pro Thread privat. Genau diese Aufteilung wird in Klausuren abgefragt.
Anmelden, um den Fortschritt zu speichern.
Nächster Schritt
Aktives Abrufen festigt Wissen schneller als nochmal lesen.
Warum stürzt bei einem Browser-Tab-Crash nicht der ganze Browser ab, aber bei einem Thread-Crash schon? Weil das eine Prozesse (isoliert) und das andere Threads (geteilter Speicher) sind. Klausurpflicht in 6/10 Betriebssysteme-Modulen, das Kern-Konzept der Nebenläufigkeit.
Ein Prozess ist ein laufendes Programm mit eigenem, isoliertem Adressraum. Ein Thread ist ein Ausführungsstrang INNERHALB eines Prozesses: mehrere Threads teilen sich Heap, Code und Daten, haben aber je einen eigenen Stack.
Ein Prozess ist ein Programm in Ausführung. Das Betriebssystem gibt ihm:
erzeugt
|
v
+-> BEREIT (ready) <----+
| | |
| v | (Scheduler wählt)
| LAUFEND (running) --+
| |
| v
+-- BLOCKIERT (waiting) (wartet auf I/O)
|
v
beendet
Ein Thread ("leichtgewichtiger Prozess") ist ein Ausführungsstrang innerhalb eines Prozesses. Mehrere Threads in einem Prozess teilen sich:
| Geteilt (gemeinsam) | Privat (pro Thread) |
|---|---|
| Code-Segment | Stack |
| Daten-Segment (global) | Register (inkl. Program Counter) |
| Heap | Thread-ID |
| offene Dateien |
Konsequenz: Threads kommunizieren über gemeinsamen Speicher (sehr schnell). Aber: gleichzeitige Zugriffe auf geteilte Daten brauchen Synchronisation (sonst Race-Conditions).
| Kriterium | Prozess | Thread |
|---|---|---|
| Adressraum | eigener, isoliert | geteilt (im Prozess) |
| Heap/Daten/Code | privat | gemeinsam |
| Stack/Register | privat | privat pro Thread |
| Erzeugung | teuer (fork, kompletter Adressraum) | günstig |
| Kontextwechsel | teuer (MMU/TLB-Flush) | günstig (nur Register) |
| Kommunikation | IPC (Pipes, Sockets, Shared Memory) | gemeinsamer Speicher direkt |
| Crash-Verhalten | isoliert (1 Prozess stürzt allein ab) | 1 Thread-Crash = ganzer Prozess weg |
Wenn die CPU von einer Ausführungseinheit zur nächsten wechselt:
1. Prozess = isolierter Adressraum, Thread = geteilter Adressraum. Der Kern-Unterschied.
2. Threads teilen Heap/Code/Daten, NICHT Stack/Register. Auswendig.
3. Thread-Wechsel ist billiger als Prozess-Wechsel. Kein MMU/TLB-Flush.
4. Thread-Crash killt den ganzen Prozess, Prozess-Crash ist isoliert. Crash-Verhalten.
5. Prozess-Kommunikation = IPC, Thread-Kommunikation = gemeinsamer Speicher.
6. 3 Prozess-Zustände: bereit, laufend, blockiert. Plus erzeugt/beendet.
1. "Threads haben eigenen Heap" ist FALSCH. Threads teilen den Heap. Nur Stack ist privat.
2. Prozess-Zustände verwechseln. "Laufend → blockiert" passiert bei I/O-Warten, NICHT "laufend → bereit" (das ist Preemption durch Scheduler).
3. Kontextwechsel-Kosten unterschätzen. Prozess-Wechsel ist teuer wegen MMU/TLB, nicht "nur Register".
4. Race-Conditions ignorieren. Geteilter Speicher bei Threads = ohne Synchronisation (Mutex/Semaphor) drohen Race-Conditions.
5. "fork() erzeugt einen Thread" ist FALSCH. fork() erzeugt einen neuen PROZESS (Kopie). Threads erzeugt man mit pthread_create / std::thread.
6. PCB vs. TCB. Prozess hat Process Control Block (PCB), Thread hat Thread Control Block (TCB). Der TCB ist kleiner (kein eigener Adressraum).
Toggle zwischen zwei Ansichten: 1) Zwei isolierte Prozesse mit je eigenem Heap/Stack/Code/Daten. 2) Ein Prozess mit 3 Threads, die sich Heap/Code/Daten teilen, aber je eigenen Stack haben.
Darunter: Kontextwechsel-Kosten-Vergleich und vollständige Vergleichstabelle.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
Klausur-Tipp: Merke die Speicher-Aufteilung: Threads teilen Heap + Code + Daten (gemeinsam), aber Stack + Register sind pro Thread privat. Genau diese Aufteilung wird in Klausuren abgefragt.
6 Aufgaben zu Speicher-Sharing, Kontextwechsel und Zuständen.
Klausurfragen mit Lösungen (6)
Antwort: Ein Prozess hat einen eigenen, isolierten Adressraum; Threads innerhalb eines Prozesses teilen sich den Adressraum
Erklärung: Der Kern-Unterschied: Ein Prozess hat einen eigenen, isolierten Adressraum (eigener Heap, Code, Daten). Threads laufen INNERHALB eines Prozesses und teilen sich dessen Heap/Code/Daten, haben aber je einen eigenen Stack + Register. Daher: Threads kommunizieren über gemeinsamen Speicher, Prozesse über IPC. Klausur-Kernfrage.
Antwort: Den Stack
Erklärung: Threads teilen sich Heap, Code-Segment und globale Daten (gemeinsam). NICHT geteilt: der Stack (jeder Thread hat einen eigenen für lokale Variablen + Funktions-Aufrufe) und die Register (inkl. Program Counter). Klausur-Stolperstein: 'Threads haben eigenen Heap' ist FALSCH, nur Stack ist privat.
Zuordnungen:
Erklärung: Bei Threads: geteilt sind Heap, Code-Segment, globale Daten, offene Dateien. Privat pro Thread sind Stack (lokale Variablen, Call-Stack) und Register (inkl. Program Counter, der zeigt wo der Thread im Code ist). Diese Aufteilung erklärt, warum Threads schnell kommunizieren, aber Synchronisation brauchen. Klausur-Pflicht.
Typ: Zuordnung
Antwort: Beim Thread-Wechsel muss der Adressraum (MMU/Page-Table/TLB) nicht umgeschaltet werden, nur Register + Stack-Pointer
Erklärung: Beim Thread-Wechsel innerhalb desselben Prozesses bleibt der Adressraum gleich: kein MMU/Page-Table-Umschalten, kein TLB-Flush, Cache bleibt warm. Nur Register + Stack-Pointer werden getauscht. Beim Prozess-Wechsel muss der komplette Adressraum umgeschaltet werden (teuer). Klausur-Verständnisfrage.
Antwort: Wahr
Erklärung: RICHTIG. Da Threads sich den Adressraum teilen, kann ein Fehler in einem Thread (z.B. Speicher-Korruption, Segfault) den ganzen Prozess zum Absturz bringen. Deshalb nutzen sicherheitskritische Anwendungen (z.B. Browser für Tabs) oft PROZESSE statt Threads, um Crash-Isolation zu erreichen. Klausur-Schlüsselkonzept.
Typ: Wahr/Falsch
Antwort: blockiert (waiting)
Erklärung: Ein laufender Prozess, der auf I/O (Festplatte, Netzwerk) wartet, wechselt in den Zustand BLOCKIERT (waiting). Er gibt die CPU frei. Wenn die I/O fertig ist, wechselt er zu BEREIT (ready) und wartet auf erneute CPU-Zuteilung durch den Scheduler. Klausur-Stolperstein: 'laufend → blockiert' bei I/O, 'laufend → bereit' nur bei Preemption.
6 Klausur-Fragen mit Zuständen, IPC und Crash-Verhalten.
Klausurfragen mit Lösungen (6)
Antwort: Ein Programm in Ausführung mit eigenem Adressraum und Verwaltungsdaten (PCB)
Erklärung: Ein Prozess ist ein PROGRAMM IN AUSFÜHRUNG: eine Programmdatei (passiv, auf der Platte) plus laufender Zustand (Adressraum, Register, PCB, offene Dateien). Das gleiche Programm kann mehrfach als getrennte Prozesse laufen. Der Process Control Block (PCB) speichert die Verwaltungsdaten. Klausur-Definition.
Antwort: Über IPC-Mechanismen (Pipes, Sockets, Shared Memory, Message Queues)
Erklärung: Getrennte Prozesse haben isolierte Adressräume, können also NICHT direkt auf den Speicher des anderen zugreifen. Kommunikation läuft über IPC (Inter-Process Communication): Pipes, Named Pipes, Sockets, Shared Memory (explizit eingerichtet), Message Queues, Signale. Threads dagegen nutzen direkt den gemeinsamen Speicher. Klausur-Pflicht.
Zuordnungen:
Erklärung: fork() = System-Call, der einen neuen Prozess als Kopie des aufrufenden erzeugt (NICHT einen Thread). PCB = Process Control Block, speichert PID/Zustand/Register/offene Dateien. Kontextwechsel = CPU-Umschaltung zwischen Prozessen/Threads. IPC = Kommunikationsmechanismen zwischen Prozessen. Klausur-Begriffe.
Typ: Zuordnung
Antwort: Mehrere Threads eines Prozesses können auf verschiedenen CPU-Kernen echt parallel laufen (bei Kernel-Level-Threads)
Erklärung: Kernel-Level-Threads können vom Scheduler auf verschiedene CPU-Kerne verteilt werden, also ECHT parallel laufen. Das ist ein Hauptgrund für Threading: einen Prozess auf mehrere Kerne skalieren. User-Level-Threads (ohne Kernel-Unterstützung) laufen dagegen auf einem Kern. Klausur-Detail zur Parallelität.
Antwort: Falsch
Erklärung: FALSCH. fork() erzeugt einen neuen PROZESS (eine fast identische Kopie des aufrufenden Prozesses mit eigenem Adressraum). Threads werden mit pthread_create() (POSIX), std::thread (C++) oder Thread-Klassen (Java) erzeugt. Klausur-Klassiker-Verwechslung: fork = Prozess, pthread_create = Thread.
Typ: Wahr/Falsch
Antwort: Crash-Isolation: ein abstürzender Tab reißt nicht den ganzen Browser mit, und Tabs sind voneinander sicherheitstechnisch isoliert
Erklärung: Prozess-pro-Tab gibt CRASH-ISOLATION (ein abstürzender Tab beendet nur seinen Prozess, der Browser läuft weiter) und SICHERHEIT (getrennte Adressräume, Sandbox-Isolation gegen bösartige Webseiten). Nachteil: höherer Speicherverbrauch (jeder Prozess hat eigenen Adressraum). Chrome/Firefox machen genau das. Klausur-Praxisbeispiel.