WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

ReentrantLock-Methoden: Sperrerwerb, Wiedereintritt und Bedingungen

Unterscheide das blockierende `lock()` von beiden `tryLock()`-Überladungen, gleiche jeden erfolgreichen Erwerb mit `unlock()` aus und nutze getrennte Bedingungen an derselben Sperre.

Version: Java SE 21

Syntax

// Java SE 21 — instance methods of java.util.concurrent.locks.ReentrantLock
public void lock()
public void unlock()
public boolean tryLock()
public boolean tryLock(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException
public java.util.concurrent.locks.Condition newCondition()
public int getHoldCount()

In Java SE 21 bietet java.util.concurrent.locks.ReentrantLock eine wiedereintrittsfähige Sperre für gegenseitigen Ausschluss. lock() wartet, wenn ein anderer Thread die Sperre hält; eine Unterbrechung bricht dieses Warten nicht ab. Der Besitzer kann dieselbe Sperre ohne Warten erneut erwerben. getHoldCount() zählt die noch nicht ausgeglichenen Erwerbe des aktuellen Threads, nicht die wartenden Threads. 0 bedeutet nicht, dass die Sperre frei ist.

unlock() verringert den Zähler um eins und gibt die Sperre erst bei 0 frei. Ein Thread, der die Sperre nicht hält, erhält eine IllegalMonitorStateException. Beginne unmittelbar nach jedem erfolgreichen Erwerb einen try-Block und setze das zugehörige unlock() in finally. Gleiche keinen fehlgeschlagenen oder mit Ausnahme beendeten Versuch mit unlock() aus. Wenn Code beide Sperren benötigt, muss jeder Pfad sie in derselben Reihenfolge erwerben, etwa gateLock vor orderLock, und in umgekehrter Reihenfolge freigeben.

tryLock() wartet nicht: Hält ein anderer Thread die Sperre, liefert es false, bei erfolgreichem Erwerb einschließlich Wiedereintritt true. Auch bei einer fairen Sperre kann es wartende Threads überholen. tryLock(timeout, unit) berücksichtigt die Fairness, wenn sie aktiviert ist, wartet höchstens die angegebene Dauer (timeout <= 0 bedeutet kein Warten) und liefert false, wenn der Erwerb in dieser Zeit nicht gelingt. Eine Unterbrechung beim Eintritt oder während des Erwerbs führt zu InterruptedException und löscht den Unterbrechungsstatus; unit == null ist unzulässig und führt zu NullPointerException.

Jeder Aufruf von newCondition() erzeugt ein separates Condition-Objekt für dieselbe Sperre. In einem Puffer mit einem Platz ist notEmpty für Verbraucher und notFull für Erzeuger gedacht. Ruft ein Thread signal() auf, ohne die Sperre zu halten, wird eine IllegalMonitorStateException ausgelöst. await() prüft zuerst den Unterbrechungsstatus des aktuellen Threads. Ist er bereits gesetzt, löscht await() ihn und löst eine InterruptedException aus, noch bevor es den Besitz der Sperre prüft und ohne die Sperre freizugeben. Andernfalls löst await() eine IllegalMonitorStateException aus, wenn der aufrufende Thread die Sperre nicht hält. Geht await() in den Wartezustand über, gibt es die Sperre atomar frei und erwirbt sie vor Abschluss des Aufrufs mit dem ursprünglichen Zählerstand erneut. Prüfe den Zustand in einer while-Schleife, da unbeabsichtigtes Aufwachen möglich ist. Signalisiere nach der Zustandsänderung, solange du die Sperre noch hältst; signal() gibt sie nicht frei.

Beispiele

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final class Slot {
        private final ReentrantLock lock = new ReentrantLock();
        private final Condition notEmpty = lock.newCondition();
        private final Condition notFull = lock.newCondition();
        private Integer value;

        void put(int item) throws InterruptedException {
            lock.lock();
            try {
                while (value != null) {
                    notFull.await();
                }
                value = item;
                notEmpty.signal();
            } finally {
                lock.unlock();
            }
        }

        int take() throws InterruptedException {
            lock.lock();
            try {
                while (value == null) {
                    notEmpty.await();
                }
                int item = value;
                value = null;
                notFull.signal();
                return item;
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock gateLock = new ReentrantLock();
        ReentrantLock orderLock = new ReentrantLock(true);

        System.out.println(orderLock.getHoldCount());
        orderLock.lock();
        try {
            orderLock.lock();
            try {
                System.out.println(orderLock.getHoldCount());
            } finally {
                orderLock.unlock();
            }
            System.out.println(orderLock.getHoldCount());
            if (orderLock.tryLock()) {
                try {
                    System.out.println(orderLock.getHoldCount());
                } finally {
                    orderLock.unlock();
                }
            }
            System.out.println(orderLock.getHoldCount());
        } finally {
            orderLock.unlock();
        }
        System.out.println(orderLock.getHoldCount());

        gateLock.lock();
        try {
            for (int attempt = 1; attempt <= 2; attempt++) {
                if (!orderLock.tryLock(10, TimeUnit.MILLISECONDS)) {
                    System.out.println("timed " + attempt + ": timeout");
                    continue;
                }
                try {
                    System.out.println("timed " + attempt + ": acquired");
                } finally {
                    orderLock.unlock();
                }
            }
        } finally {
            gateLock.unlock();
        }

        Slot slot = new Slot();
        slot.put(42);
        System.out.println("slot: " + slot.take());
    }
}

Ergebnis

0
2
1
2
1
0
timed 1: acquired
timed 2: acquired
slot: 42

Zwei `lock()`-Aufrufe ergeben nach der anfänglichen `0` die erste `2`. Ein `unlock()` lässt `1` übrig; das sofortige `tryLock()` des Besitzers erhöht wieder auf `2`. Die beiden übrigen Freigaben ergeben `1` und `0`. Beide zeitbegrenzten Versuche verwenden dieselbe `orderLock` und gelingen ohne Konkurrenz. `put(42)` und `take()` verwenden getrennte Bedingungen an der einen Puffersperre; bei diesem Lauf wartet keine der beiden Operationen.

Zugehörige Lektionen

  • Java · Lektion 30 · Fortgeschritten · Version: 2
  • Java · Lektion 54 · Mittlere Stufe · Version: 2
  • Java · Lektion 58 · Mittlere Stufe · Version: 2

Quellen