github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

javadocs updated

Browse Source
pull/2452/merge
Nikita Koksharov 5 years ago
parent 9c285ea309
commit 146297c2c1
4 changed files with 42 additions and 194 deletions
Show Stats Download Patch File Download Diff File

86
redisson/src/main/java/org/redisson/api/RCountDownLatch.java
Unescape Escape View File

@ -18,7 +18,7 @@ package org.redisson.api;
import java.util.concurrent.TimeUnit;
/**
* Distributed implementation of {@link java.util.concurrent.CountDownLatch}
* Redis based implementation of {@link java.util.concurrent.CountDownLatch}
*
* It has an advantage over {@link java.util.concurrent.CountDownLatch} --
* count can be set via {@link #trySetCount} method.
@ -29,95 +29,33 @@ import java.util.concurrent.TimeUnit;
public interface RCountDownLatch extends RObject, RCountDownLatchAsync {
/**
* Causes the current thread to wait until the latch has counted down to
* zero, unless the thread is {@linkplain Thread#interrupt interrupted}.
* Waits until counter reach zero.
*
* <p>If the current count is zero then this method returns immediately.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until one of two things happen:
* <ul>
* <li>The count reaches zero due to invocations of the
* {@link #countDown} method; or
* <li>Some other thread {@linkplain Thread#interrupt interrupts}
* the current thread.
* </ul>
*
* <p>If the current thread:
* <ul>
* <li>has its interrupted status set on entry to this method; or
* <li>is {@linkplain Thread#interrupt interrupted} while waiting,
* </ul>
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.
*
* @throws InterruptedException if the current thread is interrupted
* while waiting
* @throws InterruptedException if the current thread was interrupted
*/
void await() throws InterruptedException;
/**
* Causes the current thread to wait until the latch has counted down to
* zero, unless the thread is {@linkplain Thread#interrupt interrupted},
* or the specified waiting time elapses.
*
* <p>If the current count is zero then this method returns immediately
* with the value {@code true}.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until one of three things happen:
* <ul>
* <li>The count reaches zero due to invocations of the
* {@link #countDown} method; or
* <li>Some other thread {@linkplain Thread#interrupt interrupts}
* the current thread; or
* <li>The specified waiting time elapses.
* </ul>
*
* <p>If the count reaches zero then the method returns with the
* value {@code true}.
*
* <p>If the current thread:
* <ul>
* <li>has its interrupted status set on entry to this method; or
* <li>is {@linkplain Thread#interrupt interrupted} while waiting,
* </ul>
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.
*
* <p>If the specified waiting time elapses then the value {@code false}
* is returned. If the time is less than or equal to zero, the method
* will not wait at all.
* Waits until counter reach zero or up to defined <code>timeout</code>.
*
* @param timeout the maximum time to wait
* @param unit the time unit of the {@code timeout} argument
* @return {@code true} if the count reached zero and {@code false}
* if the waiting time elapsed before the count reached zero
* @throws InterruptedException if the current thread is interrupted
* while waiting
* @param unit the time unit
* @return <code>true</code> if the count reached zero and <code>false</code>
* if timeout reached before the count reached zero
* @throws InterruptedException if the current thread was interrupted
*/
boolean await(long timeout, TimeUnit unit) throws InterruptedException;
/**
* Decrements the count of the latch, releasing all waiting threads if
* the count reaches zero.
*
* <p>If the current count is greater than zero then it is decremented.
* If the new count is zero then all waiting threads are re-enabled for
* thread scheduling purposes.
*
* <p>If the current count equals zero then nothing happens.
* Decrements the counter of the latch.
* Notifies all waiting threads when count reaches zero.
*/
void countDown();
/**
* Returns the current count.
*
* <p>This method is typically used for debugging and testing purposes.
* Returns value of current count.
*
* @return the current count
* @return current count
*/
long getCount();

50
redisson/src/main/java/org/redisson/api/RCountDownLatchAsync.java
Unescape Escape View File

@ -18,7 +18,7 @@ package org.redisson.api;
import java.util.concurrent.TimeUnit;
/**
* Async interface of {@link java.util.concurrent.CountDownLatch}
* Async interface of Redis based {@link java.util.concurrent.CountDownLatch}
*
* It has an advantage over {@link java.util.concurrent.CountDownLatch} --
* count can be set via {@link #trySetCountAsync} method.
@ -29,63 +29,33 @@ import java.util.concurrent.TimeUnit;
public interface RCountDownLatchAsync extends RObjectAsync {
/**
* Causes the current thread to wait until the latch has counted down to
* zero.
* Waits until counter reach zero.
*
* <p>If the current count is zero then this method returns immediately.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until the count reaches zero due to invocations of the
* {@link #countDownAsync} method.
* @return void
*
*/
RFuture<Void> awaitAsync();
/**
* Causes the current thread to wait until the latch has counted down to
* zero or the specified waiting time elapses.
*
* <p>If the current count is zero then this method returns immediately
* with the value {@code true}.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until the count reaches zero due to invocations of the
* {@link #countDownAsync()} method or the specified waiting time elapses.
*
* <p>If the count reaches zero then the method returns with the
* value {@code true}.
*
* <p>If the specified waiting time elapses then the value {@code false}
* is returned. If the time is less than or equal to zero, the method
* will not wait at all.
* Waits until counter reach zero or up to defined <code>timeout</code>.
*
* @param waitTime the maximum time to wait
* @param unit the time unit of the {@code timeout} argument
* @return {@code true} if the count reached zero and {@code false}
* if the waiting time elapsed before the count reached zero
* @param unit the time unit
* @return <code>true</code> if the count reached zero and <code>false</code>
* if timeout reached before the count reached zero
*/
RFuture<Boolean> awaitAsync(long waitTime, TimeUnit unit);
/**
* Decrements the count of the latch, releasing all waiting threads if
* the count reaches zero.
*
* <p>If the current count is greater than zero then it is decremented.
* If the new count is zero then all waiting threads are re-enabled for
* thread scheduling purposes.
*
* <p>If the current count equals zero then nothing happens.
* Decrements the counter of the latch.
* Notifies all waiting threads when count reaches zero.
*
* @return void
*/
RFuture<Void> countDownAsync();
/**
* Returns the current count.
*
* <p>This method is typically used for debugging and testing purposes.
* Returns value of current count.
*
* @return the current count
*/

50
redisson/src/main/java/org/redisson/api/RCountDownLatchReactive.java
Unescape Escape View File

@ -20,7 +20,7 @@ import reactor.core.publisher.Mono;
import java.util.concurrent.TimeUnit;
/**
* Reactive interface of {@link java.util.concurrent.CountDownLatch}
* Reactive interface of Redis based {@link java.util.concurrent.CountDownLatch}
*
* It has an advantage over {@link java.util.concurrent.CountDownLatch} --
* count can be set via {@link #trySetCount} method.
@ -31,63 +31,33 @@ import java.util.concurrent.TimeUnit;
public interface RCountDownLatchReactive extends RObjectRx {
/**
* Causes the current thread to wait until the latch has counted down to
* zero.
* Waits until counter reach zero.
*
* <p>If the current count is zero then this method returns immediately.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until the count reaches zero due to invocations of the
* {@link #countDown} method.
* @return void
*
*/
Mono<Void> await();
/**
* Causes the current thread to wait until the latch has counted down to
* zero or the specified waiting time elapses.
*
* <p>If the current count is zero then this method returns immediately
* with the value {@code true}.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until the count reaches zero due to invocations of the
* {@link #countDown()} method or the specified waiting time elapses.
*
* <p>If the count reaches zero then the method returns with the
* value {@code true}.
*
* <p>If the specified waiting time elapses then the value {@code false}
* is returned. If the time is less than or equal to zero, the method
* will not wait at all.
* Waits until counter reach zero or up to defined <code>timeout</code>.
*
* @param waitTime the maximum time to wait
* @param unit the time unit of the {@code timeout} argument
* @return {@code true} if the count reached zero and {@code false}
* if the waiting time elapsed before the count reached zero
* @param unit the time unit
* @return <code>true</code> if the count reached zero and <code>false</code>
* if timeout reached before the count reached zero
*/
Mono<Boolean> await(long waitTime, TimeUnit unit);
/**
* Decrements the count of the latch, releasing all waiting threads if
* the count reaches zero.
*
* <p>If the current count is greater than zero then it is decremented.
* If the new count is zero then all waiting threads are re-enabled for
* thread scheduling purposes.
*
* <p>If the current count equals zero then nothing happens.
* Decrements the counter of the latch.
* Notifies all waiting threads when count reaches zero.
*
* @return void
*/
Mono<Void> countDown();
/**
* Returns the current count.
*
* <p>This method is typically used for debugging and testing purposes.
* Returns value of current count.
*
* @return the current count
*/

50
redisson/src/main/java/org/redisson/api/RCountDownLatchRx.java
Unescape Escape View File

@ -21,7 +21,7 @@ import io.reactivex.Single;
import java.util.concurrent.TimeUnit;
/**
* RxJava2 interface of {@link java.util.concurrent.CountDownLatch}
* RxJava2 interface of Redis based {@link java.util.concurrent.CountDownLatch}
*
* It has an advantage over {@link java.util.concurrent.CountDownLatch} --
* count can be set via {@link #trySetCount} method.
@ -32,63 +32,33 @@ import java.util.concurrent.TimeUnit;
public interface RCountDownLatchRx extends RObjectRx {
/**
* Causes the current thread to wait until the latch has counted down to
* zero.
* Waits until counter reach zero.
*
* <p>If the current count is zero then this method returns immediately.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until the count reaches zero due to invocations of the
* {@link #countDown} method.
* @return void
*
*/
Completable await();
/**
* Causes the current thread to wait until the latch has counted down to
* zero or the specified waiting time elapses.
*
* <p>If the current count is zero then this method returns immediately
* with the value {@code true}.
*
* <p>If the current count is greater than zero then the current
* thread becomes disabled for thread scheduling purposes and lies
* dormant until the count reaches zero due to invocations of the
* {@link #countDown()} method or the specified waiting time elapses.
*
* <p>If the count reaches zero then the method returns with the
* value {@code true}.
*
* <p>If the specified waiting time elapses then the value {@code false}
* is returned. If the time is less than or equal to zero, the method
* will not wait at all.
* Waits until counter reach zero or up to defined <code>timeout</code>.
*
* @param waitTime the maximum time to wait
* @param unit the time unit of the {@code timeout} argument
* @return {@code true} if the count reached zero and {@code false}
* if the waiting time elapsed before the count reached zero
* @param unit the time unit
* @return <code>true</code> if the count reached zero and <code>false</code>
* if timeout reached before the count reached zero
*/
Single<Boolean> await(long waitTime, TimeUnit unit);
/**
* Decrements the count of the latch, releasing all waiting threads if
* the count reaches zero.
*
* <p>If the current count is greater than zero then it is decremented.
* If the new count is zero then all waiting threads are re-enabled for
* thread scheduling purposes.
*
* <p>If the current count equals zero then nothing happens.
* Decrements the counter of the latch.
* Notifies all waiting threads when count reaches zero.
*
* @return void
*/
Completable countDown();
/**
* Returns the current count.
*
* <p>This method is typically used for debugging and testing purposes.
* Returns value of current count.
*
* @return the current count
*/

Write Preview
Loading…
Cancel
Save