CKTIS / Java
Sémaphore Java : acquérir et libérer des permis
Découvrez quand un sémaphore attend un permis, pourquoi `tryAcquire()` diffère de `tryAcquire(0)` et comment éviter d’ajouter des permis en trop.
Version : Java SE 21
Syntaxe
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()Dans Java SE 21, Semaphore(int), dans java.util.concurrent, fixe le nombre initial de permis disponibles. new Semaphore(2) démarre avec deux permis sans imposer de plafond au compteur. Par défaut, la politique est non équitable : en cas de contention, l’ordre FIFO n’est pas garanti.
tryAcquire() n’attend pas. Si un permis est disponible, la méthode le prend et renvoie true ; sinon, elle renvoie false sans modifier le compteur. tryAcquire(0) sélectionne la surcharge qui prend un nombre de permis. Quand aucun permis n’est disponible, elle renvoie true sans rien prendre : l’argument n’est pas un délai nul.
acquire() prend un permis et attend si nécessaire. Si l’indicateur d’interruption est déjà positionné à l’entrée ou si le thread est interrompu pendant l’attente, la méthode lève InterruptedException, efface l’indicateur et ne prend aucun permis. Même sur un sémaphore équitable, tryAcquire() peut passer devant les threads en attente ; tryAcquire(0, TimeUnit.SECONDS) n’attend pas non plus, mais respecte la politique d’équité et détecte l’interruption.
release() ajoute un permis sans vérifier que le thread courant l’a acquis. Pour limiter le nombre d’opérations simultanées, rendez dans finally uniquement les permis effectivement acquis, même si le code protégé lève une exception. Placez acquire() avant le try et stockez le résultat de tryAcquire() dans permitHeld pour éviter d’augmenter le compteur après un échec.
Exemples
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());
}
}Résultat
second permit: true available while held: 0 tryAcquire(): false tryAcquire(0): true available after cleanup: 2
Un seul thread prend les deux permis. Quand il n’en reste aucun, les deux essais renvoient respectivement `false` et `true`. Après `finally`, deux permis sont à nouveau disponibles.
Leçons associées
- Java · Leçon 36 · Avancé · Version : 2