[jira] [Created] (CURATOR-459) Support for asynchronous locks in Curator Async

["Peter Rietzler (JIRA)" <ji...@apache.org>]

Peter Rietzler created CURATOR-459:
--------------------------------------

             Summary: Support for asynchronous locks in Curator Async
                 Key: CURATOR-459
                 URL: https://issues.apache.org/jira/browse/CURATOR-459
             Project: Apache Curator
          Issue Type: Wish
          Components: Recipes
            Reporter: Peter Rietzler


It would be great to have a support for asynchronous locks. Here's an interface suggestion
{code:java}
/**
 * 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();
 }
}{code}
 



--
This message was sent by Atlassian JIRA
(v7.6.3#76005)