Java Concurrency - Semaphore

Use java.util.concurrent.Semaphore to control concurrent access to a resource in Java.

---

What is a Semaphore?

A Semaphore is a synchronization aid that controls access to a shared resource by maintaining a set number of permits. It can be thought of as a counter that controls how many threads can access a resource at the same time.

Key Concepts:

• Permits: Define how many threads can access a resource concurrently.
• Acquire & Release: Threads acquire permits before proceeding and release them when done.
• Blocking & Non-Blocking: Threads can wait indefinitely for permits or use timeouts.

When to Use a Semaphore

Use Semaphore when:

• You need to limit access to a shared resource (e.g., database connections, file access).
• Implementing rate limiting or thread pooling.
• Managing fair access to critical sections.

How Semaphore Works

The basic usage of Semaphore involves:

1. Creating a Semaphore with a specified number of permits.
2. Threads acquiring and releasing permits as needed.

Example: Controlling Access to a Resource

import java.util.concurrent.Semaphore;

class SharedResource {
    private final Semaphore semaphore = new Semaphore(3); // Allow up to 3 threads

    void accessResource(String threadName) {
        try {
            System.out.println(threadName + " is trying to acquire a permit...");
            semaphore.acquire();
            System.out.println(threadName + " acquired a permit. Performing operation...");
            Thread.sleep(2000); // Simulate resource usage
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            System.out.println(threadName + " is releasing the permit.");
            semaphore.release();
        }
    }
}

public class SemaphoreExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        Runnable task = () -> {
            String threadName = Thread.currentThread().getName();
            resource.accessResource(threadName);
        };

        // Create multiple threads to simulate concurrent access
        for (int i = 1; i <= 5; i++) {
            new Thread(task, "Thread-" + i).start();
        }
    }
}

Output (Example Execution)

Thread-1 is trying to acquire a permit...
Thread-1 acquired a permit. Performing operation...
Thread-2 is trying to acquire a permit...
Thread-2 acquired a permit. Performing operation...
Thread-3 is trying to acquire a permit...
Thread-3 acquired a permit. Performing operation...
Thread-4 is trying to acquire a permit...
Thread-5 is trying to acquire a permit...
Thread-1 is releasing the permit.
Thread-4 acquired a permit. Performing operation...
...

Fair vs. Non-Fair Semaphores

By default, Semaphore is non-fair, meaning it does not guarantee that the longest-waiting thread gets the permit first. You can create a fair semaphore like this:

Semaphore semaphore = new Semaphore(3, true);

A fair semaphore ensures that permits are granted in FIFO (First-In-First-Out) order. This is useful when strict ordering is needed but may slightly impact performance.

Advanced Use Case: Semaphore for Producer-Consumer

Semaphores can also be used to implement producer-consumer patterns where producers generate items and consumers process them.

import java.util.concurrent.Semaphore;
import java.util.LinkedList;
import java.util.Queue;

class SharedQueue {
    private final Queue<Integer> queue = new LinkedList<>();
    private final Semaphore items = new Semaphore(0); // Track available items
    private final Semaphore spaces; // Track available space

    SharedQueue(int capacity) {
        this.spaces = new Semaphore(capacity);
    }

    void produce(int item) throws InterruptedException {
        spaces.acquire();
        synchronized (this) {
            queue.offer(item);
            System.out.println("Produced: " + item);
        }
        items.release();
    }

    void consume() throws InterruptedException {
        items.acquire();
        synchronized (this) {
            int item = queue.poll();
            System.out.println("Consumed: " + item);
        }
        spaces.release();
    }
}

public class ProducerConsumerSemaphore {
    public static void main(String[] args) {
        SharedQueue sharedQueue = new SharedQueue(5);

        Runnable producer = () -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    sharedQueue.produce(i);
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Runnable consumer = () -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    sharedQueue.consume();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        new Thread(producer, "Producer").start();
        new Thread(consumer, "Consumer").start();
    }
}

tryAcquire()

Acquires a permit from this semaphore, only if one is available at the time of invocation.

This method is often used in scenarios where you want to attempt to acquire a permit without blocking the thread. If a permit is available, it returns true; otherwise, it returns false.

Conclusion

Semaphore is a powerful tool in Java’s concurrency toolkit. It helps manage access to resources, control concurrent execution, and prevent race conditions. Whether you need to limit access to a resource, implement a producer-consumer model, or enforce fairness, Semaphore provides a flexible and efficient solution.

Key Takeaways:
✅ Use Semaphore to limit concurrent access to shared resources.
✅ Choose fair or non-fair mode based on performance vs. fairness needs.
✅ Combine Semaphore with other concurrency tools for more advanced scenarios.

By mastering java.util.concurrent.Semaphore, you can write more efficient and thread-safe Java applications! 🚀

---

Would you like any refinements or more advanced examples? 😊