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

CKTIS / Java

StampedLock: leitura otimista, escrita e recurso ao bloqueio de leitura

Aprende quando podes usar os dados de uma leitura otimista e como repetir a leitura com um bloqueio partilhado, libertando-o com o selo correto.

Versão: Java SE 21

Sintaxe

java.util.concurrent.locks.StampedLock — Java SE 21
public long tryOptimisticRead()
public boolean validate(long stamp)
public long writeLock()
public void unlockWrite(long stamp)
public long readLock()
public void unlockRead(long stamp)

Em Java SE 21, java.util.concurrent.locks.StampedLock permite escrita exclusiva, leitura partilhada e leitura otimista. tryOptimisticRead() não espera nem adquire um bloqueio: devolve um selo do tipo long ou 0L se o bloqueio já estiver adquirido em modo de escrita. Com um selo otimista, não há nenhum bloqueio a libertar.

Com um selo diferente de zero, copia os campos necessários para variáveis locais e chama validate(long) no mesmo bloqueio. Para um selo otimista recente, true significa que não foi adquirido um bloqueio de escrita desde a emissão do selo. Isso não impede uma escrita posterior. validate(0L) devolve sempre false. Antes de uma validação bem-sucedida, as cópias podem ser incoerentes: não as uses em chamadas ou ações que pressuponham coerência. Se a validação devolver false, descarta todas as cópias.

writeLock() adquire o bloqueio em modo exclusivo e espera se necessário. A própria aquisição invalida os selos otimistas anteriores, mesmo sem alterar os dados e mesmo depois de o bloqueio ser libertado. Altera os dados protegidos sob o bloqueio de escrita e passa o respetivo selo a unlockWrite(long) em finally.

Se o selo for 0L ou a validação falhar, usa readLock() para adquirir um bloqueio partilhado, esperando se necessário. Volta a ler todos os campos necessários e chama unlockRead(long) em finally com o selo devolvido por readLock(), não com o selo otimista. Os métodos de libertação lançam IllegalMonitorStateException se o selo não corresponder ao estado do bloqueio. O bloqueio não é reentrante: não tentes adquiri-lo de novo enquanto já o deténs. Os selos não são credenciais de segurança.

Exemplos

import java.util.concurrent.locks.StampedLock;

public class StampedLockDemo {
    private final StampedLock lock = new StampedLock();
    private int value = 10;

    private void write(int newValue) {
        long writeStamp = lock.writeLock();
        try {
            value = newValue;
        } finally {
            lock.unlockWrite(writeStamp);
        }
    }

    private void demo() {
        long firstStamp = lock.tryOptimisticRead();
        int firstCopy = value;
        boolean firstValid = lock.validate(firstStamp);
        System.out.println("first valid: " + firstValid);
        if (firstValid) {
            System.out.println("first value: " + firstCopy);
        }

        long secondStamp = lock.tryOptimisticRead();
        int secondCopy = value;
        write(20);
        boolean secondValid = lock.validate(secondStamp);
        System.out.println("second valid: " + secondValid);
        if (!secondValid) {
            long readStamp = lock.readLock();
            try {
                secondCopy = value;
            } finally {
                lock.unlockRead(readStamp);
            }
        }
        System.out.println("second value: " + secondCopy);
    }

    public static void main(String[] args) {
        new StampedLockDemo().demo();
    }
}

Resultado

first valid: true
first value: 10
second valid: false
second value: 20

O exemplo usa uma única thread. A primeira leitura é validada e dá `10`. Na segunda, a escrita de `20` é colocada de propósito entre a cópia do campo e a validação. A cópia desatualizada é substituída por `20`, lido sob um bloqueio que é libertado com `readStamp`.

Lições relacionadas

  • Java · Lição 29 · Avançado · Versão: 2

Fontes