Java Programming Concurrency Utilities Semaphore Countdownlatch Complete Guide

Java Programming Concurrency Utilities: Semaphore, CountDownLatch

Semaphore

A Semaphore in Java is a concurrency control mechanism that allows multiple threads to access a common resource in a controlled manner. It maintains a set number of permits, which threads can acquire and release as they enter and exit the critical section of the code. Semaphores are particularly useful in scenarios where limited resources need to be shared among multiple threads.

Key Points:

• Permits: Each semaphore has a maximum number of permits. Threads acquire permits to enter the critical section and release them when they are done.
• Fairness: Semaphores can be created in "fair" mode, meaning that the semaphore will grant permits to waiting threads in the order in which they requested them.
• Multiple Permits: You can acquire or release more than one permit at a time, making it flexible for various use cases.
• Use Cases: Resource pooling, limiting concurrent execution, controlling resource access, etc.

Example Code:

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final int MAX_PERMITS = 3;

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(MAX_PERMITS, true); // Fair Semaphore

        for (int i = 0; i < 5; i++) {
            new Thread(new Worker(semaphore, "Thread-" + i)).start();
        }
    }

    static class Worker implements Runnable {
        private final Semaphore semaphore;
        private final String name;

        public Worker(Semaphore semaphore, String name) {
            this.semaphore = semaphore;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire(); // Acquire a permit
                System.out.println(name + " has entered the critical section.");
                Thread.sleep(2000); // Simulate work
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                semaphore.release(); // Release the permit
                System.out.println(name + " has exited the critical section.");
            }
        }
    }
}

Explanation:

• Semaphore Initialization: The semaphore is initialized with 3 permits, allowing up to 3 threads to enter the critical section simultaneously.
• Thread Creation: Five threads are created, each trying to acquire a permit from the semaphore.
• Acquire and Release: When a thread acquires a permit, it enters the critical section. After completing its task, it releases the permit, allowing other threads to enter.

CountDownLatch

A CountDownLatch is a synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes. It is used for coordinating multiple threads where one thread should wait for others to complete their tasks before proceeding.

Key Points:

• Countdown: The count is initialized when the latch is created and can only be decremented. Once the count reaches zero, all waiting threads are allowed to proceed.
• Threads: Any thread can decrement the count or wait for the latch to reach zero.
• Use Cases: Thread synchronization, initialization of resources, waiting for multiple operations to complete, etc.

Example Code:

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private static final int NUM_WORKERS = 3;

    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(NUM_WORKERS);

        for (int i = 0; i < NUM_WORKERS; i++) {
            new Thread(new Worker(latch, "Thread-" + i)).start();
        }

        try {
            latch.await(); // Wait for all workers to finish
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("All workers have completed their tasks.");
    }

    static class Worker implements Runnable {
        private final CountDownLatch latch;
        private final String name;

        public Worker(CountDownLatch latch, String name) {
            this.latch = latch;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                System.out.println(name + " is starting.");
                Thread.sleep(2000); // Simulate work
                System.out.println(name + " has finished.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                latch.countDown(); // Decrement the count
            }
        }
    }
}

Explanation:

• CountDownLatch Initialization: The latch is created with a count of 3, representing the number of worker threads.
• Thread Creation: Three threads are created, each performing some work independently.
• Await and CountDown: The main thread waits until the latch count is reduced to zero (all workers have completed their tasks), and then it proceeds with its execution.

Summary

In summary, Java's Semaphore and CountDownLatch are powerful concurrency utilities that enable developers to control thread access and synchronization effectively. Semaphore manages multiple permits to control the number of threads accessing a shared resource, while CountDownLatch allows one or more threads to wait until a set of operations performed in other threads completes. Both tools enhance the robustness and efficiency of concurrent Java applications.