CKTIS / Java
Zámok na čítanie a zápis: readLock(), writeLock(), lock() a unlock()
Zdieľané údaje môže čítať viac vlákien naraz, ale zápis vyžaduje výhradný prístup. Výberom zámku ho vlákno ešte nezíska.
Verzia: Java SE 21
Syntax
// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();
// java.util.concurrent.locks.Lock
void lock();
void unlock();V Java SE 21 sú ReadWriteLock a Lock rozhrania z balíka java.util.concurrent.locks. Metódy readLock() a writeLock() vracajú príslušné objekty Lock, ale zámky nezískavajú. Pre zdieľaný stav používajte jednu spoločnú inštanciu ReadWriteLock: zámok na čítanie pri operáciách bez zmien a zámok na zápis pri zmenách. Zámok na čítanie môže držať viac vlákien naraz. Kým jedno vlákno drží zámok na zápis, žiadne iné vlákno nemôže získať ani jeden z týchto dvoch zámkov.
Metódy lock() a unlock() neprijímajú argumenty a majú návratový typ void. Volajte lock() pred blokom try: ak zámok nie je dostupný, vlákno čaká, kým ho získa. V finally zavolajte unlock() na tom istom objekte Lock, aby sa zámok uvoľnil aj pri výnimke v chránenom kóde. Bezargumentové tryLock() z príkladu nečaká a vráti true, ak zámok získalo, inak false. Zámok uvoľňujte iba po úspešnom získaní.
Po uvoľnení zámku na zápis vlákno, ktoré neskôr získa príslušný zámok na čítanie, uvidí zmeny vykonané pod zámkom na zápis. Zámky nechránia kód, ktorý pristupuje k stavu bez ich použitia.
Pri ReentrantReadWriteLock musí vlákno vyvážiť každé získanie jedným volaním unlock(). Uvoľnenie zámku, ktorý vlákno nedrží, vyvolá IllegalMonitorStateException. Nepokúšajte sa získať zámok na zápis, kým držíte iba zámok na čítanie: lock() sa nevráti. Uvoľnite zámok na čítanie, získajte zámok na zápis a opäť skontrolujte stav, pretože sa medzitým mohol zmeniť. V opačnom smere môžete získať zámok na čítanie, kým ešte držíte zámok na zápis, a až potom uvoľniť zámok na zápis.
Príklady
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();
}
}
}Výsledok
read lock held: reader=0, writer=false write lock held: reader=blocked, writer=false read after write: 10
Kým hlavné vlákno drží zámok na čítanie, druhé vlákno prečíta `0`, ale nezíska zámok na zápis. Po nastavení hodnoty `10`, kým hlavné vlákno ešte drží zámok na zápis, oba pokusy druhého vlákna zlyhajú. Po uvoľnení zámku na zápis chránené čítanie vráti `10`. `FutureTask.get()` zabezpečí toto poradie bez uspávania vlákien.
Súvisiace lekcie
- Java · Lekcia 29 · Pokročilá · Verzia: 2