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

CKTIS / Java

Lock — aquisição e libertação explícitas do bloqueio

A interface java.util.concurrent.locks.Lock permite controlar explicitamente os bloqueios. Aprende o par lock()/unlock(), o padrão seguro try/finally e um exemplo que usa ReentrantLock para proteger um contador partilhado.

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

Sintaxe

Lock lock = new ReentrantLock();
lock.lock();
try {
    // protected operations
} finally {
    lock.unlock();
}

java.util.concurrent.locks.Lock é uma interface para bloqueio explícito; ReentrantLock é uma implementação que proporciona exclusão mútua e permite a reentrada pela mesma thread. Nem todas as implementações de Lock têm necessariamente estas propriedades.

Lock.lock() adquire o bloqueio, aguardando se necessário; Lock.unlock() liberta-o. Chama lock.lock() antes de try e lock.unlock() em finally. Ao contrário de synchronized, a libertação não é automática. finally garante a libertação mesmo que ocorra uma exceção no código protegido.

Todos os acessos concorrentes ao estado protegido têm de seguir o mesmo protocolo de bloqueio. A aquisição do bloqueio por uma thread que ainda não o detém e a sua libertação completa, quando bem-sucedidas, têm os mesmos efeitos de sincronização da memória que a aquisição e a libertação de um monitor, respetivamente. Lock não exige esses efeitos nas operações que falham, nem nas aquisições reentrantes e nas libertações correspondentes. synchronized (lock) não substitui lock.lock().

Com ReentrantLock, cada aquisição exige uma libertação correspondente; se uma thread que não detém o bloqueio chamar unlock(), é lançada IllegalMonitorStateException. A interface também disponibiliza tryLock() e lockInterruptibly() para outras estratégias de espera.

O exemplo usa um único bloqueio partilhado para ambas as operações count++. Depois das duas chamadas a join(), o programa apresenta 2, independentemente da ordem de execução das threads. Âmbito da documentação: Java SE 21; os ambientes de execução do repositório e de produção não estão atestados.

Exemplos

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final Lock lock = new ReentrantLock();
    private static int count = 0;

    private static void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread first = new Thread(Main::increment);
        Thread second = new Thread(Main::increment);
        first.start();
        second.start();
        first.join();
        second.join();
        System.out.println(count);
    }
}

Resultado

2

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