Haben Sie in Ihrer Praxis mit Semaphoren gearbeitet…

Ja, ich musste Semaphoren verwenden, insbesondere im Zusammenhang mit Multithreading in Android-Anwendungen.

Semaphoren in Java (java.util.concurrent.Semaphore) werden verwendet, um die Anzahl der Threads zu begrenzen, die gleichzeitig auf eine bestimmte Ressource zugreifen können. Dies ist in Szenarien nützlich, in denen die Ressource eine "Kapazität" hat, z.B. einen Verbindungspool oder eine begrenzte Anzahl verfügbarer Slots.

Die Hauptmethoden, mit denen ich gearbeitet habe, sind:

acquire(): Blockiert den aktuellen Thread, bis eine Erlaubnis verfügbar ist.
acquire(int permits): Blockiert den aktuellen Thread, bis die angegebene Anzahl an Erlaubnissen verfügbar ist.
release(): Gibt eine Erlaubnis an das Semaphor zurück und erhöht die Anzahl der verfügbaren Erlaubnisse.
release(int permits): Gibt die angegebene Anzahl an Erlaubnissen zurück.
tryAcquire(): Versucht, eine Erlaubnis zu erhalten, ohne den Thread zu blockieren.
availablePermits(): Gibt die aktuelle Anzahl der verfügbaren Erlaubnisse zurück.

Beispiel für die Verwendung:

import java.util.concurrent.Semaphore;

public class ResourcePool {

    private static final int MAX_AVAILABLE = 5;
    private final Semaphore permits = new Semaphore(MAX_AVAILABLE, true); // Fairer Semaphor

    public void useResource() throws InterruptedException {
        permits.acquire(); // Erlaubnis anfordern
        try {
            // Logik zur Nutzung der Ressource (z.B. Arbeit mit einem Verbindungspool)
            System.out.println(Thread.currentThread().getName() + " benutzt die Ressource.");
            Thread.sleep(1000); // Simulation der Arbeit mit der Ressource
        } finally {
            permits.release(); // Erlaubnis freigeben
            System.out.println(Thread.currentThread().getName() + " hat die Ressource beendet.");
        }
    }

    public static void main(String[] args) {
        ResourcePool pool = new ResourcePool();
        // Mehrere Threads erstellen, die versuchen, die Ressource zu verwenden
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    pool.useResource();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

In diesem Beispiel wird der Semaphor permits mit 5 Erlaubnissen initialisiert, was bedeutet, dass maximal 5 Threads gleichzeitig im Block try die Ressource verwenden können. Die Methode acquire() blockiert Threads, wenn alle Erlaubnisse belegt sind, bis andere Threads release() aufrufen.

Semaphoren sind nützlich, um den Zugriff auf begrenzte Ressourcenpools zu steuern, aber es ist wichtig, auf potenzielle Probleme wie Deadlocks zu achten, wenn die Erlaubnisverwaltung nicht korrekt erfolgt. Die Verwendung von try mit einem finally-Block zum Aufruf von release() ist eine bewährte Praxis, um die Freigabe von Ressourcen auch bei Ausnahmen sicherzustellen.

Haben Sie in Ihrer Praxis mit Semaphoren gearbeitet?