CKTIS / Java
Semáforo em Java: adquirir e libertar permissões
Aprende quando um semáforo espera, porque é que `tryAcquire()` difere de `tryAcquire(0)` e como evitar devolver permissões que não adquiriste.
Versão: Java SE 21
Sintaxe
import java.util.concurrent.Semaphore;
// Constructor and method signatures (Java SE 21)
Semaphore(int permits)
boolean tryAcquire()
boolean tryAcquire(int permits)
void acquire() throws InterruptedException
void release()Em Java SE 21, Semaphore(int), de java.util.concurrent, define o número inicial de permissões disponíveis. new Semaphore(2) começa com duas permissões, mas não impõe um limite máximo ao contador. Por omissão, a política não é equitativa: quando há concorrência pelas permissões, não há garantia de ordem FIFO.
tryAcquire() não espera. Se houver uma permissão disponível, adquire-a e devolve true; caso contrário, devolve false sem alterar o contador. tryAcquire(0) seleciona a sobrecarga que recebe o número de permissões. Quando há zero permissões disponíveis, devolve true sem adquirir nenhuma: o argumento não é um tempo de espera nulo.
acquire() adquire uma permissão e espera se for necessário. Se o estado de interrupção já estiver ativo à entrada ou se a thread for interrompida durante a espera, o método lança InterruptedException, limpa esse estado e não adquire nenhuma permissão. Mesmo num semáforo equitativo, tryAcquire() pode ultrapassar as threads em espera; tryAcquire(0, TimeUnit.SECONDS) também não espera, mas respeita a política de equidade e deteta a interrupção.
release() adiciona uma permissão sem verificar se a thread atual a adquiriu. Se usares o semáforo para limitar a concorrência, devolve em finally apenas as permissões efetivamente adquiridas, mesmo que o código protegido lance uma exceção. Coloca acquire() antes de try e guarda o resultado de tryAcquire() em permitHeld para que uma tentativa falhada não aumente o contador na libertação.
Exemplos
import java.util.concurrent.Semaphore;
public class SemaphoreDemo {
public static void main(String[] args) throws InterruptedException {
Semaphore semaphore = new Semaphore(2);
boolean permitHeld = false;
semaphore.acquire();
try {
permitHeld = semaphore.tryAcquire();
System.out.println("second permit: " + permitHeld);
System.out.println("available while held: " + semaphore.availablePermits());
System.out.println("tryAcquire(): " + semaphore.tryAcquire());
System.out.println("tryAcquire(0): " + semaphore.tryAcquire(0));
} finally {
if (permitHeld) {
semaphore.release();
}
semaphore.release();
}
System.out.println("available after cleanup: " + semaphore.availablePermits());
}
}Resultado
second permit: true available while held: 0 tryAcquire(): false tryAcquire(0): true available after cleanup: 2
Uma única thread adquire as duas permissões. Quando não resta nenhuma, as duas tentativas devolvem `false` e `true`, respetivamente. Depois de `finally`, voltam a estar disponíveis duas permissões.
Lições relacionadas
- Java · Lição 36 · Avançado · Versão: 2