Nebenläufige & verteilte Programmierung

Die Welt ist nebenläufig und verteilt!

Dies müssen auch immer mehr Software-Entwickler feststellen. Auf moderne Software-Systeme greifen viele Benutzer gleichzeitig über Netze zu. Bei der Realisierung solcher Anwendungen müssen daher nebenläufige und verteilte Programmierkonzepte berücksichtigt werden. Viele Software-Entwickler und Studierende der Informatik haben aber die nebenläufige und verteilte Programmierung oft nicht systematisch gelernt. Ein Online-Kurs und ein Buch schließen nun diese Lücke.

Der Autor, Dr.-Ing. Peter Ziesche, zeigt, wie mithilfe der UML 2 nebenläufige Systeme entworfen werden. Die Implementierung erfolgt anhand der nebenläufigen Konzepte von Java 2 (V1.4 &, V5.0). Die umfangreiche Fallstudie »Lagerverwaltung« demonstriert das Zusammenwirken der behandelten Konzepte und Entwurfsmuster. Nebenläufige Programmierung ist nach allgemeiner Auffassung schwieriger als sequenzielle Programmierung. Die Programme sind komplexer, fehleranfälliger und schwerer zu warten. Dass dies nicht so sein muss, vermitteln dieser Kurs und dieses Buch.

Es richtet sich an Programmierer, die bisher Erfahrungen mit sequenziellen Programmen gemacht haben und mit Nebenläufigkeit nur am Rande in Berührung gekommen sind. Es wird gezeigt, wie man Programme mit relativ wenig Aufwand nebenläufig gestalten kann, ohne dass Komplexität und Fehlerzahlen dramatisch steigen. Kurs und Buch zeigen darüber hinaus, dass nebenläufige Programmierung eine spannende und interessante Sache ist, die, richtig eingesetzt, zu besseren und einfacheren Anwendungen führen kann.

Für die Bearbeitung des Online-Kurses werden ca. 60 Stunden benötigt, davon 40 Stunden zum Durcharbeiten der Wissensbausteine, 2 Stunden für Tests und 18 Stunden für Aufgaben. Mehr als 20 Tests sind zu absolvieren und über 30 Aufgaben zu lösen, die von einem Tutor korrigiert werden. Folgende Themen werden behandelt:

Nebenläufigkeit: Schnelleinstieg

Multi-threaded-Anwendungen in Java

Synchronisation und Verklemmungen

Swing-GUIs und Nebenläufigkeit

Klassen für nebenläufige Anwendungen im neuen Java 2 (V5.0)

UML-Modellierung nebenläufiger und verteilter Anwendungen

OO-Konzepte für verteilte Anwendungen

Java-RMI in der Praxis

Entwurfsmuster für verteilte OO-Anwendungen

Fallstudie: verteiltes Lagerverwaltungssystem

170 Abbildungen, 81 Glossarbegriffe


Leseprobe:

5 Neues zur Nebenläufigkeit in Java 5 (S. 123)

Für einfache Beispiele lassen sich mit den Java-Sprachkonstrukten elegante nebenläufige Anwendungen entwickeln (siehe Wissensbaustein »Threads in Java: Schnelleinstieg« (S. 57)). Bestimmte Problemstellungen treten in der Praxis aber in gleicher oder ähnlicher Form immer wieder auf. Sie lassen sich zwar mit Java lösen, jedoch ist der immer wiederkehrende Aufwand recht hoch und auch unnötig.

Das Java-API bietet in der Version 5 eine ganze Reihe von nützlichen Klassen, mit denen sich viele typische Probleme der nebenläufigen Programmierung leichter lösen lassen. Sie sind im Paket java.util.concurrent und dessen Unterpaketen zusammengefasst. Ursprünglich stammen sie zum großen Teil aus /Lea 99/. Mit Java 5 sind sie zum festen Bestandteil des Java-APIs geworden.

Die Klassen und Schnittstellen im Paket java.util.concurrent realisieren eine Reihe von Mustern für den Umgang mit Nebenläufigkeit. In der API-Dokumentation ist von kleinen frameworks die Rede. Abb. 5.0-1 und Abb. 5.0-2 zeigen die wichtigsten Elemente des Pakets und die Beziehungen zwischen ihnen als UML-Klassen-Diagramme.

Alle Klassen basieren auf den grundlegenden Mechanismen von Java zur Realisierung von Nebenläufigkeit. Sie sind vollständig in Java realisiert und verwenden keine Aufrufe des unterliegenden Betriebssystems. Intern wird also z.B. stets die Klasse Thread zum Erzeugen neuer threads verwendet und die Mechanismen für die Realisierung von Monitoren (synchronized, wait(), notify()) finden Anwendung. Die grundlegenden Mechanismen werden aber meist hinter einer leichter nutzbaren Schnittstelle verborgen.

Es sollen im Folgenden die hinter den Klassen und Schnitt- stellen stehenden Konzepte beleuchtet werden. Für eine detaillierte Referenz einzelner Operationen und Parameter sei auf die API-Dokumentation verwiesen.

Die Bestandteile von java.util.concurrent

Der Aufzählungstyp TimeUnit repräsentiert die Zeiteinhei- ten Sekunden, Millisekunden, Mikrosekunden und Nanosekunden. Alle Klassen in java.util.concurrent nutzen diesen Aufzählungstyp, um die Angabe von Zeiteinheiten in der jeweils passenden Einheit annehmen zu können:

- Wissensbaustein »Zeiteinheiten angeben mit TimeUnit« (S. 126)

Die Container-Klassen und Warteschlangen im Paket java. util.concurrent helfen bei der Verwaltung von Objekten, auf die mehrere threads gleichzeitig zugreifen sollen:

- Wissensbaustein »Nebenläufige Container-Klassen« (S. 130)

Ein weiterer Bestandteil von java.util.concurrent ist ein Framework zur Erzeugung, Verwaltung und nebenläufigen Ausführung von Aufträgen (tasks). Die Klassen in diesem Framework vereinfachen die Entwicklung von Server-Anwendungen:

- Wissensbaustein »Auftragsorientierte Architektur« (S. 155)

Mit den Klassen im Paket java.util.concurrent.locks lassen sich Monitore flexibler gestalten als mit den Sprachkonstrukten von Java. So kann z.B. zwischen lesendem und schreibendem Zugriff unterschieden werden und es können mehrere Bedingungs-Variablen eingesetzt werden:

- Wissensbaustein »Flexible Monitore« (S. 171)

- Wissensbaustein »Leser-Schreiber-Synchronisation« (S. 181)

Das Java-API stellt ab der Version 5 einige Synchronisations- Objekte zur Verfügung. Sie vereinfachen die Synchronisation von threads, wenn kein Monitor eingesetzt werden kann:

- Wissensbaustein »Synchronisations-Objekte in Java 5« (S. 186)