CKTIS / Java
Bloqueio de leitura e escrita: readLock(), writeLock(), lock() e unlock()
Várias threads podem ler dados partilhados em simultâneo, mas a escrita exige acesso exclusivo. Escolher um bloqueio não é o mesmo que adquiri-lo.
Versão: Java SE 21
Sintaxe
// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();
// java.util.concurrent.locks.Lock
void lock();
void unlock();Em Java SE 21, ReadWriteLock e Lock são interfaces do pacote java.util.concurrent.locks. readLock() e writeLock() devolvem os objetos Lock associados sem adquirir os bloqueios. Usa uma única instância partilhada de ReadWriteLock para proteger o estado: o bloqueio de leitura para operações que não o alteram e o de escrita para alterações. Várias threads podem deter o bloqueio de leitura em simultâneo. Enquanto uma thread detém o bloqueio de escrita, nenhuma outra pode adquirir qualquer um dos dois bloqueios.
lock() e unlock() não recebem argumentos e têm tipo de retorno void. Chama lock() antes do bloco try: se o bloqueio estiver indisponível, a thread espera até o adquirir. Chama unlock() no mesmo Lock em finally, para libertar o bloqueio mesmo que o código protegido lance uma exceção. O exemplo usa tryLock() sem argumentos, que não espera: devolve true se adquirir o bloqueio e false caso contrário. Só libertes o bloqueio depois de o adquirires com êxito.
Depois de libertado o bloqueio de escrita, uma thread que adquira posteriormente o bloqueio de leitura associado vê as alterações feitas sob o bloqueio de escrita. Os bloqueios não protegem o código que acede ao estado sem os usar.
Com ReentrantReadWriteLock, a thread tem de fazer corresponder um unlock() a cada aquisição. Libertar um bloqueio que não detém lança IllegalMonitorStateException. Não tentes adquirir o bloqueio de escrita enquanto deténs apenas o de leitura: lock() não retorna. Liberta o bloqueio de leitura, adquire o de escrita e volta a verificar o estado, pois pode ter mudado entretanto. No sentido inverso, podes adquirir o bloqueio de leitura mantendo o de escrita e, só depois, libertar o de escrita.
Exemplos
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();
}
}
}Resultado
read lock held: reader=0, writer=false write lock held: reader=blocked, writer=false read after write: 10
Enquanto a thread principal detém o bloqueio de leitura, uma segunda thread lê `0`, mas não consegue adquirir o bloqueio de escrita. Depois de a thread principal atribuir `10`, e enquanto ainda detém o bloqueio de escrita, as duas tentativas da segunda thread falham. Uma vez libertado o bloqueio de escrita, uma leitura protegida obtém `10`. `FutureTask.get()` mantém esta ordem sem recorrer a pausas.
Lições relacionadas
- Java · Lição 29 · Avançado · Versão: 2