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

CKTIS / Java

ReadWriteLock — bloqueios separados de leitura e escrita

ReadWriteLock disponibiliza bloqueios associados de leitura e escrita: vários leitores podem partilhar o acesso, enquanto a escrita exige acesso exclusivo. Aprende a usar readLock() e writeLock(), a visibilidade das alterações e a libertar os bloqueios com segurança.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

ReadWriteLock rw = new ReentrantReadWriteLock();
Lock read = rw.readLock();
Lock write = rw.writeLock();
read.lock();
try {
    // Read protected state.
} finally {
    read.unlock();
}
write.lock();
try {
    // Modify protected state.
} finally {
    write.unlock();
}

java.util.concurrent.locks.ReadWriteLock é uma interface que representa um par de bloqueios associados. ReadWriteLock.readLock() devolve um Lock para leitura e ReadWriteLock.writeLock() um para escrita; chamar estes métodos não adquire um bloqueio. Vários leitores podem trabalhar em simultâneo quando não há um escritor; a escrita é exclusiva.

Chama lock() no objeto devolvido antes da secção protegida e unlock() em finally, colocando lock() antes de try. Todos os acessos ao estado protegido têm de seguir o mesmo protocolo. Não alteres o estado sob o bloqueio de leitura. A aquisição bem-sucedida do bloqueio de leitura torna visíveis as alterações publicadas por uma libertação anterior do bloqueio de escrita associado.

Uma implementação comum é ReentrantReadWriteLock. O seu modo predefinido não garante uma ordem justa. Não tentes adquirir o bloqueio de escrita enquanto ainda manténs o bloqueio de leitura: esta implementação não suporta essa conversão. Depois de libertares o bloqueio de leitura e adquirires o bloqueio de escrita, verifica novamente a condição, pois o estado pode ter mudado. Estas políticas da implementação não são garantias adicionais da interface.

Esta abordagem pode ser considerada quando as leituras são frequentes e as escritas menos frequentes, mas o custo adicional pode superar as vantagens; mede o desempenho. O exemplo protege value e apresenta 42 de forma determinística. As chamadas sequenciais em main demonstram a utilização da API, não a execução paralela nem a correção em todos os possíveis intercalamentos de threads.

Exemplos

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private int value;

    public int get() {
        Lock read = rw.readLock();
        read.lock();
        try {
            return value;
        } finally {
            read.unlock();
        }
    }

    public void set(int next) {
        Lock write = rw.writeLock();
        write.lock();
        try {
            value = next;
        } finally {
            write.unlock();
        }
    }

    public static void main(String[] args) {
        Main cell = new Main();
        cell.set(42);
        System.out.println(cell.get());
    }
}

Resultado

42

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes