Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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

Fontes