Nebenläufige & verteilte Programmierung

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)