WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Lese-Schreib-Sperren: readLock(), writeLock(), lock() und unlock()

Mehrere Threads können gemeinsame Daten gleichzeitig lesen, aber zum Schreiben ist exklusiver Zugriff nötig. Die Auswahl einer Sperre erwirbt sie noch nicht.

Version: Java SE 21

Syntax

// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();

// java.util.concurrent.locks.Lock
void lock();
void unlock();

In Java SE 21 sind ReadWriteLock und Lock Schnittstellen im Paket java.util.concurrent.locks. readLock() und writeLock() liefern die zugehörigen Lock-Objekte, ohne die Sperren zu erwerben. Verwende für denselben Zustand eine gemeinsame ReadWriteLock-Instanz: die Lesesperre für reine Lesezugriffe, die Schreibsperre für Änderungen. Mehrere Threads können die Lesesperre gleichzeitig halten. Solange ein Thread die Schreibsperre hält, kann kein anderer Thread eine der beiden Sperren erwerben.

lock() und unlock() haben keine Parameter und den Rückgabetyp void. Rufe lock() vor dem try-Block auf: Ist die Sperre nicht verfügbar, wartet der Thread, bis er sie erwerben kann. Rufe unlock() in finally auf demselben Lock auf, damit die Sperre auch bei einer Ausnahme im geschützten Code freigegeben wird. Das Beispiel verwendet tryLock() ohne Argumente: Die Methode wartet nicht und liefert bei erfolgreichem Erwerb true, sonst false. Gib eine Sperre nur nach erfolgreichem Erwerb frei.

Nach Freigabe der Schreibsperre sieht ein Thread, der anschließend die zugehörige Lesesperre erwirbt, die unter der Schreibsperre vorgenommenen Änderungen. Die Sperren schützen keinen Code, der ohne sie auf den Zustand zugreift.

Bei ReentrantReadWriteLock muss der Thread jeden Erwerb mit einem unlock() ausgleichen. Gibt er eine Sperre frei, die er nicht hält, wird IllegalMonitorStateException ausgelöst. Versuche nicht, die Schreibsperre zu erwerben, wenn du nur die Lesesperre hältst: lock() kehrt dann nicht zurück. Gib die Lesesperre frei, erwirb die Schreibsperre und prüfe den Zustand erneut, da er sich inzwischen geändert haben kann. Umgekehrt kannst du bei gehaltener Schreibsperre die Lesesperre erwerben und anschließend die Schreibsperre freigeben.

Beispiele

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private final Lock read = rw.readLock();
    private final Lock write = rw.writeLock();
    private int value = 0;

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        new ReadWriteLockDemo().run();
    }

    private void run() throws InterruptedException, ExecutionException {
        read.lock();
        try {
            System.out.println("read lock held: " + probeFromAnotherThread());
        } finally {
            read.unlock();
        }

        write.lock();
        try {
            value = 10;
            System.out.println("write lock held: " + probeFromAnotherThread());
        } finally {
            write.unlock();
        }

        int snapshot;
        read.lock();
        try {
            snapshot = value;
        } finally {
            read.unlock();
        }
        System.out.println("read after write: " + snapshot);
    }

    private String probeFromAnotherThread() throws InterruptedException, ExecutionException {
        FutureTask<String> probe = new FutureTask<>(() -> {
            String snapshot = "blocked";
            if (read.tryLock()) {
                try {
                    snapshot = Integer.toString(value);
                } finally {
                    read.unlock();
                }
            }
            return "reader=" + snapshot + ", writer=" + canAcquireNow(write);
        });
        new Thread(probe).start();
        return probe.get();
    }

    private static boolean canAcquireNow(Lock lock) {
        if (!lock.tryLock()) {
            return false;
        }
        try {
            return true;
        } finally {
            lock.unlock();
        }
    }
}

Ergebnis

read lock held: reader=0, writer=false
write lock held: reader=blocked, writer=false
read after write: 10

Während der Hauptthread die Lesesperre hält, liest ein zweiter Thread `0`, kann aber die Schreibsperre nicht erwerben. Nachdem der Hauptthread `10` gesetzt hat und solange er die Schreibsperre noch hält, scheitern beide Versuche des zweiten Threads. Nach Freigabe der Schreibsperre ergibt ein geschützter Lesezugriff `10`. `FutureTask.get()` stellt diese Reihenfolge ohne Wartepausen sicher.

Zugehörige Lektionen

  • Java · Lektion 29 · Fortgeschritten · Version: 2

Quellen