CKTIS / Java
ReadWriteLock — samostatné zámky pro čtení a zápis
ReadWriteLock poskytuje související zámky pro čtení a zápis: přístup může sdílet více čtenářů, zatímco zápis vyžaduje výhradní přístup. Seznamte se s metodami readLock() a writeLock(), viditelností změn a bezpečným uvolňováním zámků.
Verze: Java SE 21; repository runtime, production runtime not attested
Syntaxe
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 rozhraní pro dvojici souvisejících zámků. ReadWriteLock.readLock() vrací Lock pro čtení a ReadWriteLock.writeLock() zámek pro zápis; voláním těchto metod se zámek nezíská. Pokud není aktivní žádný zapisující, může současně pracovat více čtenářů; zápis je výhradní.
Před chráněnou částí zavolejte na vráceném objektu lock() a v bloku finally unlock(); volání lock() umístěte před try. Veškerý přístup k chráněnému stavu musí dodržovat stejný protokol. Stav pod zámkem pro čtení neměňte. Úspěšné získání zámku pro čtení zajišťuje viditelnost změn zveřejněných předchozím uvolněním souvisejícího zámku pro zápis.
Typickou implementací je ReentrantReadWriteLock. Jeho výchozí režim nezaručuje spravedlivé pořadí. Nepokoušejte se získat zámek pro zápis, dokud stále držíte zámek pro čtení: tato implementace takový upgrade nepodporuje. Po uvolnění zámku pro čtení a získání zámku pro zápis podmínku znovu ověřte, protože stav se mohl změnit. Tyto zásady implementace nejsou dalšími zárukami rozhraní.
Tento přístup zvažte při častém čtení a méně častém zápisu, ale režie může převážit nad přínosy; změřte výkon. Příklad chrání value a deterministicky vypíše 42. Sekvenční volání v main ukazují použití API, nikoli paralelní vykonávání ani správnost při každém možném prokládání vláken.
Příklady
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());
}
}Výsledek
42
Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.