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

CKTIS / Java

Semaphore — limitar o acesso concorrente

java.util.concurrent.Semaphore limita o acesso através de um contador de permissões. Aprende a usar acquire(), que bloqueia, tryAcquire(), que não bloqueia, e a devolver permissões em segurança com release().

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

Sintaxe

Semaphore s = new Semaphore(permits, fair);

s.acquire(); // throws InterruptedException
try {
    // Use the permit.
} finally {
    s.release();
}

boolean acquired = s.tryAcquire();
if (acquired) {
    try {
        // Use the permit.
    } finally {
        s.release();
    }
}

boolean acquiredInTime = s.tryAcquire(timeout, unit); // throws InterruptedException
if (acquiredInTime) {
    try {
        // Use the permit.
    } finally {
        s.release();
    }
}

Semaphore é um semáforo contador: as permissões limitam o acesso concorrente, mas não são objetos de recursos. new Semaphore(n) não é justo por omissão.

Semaphore.acquire() obtém uma permissão e espera, se necessário; pode lançar InterruptedException. Semaphore.tryAcquire() devolve imediatamente true se obtiver uma permissão, ou false caso contrário. A variante com limite de tempo pode esperar e ser interrompida.

Semaphore.release() acrescenta uma permissão. Ao limitar recursos, chama-o em finally apenas após uma obtenção bem-sucedida; uma libertação adicional aumenta o limite. Um semáforo não verifica quem possui a permissão. Coloca acquire() antes de try, para que uma espera interrompida não provoque uma libertação.

new Semaphore(n, true) garante a ordem FIFO nos pontos internos de entrada na fila, mas não a ordem de início das chamadas. tryAcquire() sem argumentos não espera e pode obter uma permissão disponível antes das threads que já estão na fila. As ações anteriores a release() acontecem antes das ações posteriores a uma obtenção bem-sucedida por outra thread no mesmo semáforo (happens-before). O limite, por si só, não protege as estruturas de dados dos recursos contra condições de corrida.

Exemplos

import java.util.concurrent.Semaphore;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Semaphore slots = new Semaphore(1);
        slots.acquire();
        try {
            System.out.println(slots.tryAcquire());
        } finally {
            slots.release();
        }
        if (slots.tryAcquire()) {
            try {
                System.out.println("acquired");
            } finally {
                slots.release();
            }
        }
    }
}

Resultado

false
acquired

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