Interface ICountDownLatch
- All Superinterfaces:
DistributedObject
java.util.concurrent.CountDownLatch
.
ICountDownLatch is a cluster-wide synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
There are a few differences compared to the
java.util.concurrent.CountDownLatch
:
-
ICountDownLatch count can be reset using
trySetCount(int)
after a countdown has finished but not during an active count. This allows the same latch instance to be reused. - There is no await() method to do an unbound wait since this is undesirable in a distributed application: for example, a cluster can split or the master and replicas could all die. In most cases, it is best to configure an explicit timeout so you have the ability to deal with these situations.
ICountDownLatch
is accessed via
CPSubsystem.getCountDownLatch(String)
. It works on top of the Raft
consensus algorithm. It offers linearizability during crash failures and network
partitions. It is CP with respect to the CAP principle. If a network
partition occurs, it remains available on at most one side of the partition.
All of the API methods in the new CP ICountDownLatch
impl offer
the exactly-once execution semantics. For instance, even if
a countDown()
call is internally retried because of crashed
Hazelcast member, the counter value is decremented only once.
-
Method Summary
Modifier and TypeMethodDescriptionboolean
Causes the current thread to wait until the latch has counted down to zero, or an exception is thrown, or the specified waiting time elapses.void
Decrements the count of the latch, releasing all waiting threads if the count reaches zero.int
getCount()
Returns the current count.boolean
trySetCount
(int count) Sets the count to the given value if the current count is zero.Methods inherited from interface com.hazelcast.core.DistributedObject
destroy, getDestroyContextForTenant, getName, getPartitionKey, getServiceName
-
Method Details
-
await
Causes the current thread to wait until the latch has counted down to zero, or an exception is thrown, or the specified waiting time elapses.If the current count is zero then this method returns immediately with the value
true
.If the current count is greater than zero, then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of five things happen:
- the count reaches zero due to invocations of the
countDown()
method, - this ICountDownLatch instance is destroyed,
- the countdown owner becomes disconnected,
- some other thread interrupts the current thread, or
- the specified waiting time elapses.
true
.If the current thread:
- has its interrupted status set on entry to this method, or
- is interrupted while waiting,
InterruptedException
is thrown and the current thread's interrupted status is cleared.If the specified waiting time elapses then the value
false
is returned. If the time is less than or equal to zero, the method will not wait at all.- Parameters:
timeout
- the maximum time to waitunit
- the time unit of thetimeout
argument- Returns:
true
if the count reached zero,false
if the waiting time elapsed before the count reached zero- Throws:
InterruptedException
- if the current thread is interruptedIllegalStateException
- if the Hazelcast instance is shutdown while waitingNullPointerException
- if unit is null
- the count reaches zero due to invocations of the
-
countDown
void countDown()Decrements the count of the latch, releasing all waiting threads if the count reaches zero.If the current count is greater than zero, then it is decremented. If the new count is zero:
- All waiting threads are re-enabled for thread scheduling purposes, and
- Countdown owner is set to
null
.
-
getCount
int getCount()Returns the current count.- Returns:
- the current count
-
trySetCount
boolean trySetCount(int count) Sets the count to the given value if the current count is zero.If count is not zero, then this method does nothing and returns
false
.- Parameters:
count
- the number of timescountDown()
must be invoked before threads can pass throughawait(long, java.util.concurrent.TimeUnit)
- Returns:
true
if the new count was set,false
if the current count is not zero- Throws:
IllegalArgumentException
- ifcount
is negative or zero
-