Você trabalhou com semáforos na sua prática?

Sim, tive que usar semáforos, especialmente no contexto do trabalho com concorrência em aplicações Android.

Os semáforos em Java (java.util.concurrent.Semaphore) são usados para limitar o número de threads que podem acessar simultaneamente um recurso específico. Isso é útil em cenários onde o recurso tem uma "capacidade" limitada, por exemplo, um pool de conexões ou um número limitado de slots disponíveis.

Os principais métodos com os quais trabalhei são:

• acquire(): Bloqueia a thread atual até que uma permissão esteja disponível.
• acquire(int permits): Bloqueia a thread atual até que a quantidade especificada de permissões esteja disponível.
• release(): Libera uma permissão ao semáforo, aumentando o número de permissões disponíveis.
• release(int permits): Libera a quantidade especificada de permissões.
• tryAcquire(): Tenta obter uma permissão sem bloquear a thread.
• availablePermits(): Retorna o número atual de permissões disponíveis.

Exemplo de uso:

import java.util.concurrent.Semaphore;

public class ResourcePool {

    private static final int MAX_AVAILABLE = 5;
    private final Semaphore permits = new Semaphore(MAX_AVAILABLE, true); // Semáforo justo

    public void useResource() throws InterruptedException {
        permits.acquire(); // Solicita permissão
        try {
            // Lógica de uso do recurso (por exemplo, trabalhar com um pool de conexões)
            System.out.println(Thread.currentThread().getName() + " usando recurso.");
            Thread.sleep(1000); // Simulação de trabalho com o recurso
        } finally {
            permits.release(); // Libera a permissão
            System.out.println(Thread.currentThread().getName() + " terminou de usar o recurso.");
        }
    }

    public static void main(String[] args) {
        ResourcePool pool = new ResourcePool();
        // Criamos vários threads que tentarão usar o recurso
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    pool.useResource();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Neste exemplo, o semáforo permits é inicializado com 5 permissões, o que significa que apenas 5 threads podem estar dentro do bloco try usando o recurso ao mesmo tempo. O método acquire() bloqueia os threads se todas as permissões estiverem ocupadas, até que outros threads chamem release().

Os semáforos são úteis para gerenciar o acesso a pools de recursos limitados, mas é importante estar atento a problemas potenciais como deadlocks, se a obtenção e liberação de permissões não forem gerenciadas corretamente. Usar try com um bloco finally para chamar release() é uma boa prática para garantir a liberação de recursos mesmo em caso de exceções.