Difference Between CyclicBarrier and CountDownLatch in Java

Concurrency is a fundamental aspect of modern software development, and Java provides several mechanisms to handle concurrent tasks efficiently. Two commonly used synchronization tools in Java are CyclicBarrier and CountDownLatch. Despite their similar-sounding names, these classes serve distinct purposes in managing concurrent operations. In this section, we will explore the differences between CyclicBarrier and CountDownLatch along with detailed explanations, code examples, and output demonstrations.

CyclicBarrier

The CyclicBarrier class in Java is designed to allow a group of threads to wait for each other to reach a common point, where they can synchronize and proceed together. The barrier is cyclic because it can be reused after all threads have reached it.

File Name: CyclicBarrierExample.java

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierExample {
    public static void main(String[] args) {
        int numberOfThreads = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(numberOfThreads);
        for (int i = 0; i < numberOfThreads; i++) {
            Thread thread = new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " is waiting");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " has crossed the barrier");
            });
            thread.start();
        }
    }
}

Output:

Thread-0 is waiting
Thread-1 is waiting
Thread-2 is waiting
Thread-2 has crossed the barrier
Thread-0 has crossed the barrier
Thread-1 has crossed the barrier

CountDownLatch

The CountDownLatch class in Java is used to make a thread wait until the count of CountDownLatch reaches zero. It's a one-time use synchronization tool where the count cannot be reset, making it suitable for scenarios where a specific number of tasks need to be completed before a process continues.

File Name: CountDownLatchExample.java

import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
    public static void main(String[] args) {
        int count = 3;
        CountDownLatch countDownLatch = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            Thread thread = new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " has completed its task");
                countDownLatch.countDown();
            });
            thread.start();
        }
        try {
            countDownLatch.await();
            System.out.println("All tasks have been completed. Proceeding...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Output:

Thread-0 has completed its task
Thread-2 has completed its task
Thread-1 has completed its task
All tasks have been completed. Proceeding...

CyclicBarrier Vs. CountDownLatch in Java

Feature	CyclicBarrier	CountDownLatch
Purpose	Synchronizes threads at a common barrier point.	Delays execution until the count reaches zero.
Reuse	Cyclic; can be reset and reused after all threads arrive.	One-time use; the count cannot be reset once it reaches zero.
Count Changes	Dynamic; the number of parties can be changed at runtime.	Fixed; the count is set during initialization and cannot be changed.
Parties	Threads wait for each other, all must reach the barrier.	Threads wait for a fixed number of tasks to complete.

Understanding these differences is crucial for choosing the appropriate synchronization tool based on the specific requirements of our concurrent application. CyclicBarrier is suitable for scenarios where a group of threads needs to synchronize and proceed together, while CountDownLatch is ideal for situations where a fixed number of tasks must be completed before proceeding.

In summary, both CyclicBarrier and CountDownLatch contribute to effective concurrency management in Java, providing developers with powerful tools to control the execution flow of their multithreaded applications.

Next TopicDifference Between Shallow and Deep Cloning in Java

← prev next →