WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Lock — explizites Sperren und Entsperren

Die Schnittstelle java.util.concurrent.locks.Lock ermöglicht die explizite Steuerung von Sperren. Lerne das Paar lock()/unlock(), das sichere try/finally-Muster und ein Beispiel, in dem ReentrantLock einen gemeinsam genutzten Zähler schützt.

Version: Java SE 21; repository runtime, production runtime not attested

Syntax

Lock lock = new ReentrantLock();
lock.lock();
try {
    // protected operations
} finally {
    lock.unlock();
}

java.util.concurrent.locks.Lock ist eine Schnittstelle für explizites Sperren; ReentrantLock ist eine Implementierung, die gegenseitigen Ausschluss und erneuten Eintritt durch denselben Thread ermöglicht. Nicht jede Lock-Implementierung muss diese Eigenschaften haben.

Lock.lock() erwirbt die Sperre und wartet bei Bedarf; Lock.unlock() gibt sie frei. Rufe lock.lock() vor try und lock.unlock() in finally auf. Anders als bei synchronized erfolgt die Freigabe nicht automatisch. finally stellt die Freigabe auch sicher, wenn im geschützten Code eine Ausnahme auftritt.

Alle konkurrierenden Zugriffe auf den geschützten Zustand müssen dasselbe Sperrprotokoll befolgen. Erwirbt ein Thread eine Sperre erfolgreich, die er noch nicht hält, hat das dieselben Auswirkungen auf die Speichersynchronisation wie der Erwerb eines Monitors. Die erfolgreiche vollständige Freigabe hat dieselben Auswirkungen wie die Freigabe eines Monitors. Lock schreibt keine Speichersynchronisationseffekte für erfolglose Operationen oder für den erneuten Erwerb durch einen Thread, der die Sperre bereits hält, und die zugehörige Freigabe vor. synchronized (lock) ersetzt lock.lock() nicht.

Bei ReentrantLock muss jedem Erwerb eine passende Freigabe entsprechen; ruft ein Thread, der die Sperre nicht besitzt, unlock() auf, wird IllegalMonitorStateException ausgelöst. Die Schnittstelle bietet außerdem tryLock() und lockInterruptibly() für andere Warteverfahren.

Das Beispiel verwendet für beide count++-Operationen dieselbe gemeinsame Sperre. Nach beiden Aufrufen von join() gibt das Programm unabhängig von der Ausführungsreihenfolge der Threads 2 aus. Dokumentationsumfang: Java SE 21; die Laufzeitumgebung des Repositorys und die Produktionslaufzeitumgebung sind nicht bestätigt.

Beispiele

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final Lock lock = new ReentrantLock();
    private static int count = 0;

    private static void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread first = new Thread(Main::increment);
        Thread second = new Thread(Main::increment);
        first.start();
        second.start();
        first.join();
        second.join();
        System.out.println(count);
    }
}

Ergebnis

2

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen