CKTIS / Java
Zámek pro čtení a zápis: readLock(), writeLock(), lock() a unlock()
Sdílená data může číst více vláken současně, ale zápis vyžaduje výhradní přístup. Výběrem zámku jej vlákno ještě nezíská.
Verze: Java SE 21
Syntaxe
// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();
// java.util.concurrent.locks.Lock
void lock();
void unlock();V Java SE 21 jsou ReadWriteLock a Lock rozhraní z balíčku java.util.concurrent.locks. Metody readLock() a writeLock() vracejí příslušné objekty Lock, ale zámky nezískávají. Pro sdílený stav používejte jedinou společnou instanci ReadWriteLock: zámek pro čtení při operacích bez změn, zámek pro zápis při změnách. Zámek pro čtení může držet několik vláken současně. Dokud jedno vlákno drží zámek pro zápis, žádné jiné vlákno nemůže získat ani jeden z obou zámků.
Metody lock() a unlock() nepřijímají argumenty a mají návratový typ void. Volejte lock() před blokem try: pokud zámek není k dispozici, vlákno čeká, až ho získá. V finally zavolejte unlock() na stejném objektu Lock, aby se zámek uvolnil i v případě výjimky v chráněném kódu. Bezargumentové tryLock() z příkladu nečeká a vrátí true, pokud zámek získá, jinak false. Zámek uvolňujte pouze po úspěšném získání.
Po uvolnění zámku pro zápis uvidí vlákno, které později získá příslušný zámek pro čtení, změny provedené pod zámkem pro zápis. Zámky nechrání kód, který přistupuje ke stavu, aniž je používá.
U ReentrantReadWriteLock musí vlákno každé získání vyvážit jedním voláním unlock(). Pokus o uvolnění zámku, který vlákno nedrží, vyvolá IllegalMonitorStateException. Nedržte pouze zámek pro čtení a zároveň se nepokoušejte získat zámek pro zápis: lock() se nevrátí. Uvolněte zámek pro čtení, získejte zámek pro zápis a zkontrolujte stav znovu, protože se mezitím mohl změnit. Opačně můžete při držení zámku pro zápis získat zámek pro čtení a teprve poté zámek pro zápis uvolnit.
Pří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ýsledek
read lock held: reader=0, writer=false write lock held: reader=blocked, writer=false read after write: 10
Zatímco hlavní vlákno drží zámek pro čtení, druhé vlákno přečte `0`, ale nezíská zámek pro zápis. Poté co hlavní vlákno nastaví `10` a dokud ještě drží zámek pro zápis, oba pokusy druhého vlákna selžou. Po uvolnění zámku pro zápis vrátí chráněné čtení `10`. `FutureTask.get()` zajistí toto pořadí bez uspávání vláken.
Související lekce
- Java · Lekce 29 · Pokročilá · Verze: 2