KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

ReadWriteLock — afzonderlijke lees- en schrijfvergrendelingen

ReadWriteLock biedt bij elkaar horende lees- en schrijfvergrendelingen: meerdere lezers kunnen de toegang delen, terwijl schrijven exclusieve toegang vereist. Leer over readLock() en writeLock(), de zichtbaarheid van wijzigingen en het veilig vrijgeven van vergrendelingen.

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

Syntax

ReadWriteLock rw = new ReentrantReadWriteLock();
Lock read = rw.readLock();
Lock write = rw.writeLock();
read.lock();
try {
    // Read protected state.
} finally {
    read.unlock();
}
write.lock();
try {
    // Modify protected state.
} finally {
    write.unlock();
}

java.util.concurrent.locks.ReadWriteLock is een interface voor een paar bij elkaar horende vergrendelingen. ReadWriteLock.readLock() retourneert een Lock om te lezen en ReadWriteLock.writeLock() een om te schrijven; deze methoden aanroepen verwerft geen vergrendeling. Meerdere lezers kunnen tegelijk werken zolang er geen schrijver is; schrijven is exclusief.

Roep lock() aan op het geretourneerde object voordat de beschermde sectie begint, en unlock() in finally; plaats lock() vóór try. Alle toegang tot de beschermde toestand moet hetzelfde protocol volgen. Wijzig de toestand niet onder de leesvergrendeling. Als de leesvergrendeling is verkregen, zijn wijzigingen zichtbaar die eerder zijn gepubliceerd door het vrijgeven van de bijbehorende schrijfvergrendeling.

Een gebruikelijke implementatie is ReentrantReadWriteLock. De standaardmodus garandeert geen eerlijke volgorde. Probeer de schrijfvergrendeling niet te verkrijgen terwijl je de leesvergrendeling nog vasthoudt: deze implementatie ondersteunt die upgrade niet. Controleer de voorwaarde opnieuw nadat je de leesvergrendeling hebt vrijgegeven en de schrijfvergrendeling hebt verkregen, omdat de toestand veranderd kan zijn. Dit implementatiebeleid vormt geen aanvullende garantie van de interface.

Deze aanpak is het overwegen waard bij veel leesbewerkingen en minder frequente schrijfbewerkingen, maar de overhead kan de voordelen tenietdoen; meet de prestaties. Het voorbeeld beschermt value en drukt deterministisch 42 af. De sequentiële aanroepen in main laten het API-gebruik zien, niet parallelle uitvoering of correctheid bij elke mogelijke thread-interleaving.

Voorbeelden

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

public class Main {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private int value;

    public int get() {
        Lock read = rw.readLock();
        read.lock();
        try {
            return value;
        } finally {
            read.unlock();
        }
    }

    public void set(int next) {
        Lock write = rw.writeLock();
        write.lock();
        try {
            value = next;
        } finally {
            write.unlock();
        }
    }

    public static void main(String[] args) {
        Main cell = new Main();
        cell.set(42);
        System.out.println(cell.get());
    }
}

Resultaat

42

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen