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.