CKTIS / Java
Bralno-pisalni zaklep: readLock(), writeLock(), lock() in unlock()
Več niti lahko hkrati bere skupne podatke, za pisanje pa je potreben izključni dostop. Izbira zaklepa še ne pomeni, da ga je nit pridobila.
Različica: Java SE 21
Sintaksa
// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();
// java.util.concurrent.locks.Lock
void lock();
void unlock();V Java SE 21 sta ReadWriteLock in Lock vmesnika iz paketa java.util.concurrent.locks. Metodi readLock() in writeLock() vrneta pripadajoča objekta Lock, ne da bi pridobili zaklepa. Za skupno stanje uporabite en skupen primerek ReadWriteLock: bralni zaklep za operacije brez sprememb, pisalnega pa za spreminjanje. Bralni zaklep lahko hkrati drži več niti. Dokler ena nit drži pisalni zaklep, nobena druga nit ne more pridobiti nobenega od obeh zaklepov.
Metodi lock() in unlock() ne sprejemata argumentov in imata povratni tip void. Pokličite lock() pred blokom try: če zaklep ni na voljo, nit počaka, da ga pridobi. V finally pokličite unlock() na istem objektu Lock, da se zaklep sprosti tudi ob izjemi v zaščiteni kodi. V primeru tryLock() brez argumentov ne čaka: vrne true, če pridobi zaklep, sicer false. Zaklep sprostite le po uspešni pridobitvi.
Ko je pisalni zaklep sproščen, nit, ki pozneje pridobi pripadajoči bralni zaklep, vidi spremembe, izvedene pod pisalnim zaklepom. Zaklepi ne ščitijo kode, ki do stanja dostopa, ne da bi jih uporabila.
Pri ReentrantReadWriteLock mora nit vsako pridobitev izravnati z enim klicem unlock(). Če sprosti zaklep, ki ga ne drži, se sproži IllegalMonitorStateException. Ne poskušajte pridobiti pisalnega zaklepa, če držite samo bralnega: klic lock() se ne bo vrnil. Sprostite bralni zaklep, pridobite pisalnega in ponovno preverite stanje, saj se je vmes morda spremenilo. V nasprotni smeri lahko pridobite bralni zaklep, medtem ko še držite pisalnega, nato pa pisalnega sprostite.
Primeri
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();
}
}
}Rezultat
read lock held: reader=0, writer=false write lock held: reader=blocked, writer=false read after write: 10
Medtem ko glavna nit drži bralni zaklep, druga nit prebere `0`, ne more pa pridobiti pisalnega zaklepa. Ko glavna nit nastavi `10` in še drži pisalni zaklep, oba poskusa druge niti spodletita. Po sprostitvi pisalnega zaklepa zaščiteno branje vrne `10`. `FutureTask.get()` zagotovi to zaporedje brez uspavanja niti.
Povezane lekcije
- Java · Lekcija 29 · Napredna · Različica: 2