Java Erzeuger-Verbraucher-Problem mit Concurrency-Framework

Das Java Concurrency Framework bietet Abstraktionen, die das Erzeuger-Verbraucher-Problem im Vergleich zu den traditionellen synchronisierten Monitoren mit wait und notify effizienter lösen.

Insbesondere können Bedingungen durch die Klasse Condition feingranularer eingestellt werden.

Wichtige Methoden

Lock

= Monitor

Konstruktor: new ReentrantLock()

• Lock.lock() - Sperre den Monitor
• Lock.unlock() - Löse die Sperre
• Lock.newCondition() - Erstelle eine neue Condition

ReadWriteLock

Konstruktor: new ReentrantReadWriteLock()

Spezialfall des Locks, das ein ReadLock und ein WriteLock bereitstellt

• ReadWriteLock.readLock() - Gibt das ReadLock zurück
• ReadWriteLock.writeLock() - Gibt das WriteLock zurück

Condition

• Condition.await()
• Condition.signal()
• Condition.signalAll()

Implementierung

public class Stapelspeicher {
 
	Stack<Object> stapel = new Stack<>();
 
	Lock monitor = new ReentrantLock();
 
	Condition leser = monitor.newCondition();
	Condition schreiber = monitor.newCondition();
 
	public Object get() {
		monitor.lock();
 
		try {
			while( stapel.empty() ) {
				try {
					leser.await();
				} catch (InterruptedException e) {
					//
				}
			}
 
			Object o = stapel.pop();
			schreiber.signal();
			return o;
 
		} finally {
			// In Java wird der finally-block immer ausgeführt.
			// Der Monitor wird hier also unlocked, bevor oben das return
			// ausgeführt wird.
			monitor.unlock();
		}
	}
}