Organisation und Einführung

Parallele Programmierung (3IB)

Prof. Dr.-Ing. Sandro Leuchter
Technische Hochschule Mannheim, Fakultät für Informatik
Wintersemester 2025/2026

 

Dieses Werk ist lizenziert unter einer Creative Commons „Namensnennung – Nicht-kommerziell – Weitergabe unter gleichen Bedingungen 4.0 International“ Lizenz.

Überblick

  • Organisatorisches
    • Semesterplan (roter Faden)
    • Prüfung
  • Einführung
    • Probleme paralleler Programmierung
    • UML-Modelle mit Parallelität: Aktivitätsdiagramme

Organisationshinweise

Semesterüberblick

Warum parallele Programmierung?

  • CPUs werden nicht mehr schneller, stattdessen: mehrere Cores auf einer CPU
    • Beschleunigung durch Verteilung und Parallelisierung
  • neue Rechnerarchitekturen sind standardmäßig verfügbar
    • Multicore-Prozessoren (früher war fast alles nur “Pseudo-Multitasking”)
    • Graphical Co-Processing Units (GPU) für numerische Aufgaben
    • Cloud-Computing Angebote
  • verteilte Systemarchitekturen
    • Big Data (Map-Reduce) \(\to\) “Lambda Architektur”
    • Nebenläufigkeit: Synchronisation konkurrierender Zugriffe auf Ressourcen erforderlich
    • Resilienz: Robustheit (s. Telekom Domäne)
  • Fehlersuche

Lernziele

Die Studierenden sind in der Lage,

  • die Probleme und Chancen der parallelen Programmierung zu nennen,
  • Probleme in Java-Programmen zu erkennen, die aus Nebenläufigkeit resultieren,
  • nebenläufige Programme zu erstellen,
  • vorhandene Programme bezüglich ihres Verhalten bei Nebenläufigkeit zu analysieren

Modulhandbuch PP1

Wichtige Konzepte

Nebenläufigkeit (“concurrency”)

  • mehrere logische Programmablaufpfade (“Threads of Control”)
  • können prinzipiell auch sequenzialisiert (in “Pseudo-Multitasking”) ablaufen

Parallelität

  • Teile eines Programms werden simultan abgearbeitet (“Multitasking”)

Co-Routine

  • im Gegensatz zur Subroutine (Funktion/Methode): kein Aufruf-Kontext auf dem Stack \(\to\) man kann nicht mit return zum Aufrufpunkt zurückspringen

asynchroner Funktions-/Methodenaufruf (“asynchronous procedure call”)

  • Aufruf hat sofort Rückgabe (“Future”/“Promise”), egal wie lange Berechnung dauert (z.B. wenn erst noch auf I/O/Netz gewartet werden muss)
  • Resultat wird nebenläufig berechnet (Umsetzung als Thread oder Co-Routine)

Formalia

Voraussetzungen

  • Programmierung 1
  • Programmierung 2
  • Software Engineering 1

Vorausgesetzt werden u.a.

  • UML: Klassen-, Zustands-, Aktivitäts- und Sequenzdiagramm (vereinzelt auch Kommunikations- und Interaktionsübersichtsdiagramm)
  • Objekt-Orientierung, Vererbung, Polymorphie, einige Entwurfsmuster
  • Java: anonyme innere Klassen, Lambda-Ausdrücke, Exception-Handling, Collections, Generics
  • JUnit – im Vergleich zu PR1/2 werden wir in PP seltener Unit-testen (Nebenläufigkeitsaspekte schwierig testbar)

Inhalte

  • Parallelität und Nebenläufigkeit, Prozesse, Threads, Co-Routinen/Fibers
  • Threadkonzept in Java
  • konkurrierender Zugriff auf Daten in Java
  • Synchronisation mit synchronized, Bedingungsvariablen und Signalisieren
  • Thread Pools, Completable Future und FutureTask
  • Lock-Objekte und Semaphore
  • synchronisierte, unmodifiable und concurrent Collections in Java

Inhalte

  • weitere Architekturen und Frameworks für nebenläufige und parallele Programmierung in Java und ggf. anderen Programmiersprachen: z.B.
    • Actor Model
    • Communicating Sequential Processes
    • Fork-Join
    • Java Stream Processing
    • Map-Reduce
    • Software Transactional Memory
    • RxJava
    • Datenparallelismus: GPGPU (OpenCL oder CUDA)
  • Performance-Betrachtungen
  • Design Patterns (für nebenläufige und parallele Programme)
  • Praktische Übungen zur Implementierung asynchroner, nebenläufiger und paralleler Algorithmen mit Java und ggf. anderen Programmiersprachen

Aufwand und Prüfungsmodalitäten

  • Arbeitsaufwand (work load)
    • Präsenzstudium: 30 Stunden
    • Präsenzübungen und Testate: 30 Stunden
    • Eigenstudium zur Vor- und Nachbereitung: 50 Stunden
    • Selbständiges Bearbeiten der Übungen: 40 Stunden
  • Prüfungsvorleistung
    • 2 Pflichtübungen (Gruppenarbeit)
      • Online-Abgabe, ausführliches Feedback, Möglichkeit bis zur Deadline erneut abzugeben
      • jede nicht bestandene Gruppen-Pflichtübung (Bewertung = “rot”) kann durch die entsprechende “Ausgleichsleistung” (zusätzliche Pflichtübung als Einzelarbeit) ausgeglichen werden
      • Ausgleichsleistungen nur, wenn Prüfungsvorleistungen für PR1, PR2 und SE1 bereits erbracht wurden!
  • Prüfungsleistung
    • Voraussetzung ist die Prüfungsvorleistung
      • beide Pflichtübungen bzw. jeweilige Ausgleichsleistungen bestanden
      • Präsenz-Klausur mit Moodle 90 Minuten
  • zusätzlich 2 Tests
    • asynchron innerhalb einer festen Woche, ohne Bewertung
    • Fragen sehr ähnlich zu Prüfungsklausur: perfekte Vorbereitung auf Prüfung!

Was macht parallele Programmierung schwierig?

Der Fall “Therac-25”1

https://cdn-images-1.medium.com/max/2000/1*ukXKrvRV4KJ1UbVe7OJEpQ.png
  • Linearbeschleuniger zur Anwendung in der Strahlentherapie
  • 80er Jahre
  • seltenes Problem (schwer zu reproduzieren): Überdosierung
  • durch parallelen Zugriff auf geteilte Variable \(\to\) falscher Wert \(\to\) Überdosierung

Probleme paralleler Programmierung

  • schwer zu testen
  • konkurrierende Zugriffe auf geteilte Variablen (und andere Ressourcen)
  • Deadlocks/Verklemmung
    • erfordert ggf. Kooperation durch Signalisierung

Modellierung

Nebenläufigkeit und Parallelität im UML-Aktivitätsdiagramm

  • “Fork” und “Join”
  • im “ja”-Fall:
    • P1 und P2 sind nebenläufig
    • P1 und P2 können parallel ausgeführt werden
    • keine Garantie, wann P1 und P2 beginnen oder enden
  • Garantie, dass auf das Ende von P1 und P2 gewartet wird, bevor P3 beginnt

Nebenläufigkeit und Parallelität im UML-Aktivitätsdiagramm

  • F1, F2, F3 sind nebenläufig
  • F1, F2, F3 können parallel ausgeführt werden
  • (F1, F2, F3 werden alle begonnen)
  • sobald F1 beendet ist, beginnt F4
  • F2 und F3 werden irgendwann (asynchron) beendet
  • “final flow nodes” verbrauchen Tokens, die dort ankommen

Nebenläufigkeit und Parallelität im UML-Aktivitätsdiagramm

  • F1, F2, F3 sind nebenläufig
  • F1, F2, F3 können parallel ausgeführt werden
  • (F1, F2, F3 werden alle begonnen)
  • sobald F1 beendet ist, beginnt F4
  • F2 und F3 werden irgendwann (asynchron) beendet
  • “final flow nodes” lasse ich häufig weg

Nebenläufigkeit und Parallelität im UML-Aktivitätsdiagramm

  • F1, F2, F3 sind nebenläufig
  • F1, F2, F3 können parallel ausgeführt werden
  • (F1, F2, F3 werden alle begonnen)
  • sobald F1, F2 oder F3 beendet ist, beginnt F4
  • als joinSpec könnten auch komplexere Bedingungen angegeben werden
  • es bleibt unklar, ob die beiden langsameren von F1, F2 und F3 bei {joinspec=or} auch abgebrochen werden, sobald eine davon fertig ist

Referenzen

Hettel, Jörg und Manh Tien Tran. 2016. Nebenläufige Programmierung mit Java. Konzepte und Programmiermodelle für Multicore-Systeme. Heildelberg: dpunkt.verlag.
Leveson, Nancy G. 2017. The Therac-25: 30 Years Later. Computer 50, Nr. 11 (November): 8–11. doi:10.1109/MC.2017.4041349,.
Leveson, Nancy G. und C. S. Turner. 1993. An investigation of the Therac-25 accidents. Computer 26, Nr. 7 (Juli): 18–41. doi:10.1109/MC.1993.274940,.