Avez-vous travaillé avec des sémaphores dans votre…

Oui, j'ai dû utiliser des sémaphores, notamment dans le contexte du travail avec la concurrence dans les applications Android.

Les sémaphores en Java (java.util.concurrent.Semaphore) sont utilisés pour limiter le nombre de threads pouvant accéder simultanément à une ressource donnée. Cela est utile dans des scénarios où la ressource a une "capacité" limitée, par exemple, un pool de connexions ou un nombre limité de slots disponibles.

Les principales méthodes avec lesquelles j'ai travaillé sont :

acquire(): Bloque le thread actuel jusqu'à ce qu'une permission soit disponible.
acquire(int permits): Bloque le thread actuel jusqu'à ce que le nombre spécifié de permissions soit disponible.
release(): Rétrograde une permission au sémaphore, augmentant le nombre de permissions disponibles.
release(int permits): Rétrograde le nombre spécifié de permissions.
tryAcquire(): Tente d'obtenir une permission sans bloquer le thread.
availablePermits(): Retourne le nombre actuel de permissions disponibles.

Exemple d'utilisation :

import java.util.concurrent.Semaphore;

public class ResourcePool {

    private static final int MAX_AVAILABLE = 5;
    private final Semaphore permits = new Semaphore(MAX_AVAILABLE, true); // Sémaphore équitable

    public void useResource() throws InterruptedException {
        permits.acquire(); // Demande une permission
        try {
            // Logique d'utilisation de la ressource (par exemple, travailler avec un pool de connexions)
            System.out.println(Thread.currentThread().getName() + " utilisant la ressource.");
            Thread.sleep(1000); // Simulation du travail avec la ressource
        } finally {
            permits.release(); // Libère la permission
            System.out.println(Thread.currentThread().getName() + " a fini d'utiliser la ressource.");
        }
    }

    public static void main(String[] args) {
        ResourcePool pool = new ResourcePool();
        // Création de plusieurs threads qui tenteront d'utiliser la ressource
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    pool.useResource();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Dans cet exemple, le sémaphore permits est initialisé avec 5 permissions, ce qui signifie que seulement 5 threads peuvent être dans le bloc try utilisant la ressource en même temps. La méthode acquire() bloque les threads si toutes les permissions sont occupées, jusqu'à ce que d'autres threads appellent release().

Les sémaphores sont utiles pour gérer l'accès à des pools de ressources limitées, mais il faut faire attention aux problèmes potentiels comme les deadlocks, si la gestion de l'obtention et de la libération des permissions n'est pas correcte. Utiliser try avec un bloc finally pour appeler release() est une bonne pratique pour assurer la libération des ressources même en cas d'exception.

Avez-vous travaillé avec des sémaphores dans votre pratique?