Heeft u in uw praktijk met semaforen gewerkt?

Ja, ik heb semaforen moeten gebruiken, vooral in de context van multithreading in Android-applicaties.

Semaforen in Java (java.util.concurrent.Semaphore) worden gebruikt om het aantal threads te beperken dat gelijktijdig toegang kan krijgen tot een bepaalde bron. Dit is handig in scenario's waar de bron een beperkte "capaciteit" heeft, bijvoorbeeld een verbindingenpool of een beperkt aantal beschikbare slots.

De belangrijkste methoden waarmee ik heb gewerkt zijn:

• acquire(): Blokkeert de huidige thread totdat een toestemming beschikbaar is.
• acquire(int permits): Blokkeert de huidige thread totdat het opgegeven aantal toestemmingen beschikbaar is.
• release(): Geeft een toestemming terug aan de semaphore, waardoor het aantal beschikbare toestemmingen toeneemt.
• release(int permits): Geeft het opgegeven aantal toestemmingen terug.
• tryAcquire(): Probeert een toestemming te verkrijgen zonder de thread te blokkeren.
• availablePermits(): Geeft het huidige aantal beschikbare toestemmingen terug.

Voorbeeld van gebruik:

import java.util.concurrent.Semaphore;

public class ResourcePool {

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

    public void useResource() throws InterruptedException {
        permits.acquire(); // Vraag toestemming aan
        try {
            // Logica voor het gebruik van de bron (bijvoorbeeld werken met een verbindingenpool)
            System.out.println(Thread.currentThread().getName() + " gebruikt de bron.");
            Thread.sleep(1000); // Simulatie van werk met de bron
        } finally {
            permits.release(); // Geef toestemming vrij
            System.out.println(Thread.currentThread().getName() + " heeft het gebruik van de bron voltooid.");
        }
    }

    public static void main(String[] args) {
        ResourcePool pool = new ResourcePool();
        // Maak meerdere threads die proberen de bron te gebruiken
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    pool.useResource();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

In dit voorbeeld wordt de semaphore permits geïnitialiseerd met 5 toestemmingen, wat betekent dat slechts 5 threads tegelijkertijd binnen de try-blok kunnen zijn die de bron gebruiken. De methode acquire() blokkeert threads als alle toestemmingen in gebruik zijn, totdat andere threads release() aanroepen.

Semaforen zijn handig voor het beheren van toegang tot beperkte resource-pools, maar het is belangrijk om op mogelijke problemen zoals deadlocks te letten, als het verkrijgen en vrijgeven van toestemmingen niet correct wordt beheerd. Het gebruik van try met een finally-blok om release() aan te roepen, is een goede praktijk om te zorgen dat resources worden vrijgegeven, zelfs bij uitzonderingen.