Re: Multi-threading: wait for tasks to complete
markspace wrote:
Hi all.
I was toying around with some multithreading code today. I ran into a
stick problem: how to wait for an unknown number of tasks to complete.
There seem to be a lot of Java classes that wait for a specific number
of threads or tasks: Semaphore and CountDownLatch, for example. But
there don't seem to be any that allow their value to be changed on the
fly to account for new tasks being created.
Maybe I missed an existing class?
I'm not aware of an existing class with exactly that functionality.
Which is not necessarily saying none exists. :)
Anyway, the solution I came up with was to roll my own latch, the
UpDownLatch. So named because it can count both up (for new tasks being
spawned) and down (for when the task completes).
Here's the code. Comments welcome. Obviously, it's currently a nested
class; that should be changed for general use.
While performance might not be an issue in all cases, I still would
probably have implemented your class with AtomicInteger, instead of
synchronized methods for countUp() and countDown(). Then you need only
synchronize when you actually need to notify. (The compare-and-set the
atomic classes implement aren't free of performance costs either, but
should generally perform better than a full lock).
Also, while I understand that due to the "synchronized" keyword, it's
fairly common in Java to use "this" as the monitored object, it's my
preference to have a private object used for synchronization, to ensure
no conflicts with other code that may be (usually inappropriately) using
the same "this" reference for synchronization.
So, my implementation might look something more like this:
class UpDownLatch
{
private AtomicInteger count = new AtomicInteger();
private Object objLock = new Object();
public void countUp()
{
count.incrementAndGet();
}
public void countDown()
{
if (count.decrementAndGet() > 0)
{
return;
}
// Might want to save the above return value
// and throw an exception if "count" is less
// than 0.
synchronized(objLock)
{
objLock.notify();
}
}
public void await() throws InterruptedException
{
synchronized(objLock)
{
while (count > 0)
{
objLock.wait();
}
}
}
}
You may or may not agree that there's value in the differences. :)