CKTIS / Java
Lees-schrijfvergrendeling: readLock(), writeLock(), lock() en unlock()
Meerdere threads kunnen gedeelde gegevens tegelijk lezen, maar schrijven vereist exclusieve toegang. Een lock kiezen is niet hetzelfde als die verkrijgen.
Versie: Java SE 21
Syntax
// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();
// java.util.concurrent.locks.Lock
void lock();
void unlock();In Java SE 21 zijn ReadWriteLock en Lock interfaces in het pakket java.util.concurrent.locks. readLock() en writeLock() geven de bijbehorende Lock-objecten terug, zonder de locks te verkrijgen. Gebruik één gedeelde ReadWriteLock-instantie voor de toestand: de leeslock voor bewerkingen die niets wijzigen en de schrijflock voor wijzigingen. Meerdere threads kunnen de leeslock tegelijk vasthouden. Zolang één thread de schrijflock vasthoudt, kan geen andere thread een van beide locks verkrijgen.
lock() en unlock() nemen geen argumenten aan en hebben retourtype void. Roep lock() aan vóór het try-blok: als de lock niet beschikbaar is, wacht de thread tot die de lock verkrijgt. Roep in finally unlock() aan op hetzelfde Lock-object om de lock ook vrij te geven als de beschermde code een uitzondering gooit. Het voorbeeld gebruikt tryLock() zonder argumenten. Die methode wacht niet en geeft true terug als de lock is verkregen, anders false. Geef een lock alleen vrij als die met succes is verkregen.
Zodra de schrijflock is vrijgegeven, ziet een thread die daarna de bijbehorende leeslock verkrijgt de wijzigingen die onder de schrijflock zijn gemaakt. De locks beschermen geen code die de toestand benadert zonder ze te gebruiken.
Bij ReentrantReadWriteLock moet de thread elke verkrijging met één unlock() afhandelen. Een lock vrijgeven die de thread niet vasthoudt, veroorzaakt IllegalMonitorStateException. Probeer de schrijflock niet te verkrijgen als je alleen de leeslock vasthoudt: lock() keert dan niet terug. Geef de leeslock vrij, verkrijg de schrijflock en controleer de toestand opnieuw, want die kan intussen zijn veranderd. Omgekeerd kun je de leeslock verkrijgen terwijl je de schrijflock nog vasthoudt en daarna de schrijflock vrijgeven.
Voorbeelden
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();
}
}
}Resultaat
read lock held: reader=0, writer=false write lock held: reader=blocked, writer=false read after write: 10
Terwijl de hoofdthread de leeslock vasthoudt, leest een tweede thread `0`, maar kan die de schrijflock niet verkrijgen. Nadat de hoofdthread `10` heeft ingesteld en zolang die de schrijflock vasthoudt, mislukken beide pogingen van de tweede thread. Na het vrijgeven van de schrijflock levert een beschermde leesbewerking `10` op. `FutureTask.get()` zorgt voor deze volgorde zonder slaappauzes.
Gerelateerde lessen
- Java · Les 29 · Gevorderd · Versie: 2