CountDownLatch vs. Semaphore
Solution 1
CountDownLatch
is frequently used for the exact opposite of your example. Generally, you would have many threads blocking on await()
that would all start simultaneously when the countown reached zero.
final CountDownLatch countdown = new CountDownLatch(1);
for (int i = 0; i < 10; ++ i) {
Thread racecar = new Thread() {
public void run() {
countdown.await(); //all threads waiting
System.out.println("Vroom!");
}
};
racecar.start();
}
System.out.println("Go");
countdown.countDown(); //all threads start now!
You could also use this as an MPI-style "barrier" that causes all threads to wait for other threads to catch up to a certain point before proceeding.
final CountDownLatch countdown = new CountDownLatch(num_thread);
for (int i = 0; i < num_thread; ++ i) {
Thread t= new Thread() {
public void run() {
doSomething();
countdown.countDown();
System.out.printf("Waiting on %d other threads.",countdown.getCount());
countdown.await(); //waits until everyone reaches this point
finish();
}
};
t.start();
}
That all said, the CountDownLatch
can safely be used in the manner you've shown in your example.
Solution 2
CountDownLatch is used to start a series of threads and then wait until all of them are complete (or until they call countDown()
a given number of times.
Semaphore is used to control the number of concurrent threads that are using a resource. That resource can be something like a file, or could be the cpu by limiting the number of threads executing. The count on a Semaphore can go up and down as different threads call acquire()
and release()
.
In your example, you're essentially using Semaphore as a sort of CountUPLatch. Given that your intent is to wait on all threads finishing, using the CountdownLatch
makes your intention clearer.
Solution 3
Short summary:
-
Semaphore
andCountDownLatch
serves different purpose. -
Use
Semaphore
to control thread access to resource. -
Use
CountDownLatch
to wait for completion of all threads
Semaphore
definition from Javadocs:
A
Semaphore
maintains a set of permits. Eachacquire()
blocks if necessary until a permit is available, and then takes it. Eachrelease()
adds a permit, potentially releasing a blocking acquirer.
However, no actual permit objects are used; the Semaphore
just keeps a count of the number available and acts accordingly.
How does it work?
Semaphores are used to control the number of concurrent threads that are using a resource.That resource can be something like a shared data, or a block of code (critical section) or any file.
The count on a Semaphore
can go up and down as different threads call acquire()
and release()
. But at any point of time, you can't have more number of threads greater than Semaphore count.
Semaphore
Use cases:
- Limiting concurrent access to disk (as performance degrades due to competing disk seeks)
- Thread creation limiting
- JDBC connection pooling / limiting
- Network connection throttling
- Throttling CPU or memory intensive tasks
Have a look at this article for semaphore uses.
CountDownLatch
definition from Javadocs:
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
How does it work?
CountDownLatch
works by having a counter initialized with number of threads, which is decremented each time a thread complete its execution. When count reaches to zero, it means all threads have completed their execution, and thread waiting on latch resume the execution.
CountDownLatch
Use cases:
- Achieving Maximum Parallelism: Sometimes we want to start a number of threads at the same time to achieve maximum parallelism
- Wait N threads to completes before start execution
- Deadlock detection.
Have a look at this article to understand CountDownLatch
concepts clearly.
Have a look at Fork Join Pool at this article too. It has some similarities to CountDownLatch
.
Solution 4
Say you walked in to golf pro shop, hoping to find a foursome,
When you stand in line to get a tee time from one of the pro shop attendants, essentially you called proshopVendorSemaphore.acquire()
, once you get a tee time, you called proshopVendorSemaphore.release()
.Note: any of the free attendants can service you, i.e. shared resource.
Now you walk up to starter, he starts a CountDownLatch(4)
and calls await()
to wait for others, for your part you called checked-in i.e. CountDownLatch
.countDown()
and so does rest of the foursome. When all arrive, starter gives go ahead(await()
call returns)
Now, after nine holes when each of you take a break, hypothetically lets involve starter again, he uses a 'new' CountDownLatch(4)
to tee off Hole 10, same wait/sync as Hole 1.
However, if the starter used a CyclicBarrier
to begin with, he could have reset the same instance in Hole 10 instead of a second latch, which use & throw.
Solution 5
Looking at the freely available source, there is no magic in the implementation of the two classes, so their performance should be much the same. Choose the one that makes your intent more obvious.
Related videos on Youtube
Saurabh
Updated on August 17, 2021Comments
-
Saurabh over 2 years
Is there any advantage of using
java.util.concurrent.CountdownLatch
instead of
java.util.concurrent.Semaphore?
As far as I can tell the following fragments are almost equivalent:
1. Semaphore
final Semaphore sem = new Semaphore(0); for (int i = 0; i < num_threads; ++ i) { Thread t = new Thread() { public void run() { try { doStuff(); } finally { sem.release(); } } }; t.start(); } sem.acquire(num_threads);
2: CountDownLatch
final CountDownLatch latch = new CountDownLatch(num_threads); for (int i = 0; i < num_threads; ++ i) { Thread t = new Thread() { public void run() { try { doStuff(); } finally { latch.countDown(); } } }; t.start(); } latch.await();
Except that in case #2 the latch cannot be reused and more importantly you need to know in advance how many threads will be created (or wait until they are all started before creating the latch.)
So in what situation might the latch be preferable?
-
Saurabh over 15 yearsThanks. So my two examples would not be equivalent if multiple threads could wait on the latch... unless sem.acquire(num_threads); is followed by sem.release(num_threads);? I think that would make them equivalent again.
-
James Schek over 15 yearsIn a sense, yes, as long as every thread called acquire followed by release. Strictly speaking, no. With a latch, all threads are eligible to start simultaneously. With the semaphore, they become eligible one after another (which could result in different thread scheduling).
-
Chris Morris about 11 yearsThe Java documentation seems to imply this a CountdownLatch fits well with his example: docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/…. Specifically, "A CountDownLatch initialized to N can be used to make one thread wait until N threads have completed some action, or some action has been completed N times."
-
James Schek about 11 yearsYou are right. I will update my answer a bit to reflect that this is these are the most common uses of CountDownLatch that I've seen vs that it is the intended use.
-
Marco Lackovic about 11 yearsThis answers the question What's the most frequently use of the CountDownLatch? It does not answer to the original question regarding the advantages/differences of using a CountDownLatch over a Semaphore.
-
Saurabh almost 11 yearsI'm not sure I understand your answer, but if you are attempting to describe how CountdownLatch and Semaphore work, that is not the subject of the question.
-
ring bearer almost 9 yearsUnfortunately I know nothing about golf.
-
Lassi Kinnunen about 8 yearsbut the starter stuff could be just as well be done with .acquire(players) and increasing the relesed count with release. the countdownlatch seems to just have less functionality and no reusability.
-
Lassi Kinnunen about 8 yearsthe answer would be better if it provided any advantage to not using semaphore to do the same thing.
-
wlnirvana almost 3 yearsNot only can
CountDownLatch
be "safely used" in the OP's manner, but it is actually one of the intended usage scenarios ofCountDownLatch
whereSemaphore
does not fit well, at least semantically. Conceptually,Semaphore
is for concurrent access to a shared resource, whileCountDownLatch
is for waiting for some task(s) to complete before lifting the latch is to let other threads out/run.