[CURATOR-459] Support for asynchronous locks in Curator Async

• Type: Wish
• Status: Open
• Priority: Minor
• Resolution: Unresolved
• Component/s: Recipes
• Assignee: Unassigned
• Reporter: Peter Rietzler
• Created: 20/Mar/18 06:41
• Updated: 20/Mar/18 14:06

Description

It would be great to have a support for asynchronous locks. Here's an interface suggestion

/**
 * A non-reentrant Lock with the ability to react when the lock is acquired async, so that the thread which
 * acquires the lock is not blocked.
 */
public interface CompletableLock {

 /**
 * Acquire the lock non-blocking. The resulting {@link CompletableFuture} can then be used to block
 * until the lock is actually acquired. The {@link CompletableFuture#cancel(boolean)} can be used
 * to abort the acquisition of the lock. As soon as the lock is actually acquired, this method has no
 * effect. The Lock itself is then released with {@link Lease#unlock()}.
 * <p>
 * Several calls results in several independent locking requests. So it is equivalent to
 * call this method multiple times or get a new lock and then call the method once.
 *
 * @return an instance of {@link CompletableFuture} which represents the actual lock.
 */
 CompletableFuture<Lease> lock();

 default void withLock(Runnable body) {
 lock().thenAccept(lock -> {
 try {
 body.run();
 } finally {
 lock.unlock();
 }
 });
 }

 /**
 * Same as {@link #lock()} but if the lock can't be acquired within the given amount of time,
 * the {@link CompletableFuture} throws a {@link java.util.concurrent.ExecutionException} with a nested
 * {@link java.util.concurrent.TimeoutException} when it is accessed the next time.
 *
 * @param time the maximum waiting time for acquiring the lock.
 * @param unit the {@link TimeUnit} for the given time.
 * @return an instance of {@link CompletableFuture} which represents the actual lock.
 */
 CompletableFuture<Lease> lock(int time, TimeUnit unit);

 /**
 * Gets the lock only if possible. If lock is currently acquired, this returns immediately with an undefined option.
 */
 Optional<Lease> tryLock();

 /**
 * Gets the lock only if possible. If lock is currently acquired, this returns an undefined option after the
 * given timeout.
 */
 Lease tryLock(int time, TimeUnit unit);

 /**
 * For unlocking a successfully acquired lock.
 */
 interface Lease {

 /**
 * Releases the lock.
 */
 void unlock();
 }
}