Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

ReadWriteLock — ločeni ključavnici za branje in pisanje

ReadWriteLock ponuja povezani ključavnici za branje in pisanje: dostop si lahko deli več bralcev, pisanje pa zahteva izključni dostop. Spoznajte readLock() in writeLock(), vidnost sprememb ter varno sproščanje ključavnic.

Različica: Java SE 21; repository runtime, production runtime not attested

Sintaksa

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 je vmesnik za par povezanih ključavnic. ReadWriteLock.readLock() vrne Lock za branje, ReadWriteLock.writeLock() pa ključavnico za pisanje; klic teh metod ključavnice ne pridobi. Če ni pisca, lahko hkrati deluje več bralcev; pisanje je izključno.

Na vrnjenem objektu pred zaščitenim odsekom pokličite lock(), v bloku finally pa unlock(); lock() postavite pred try. Vsi dostopi do zaščitenega stanja morajo upoštevati isti protokol. Stanja ne spreminjajte pod ključavnico za branje. Uspešna pridobitev ključavnice za branje zagotavlja vidnost sprememb, objavljenih s predhodno sprostitvijo povezane ključavnice za pisanje.

Pogosta implementacija je ReentrantReadWriteLock. Njegov privzeti način ne zagotavlja poštenega vrstnega reda. Ne poskušajte pridobiti ključavnice za pisanje, dokler še držite ključavnico za branje: ta implementacija takšne nadgradnje ne podpira. Ko sprostite ključavnico za branje in pridobite ključavnico za pisanje, znova preverite pogoj, saj se je stanje lahko spremenilo. Te pravilnike implementacije niso dodatna jamstva vmesnika.

Ta pristop pride v poštev pri pogostem branju in redkejšem pisanju, vendar lahko režijski stroški odtehtajo koristi; izmerite zmogljivost. Primer ščiti value in deterministično izpiše 42. Zaporedni klici v main prikazujejo uporabo API-ja, ne vzporednega izvajanja ali pravilnosti pri vsakem možnem prepletanju niti.

Primeri

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());
    }
}

Rezultat

42

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri