Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Semáforo en Java: adquirir y liberar permisos

Aprende cuándo espera un semáforo, en qué se distinguen `tryAcquire()` y `tryAcquire(0)` y cómo evitar devolver permisos que no adquiriste.

Versión: Java SE 21

Sintaxis

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()

En Java SE 21, Semaphore(int), de java.util.concurrent, fija el número inicial de permisos disponibles. new Semaphore(2) empieza con dos permisos, pero no fija un tope para el contador. La política predeterminada no es equitativa: si hay contención, no garantiza el orden FIFO.

tryAcquire() no espera. Si hay un permiso disponible, lo toma y devuelve true; de lo contrario, devuelve false sin alterar el contador. tryAcquire(0) selecciona la sobrecarga que recibe una cantidad de permisos. Cuando hay cero permisos disponibles, devuelve true sin tomar ninguno: el argumento no es un tiempo de espera de cero.

acquire() toma un permiso y espera si es necesario. Si el indicador de interrupción ya está activo al entrar o el hilo se interrumpe mientras espera, lanza InterruptedException, borra el indicador y no toma ningún permiso. Incluso en un semáforo equitativo, tryAcquire() puede adelantarse a los hilos en espera; tryAcquire(0, TimeUnit.SECONDS) tampoco espera, pero respeta la política de equidad y detecta la interrupción.

release() añade un permiso sin comprobar si el hilo actual lo adquirió. Si usas el semáforo para limitar la concurrencia, devuelve en finally solo los permisos realmente adquiridos, aunque el código protegido lance una excepción. Pon acquire() antes de try y guarda el resultado de tryAcquire() en permitHeld para que un intento fallido no infle el contador durante la limpieza.

Ejemplos

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

Un solo hilo toma los dos permisos. Cuando no queda ninguno, las dos pruebas devuelven `false` y `true`, respectivamente. Tras `finally` vuelven a quedar dos permisos disponibles.

Lecciones relacionadas

  • Java · Lección 36 · Avanzado · Versión: 2

Fuentes