Fortgeschrittene Programmierung mit Java 5 - Generics, Annotations, Concurrency und Reflection – mit allen wesentlichen Neuerungen des J2SE 5.0

9 Das concurrent-Paket (S. 189-190)

Dieses Kapitel stellt die wichtigsten der neuen Klassen vor, mittels derer Multithreading-Anwendungen erstellt werden können. Es geht um Klassen bzw. Interfaces wie Lock, BlockingQueue, Semaphore etc. Es enthält weiterhin Klassen, die sich für Thread-Pooling und Scheduling eignen. Das neue Paket enthält also Klassen, welche zusätzlich zu den »alten« Multithreading- Mitteln (synchronized, wait, notify, Thread, Runnable) genutzt werden können.

Was Nebenläufigkeit angeht, begnügte sich Java vor Java5 mit dem Interface Runnable, der Klasse Thread und einigen wenigen Synchronisations-Mechanismen: mit synchronized und den Object-Methoden wait, notify und notifyAll. Es handelte sich hier also um ein sehr elegantes, flexibel nutzbares und schlankes Konzept. Die Kenntnis dieses Konzepts und seiner Möglichkeiten wird hier vorausgesetzt.

Concurrent Programming hieß daher aber immer auch, dass man eigene Klassen für wiederkehrende Aufgaben schreiben musste – Queue-Klassen für den Austausch von Produkten (bei Producer-Consumer-Anwendungen), Klassen zum Poolen von Threads, Semaphore etc.

Das java.util.concurrent-Paket definiert nun eine Reihe von Basisklassen, die für solche Aufgaben verwendet werden können. Das, was man bislang selbst implementieren musste, kommt also ab Java5 in Form fertiger Bibliotheks-Klassen daher.

Zunächst werden die neuen Locking-Mechanismen vorgestellt. Diese Mechanismen sind eine Alternative sowohl zu synchronized als auch zu den Monitor- Methoden der Klasse Object.

Dann werden Queues beschrieben. Hier geht es also um die allgemeine Producer- Consumer-Konstellation, bei welcher die beteiligten Partner über eine Queue synchronisieren müssen: Der Producer erzeugt Produkte und stellt sie in eine Queue, aus welcher sich der Consumer die Produkte zur Konsumption abholen kann. Das concurrent-Paket definiert mehrere Queue-Klassen, welche sich u.a. durch die verwendete Zustellungsstrategie unterscheiden (FIFO, Priorität etc).

Anschließend wird das Konzept des Thread-Poolings vorgestellt. Zunächst wird eine eigene kleine ThreadPool-Klasse entwickelt, welche das Prinzip des Poolings demonstrieren soll. Dann werden die entsprechenden Klassen und Interfaces des concurrent-Pakets vorgestellt – insbesondere die Klassen ThreadPoolExecutor und ScheduledExecutor.

Weiter geht es mit dem Semaphor-Konstrukt. Natürlich konnte man auch mit den »alten« Mechanismen eigene Semaphor-Klassen entwickeln. Das concurrent- Paket definiert aber bereits eine eigene Semaphore-Klasse.

Schließlich werden einige weitere Hilfsmittel zur Synchronisation vorgestellt: die Klassen Exchanger, CountDownLatch und CyclicBarrier.

9.1 Locks

Das Konzept

Dieses Kapitel beschreibt das neue Locking-Konzept, welches in den Klassen des Pakets java.util.concurrent.locks implementiert ist.

Ein Lock ist bekanntlich ein Mittel, um innerhalb eines multithreaded Systems den gemeinsamen Zugriff auf Ressourcen zu kontrollieren. Um eine solche Ressource nutzen zu können, muss ein Thread einen dieser Ressource zugehörigen Schlüssel anfordern. Solange er den Schlüssel besitzt, kann kein anderer Thread die Ressource nutzen. Der Thread, der den Schlüssel besitzt, wird diesen Schlüssel nach Beendigung seines Zugriffs auf die Ressource wieder freigeben – so dass ein ggf. auf diesen Schlüssel wartender Thread seine Arbeit fortsetzen kann. Dieses Konzept wurde bislang (und wird natürlich weiterhin) durch synchronized unterstützt.