Dolgozott már a gyakorlatában szignálsorompókkal…

Igen, használtam szemináriumokat, különösen Android alkalmazások több szálú működésével kapcsolatban.

A Java-ban (java.util.concurrent.Semaphore) a szemináriumokat arra használják, hogy korlátozzák, hány szál férhet hozzá egy adott erőforráshoz egyszerre. Ez hasznos olyan helyzetekben, ahol az erőforrás korlátozott "kapacitással" rendelkezik, például kapcsolatok poolja vagy korlátozott számú elérhető slot.

Az alapvető módszerek, amikkel dolgoztam:

acquire(): blokkolja az aktuális szálat, amíg engedély nem válik elérhetővé.
acquire(int permits): blokkolja az aktuális szálat, amíg a megadott számú engedély elérhetővé nem válik.
release(): visszaadja az engedélyt a szemináriumnak, növelve az elérhető engedélyek számát.
release(int permits): visszaadja a megadott számú engedélyt.
tryAcquire(): megpróbálja megszerezni az engedélyt, anélkül, hogy blokkolná a szálat.
availablePermits(): visszaadja az aktuálisan elérhető engedélyek számát.

Példa a használatra:

import java.util.concurrent.Semaphore;

public class ResourcePool {

    private static final int MAX_AVAILABLE = 5;
    private final Semaphore permits = new Semaphore(MAX_AVAILABLE, true); // Igazságos szeminárium

    public void useResource() throws InterruptedException {
        permits.acquire(); // Engedély kérés
        try {
            // Erőforrás használatának logikája (pl. kapcsolatok pooljával való munka)
            System.out.println(Thread.currentThread().getName() + " erőforrást használ.");
            Thread.sleep(1000); // Munka szimulálása az erőforrással
        } finally {
            permits.release(); // Engedély visszaadása
            System.out.println(Thread.currentThread().getName() + " befejezte az erőforrás használatát.");
        }
    }

    public static void main(String[] args) {
        ResourcePool pool = new ResourcePool();
        // Több szál létrehozása, amelyek megpróbálják használni az erőforrást
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    pool.useResource();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Ebben a példában a permits szeminárium 5 engedéllyel van inicializálva, ami azt jelenti, hogy egyszerre csak 5 szál lehet a try blokkban, amely az erőforrást használja. Az acquire() módszer blokkolja a szálakat, ha minden engedély foglalt, amíg más szálak nem hívják a release()-t.

A szemináriumok hasznosak a korlátozott erőforrások pooljának kezelésében, de figyelni kell a potenciális problémákra, például a holtpontokra, ha helytelenül kezeljük az engedélyek megszerzését és visszaadását. A try-val és a finally-nel történő release() hívás jó gyakorlat az erőforrások biztosítására még kivétel esetén is.

Dolgozott már a gyakorlatában szignálsorompókkal?