From 4c95155ab17006eb752c20961c2ac3f22a9c78e6 Mon Sep 17 00:00:00 2001 From: Nikita Date: Wed, 10 Aug 2016 12:04:12 +0300 Subject: [PATCH] comments added --- .../org/redisson/api/RBlockingQueueAsync.java | 77 +++++++++++++++++++ .../redisson/api/RBoundedBlockingQueue.java | 11 ++- .../api/RBoundedBlockingQueueAsync.java | 25 ++++++ 3 files changed, 109 insertions(+), 4 deletions(-) diff --git a/redisson/src/main/java/org/redisson/api/RBlockingQueueAsync.java b/redisson/src/main/java/org/redisson/api/RBlockingQueueAsync.java index 2159f3172..dbe0a027b 100644 --- a/redisson/src/main/java/org/redisson/api/RBlockingQueueAsync.java +++ b/redisson/src/main/java/org/redisson/api/RBlockingQueueAsync.java @@ -43,16 +43,93 @@ public interface RBlockingQueueAsync extends RQueueAsync { */ Future pollFromAnyAsync(long timeout, TimeUnit unit, String ... queueNames); + /** + * Removes at most the given number of available elements from + * this queue and adds them to the given collection in async mode. A failure + * encountered while attempting to add elements to + * collection {@code c} may result in elements being in neither, + * either or both collections when the associated exception is + * thrown. Attempts to drain a queue to itself result in + * {@code IllegalArgumentException}. Further, the behavior of + * this operation is undefined if the specified collection is + * modified while the operation is in progress. + * + * @param c the collection to transfer elements into + * @param maxElements the maximum number of elements to transfer + * @return the number of elements transferred + * @throws UnsupportedOperationException if addition of elements + * is not supported by the specified collection + * @throws ClassCastException if the class of an element of this queue + * prevents it from being added to the specified collection + * @throws NullPointerException if the specified collection is null + * @throws IllegalArgumentException if the specified collection is this + * queue, or some property of an element of this queue prevents + * it from being added to the specified collection + */ Future drainToAsync(Collection c, int maxElements); + /** + * Removes all available elements from this queue and adds them + * to the given collection in async mode. This operation may be more + * efficient than repeatedly polling this queue. A failure + * encountered while attempting to add elements to + * collection {@code c} may result in elements being in neither, + * either or both collections when the associated exception is + * thrown. Attempts to drain a queue to itself result in + * {@code IllegalArgumentException}. Further, the behavior of + * this operation is undefined if the specified collection is + * modified while the operation is in progress. + * + * @param c the collection to transfer elements into + * @return the number of elements transferred + * @throws UnsupportedOperationException if addition of elements + * is not supported by the specified collection + * @throws ClassCastException if the class of an element of this queue + * prevents it from being added to the specified collection + * @throws NullPointerException if the specified collection is null + * @throws IllegalArgumentException if the specified collection is this + * queue, or some property of an element of this queue prevents + * it from being added to the specified collection + */ Future drainToAsync(Collection c); Future pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit); + /** + * Retrieves and removes the head of this queue in async mode, waiting up to the + * specified wait time if necessary for an element to become available. + * + * @param timeout how long to wait before giving up, in units of + * {@code unit} + * @param unit a {@code TimeUnit} determining how to interpret the + * {@code timeout} parameter + * @return the head of this queue, or {@code null} if the + * specified waiting time elapses before an element is available + * @throws InterruptedException if interrupted while waiting + */ Future pollAsync(long timeout, TimeUnit unit); + /** + * Retrieves and removes the head of this queue in async mode, waiting if necessary + * until an element becomes available. + * + * @return the head of this queue + * @throws InterruptedException if interrupted while waiting + */ Future takeAsync(); + /** + * Inserts the specified element into this queue in async mode, waiting if necessary + * for space to become available. + * + * @param e the element to add + * @throws InterruptedException if interrupted while waiting + * @throws ClassCastException if the class of the specified element + * prevents it from being added to this queue + * @throws NullPointerException if the specified element is null + * @throws IllegalArgumentException if some property of the specified + * element prevents it from being added to this queue + */ Future putAsync(V e); } diff --git a/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueue.java b/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueue.java index 8128c9993..3b21c4e2c 100644 --- a/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueue.java +++ b/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueue.java @@ -17,8 +17,6 @@ package org.redisson.api; import java.util.concurrent.BlockingQueue; -import io.netty.util.concurrent.Future; - /** * Bounded {@link BlockingQueue} backed by Redis * @@ -27,8 +25,13 @@ import io.netty.util.concurrent.Future; */ public interface RBoundedBlockingQueue extends RBlockingQueue, RBoundedBlockingQueueAsync { - Future trySetCapacityAsync(int capacity); - + /** + * Sets queue capacity only if it is not set before. + * + * @param capacity - queue capacity + * @return true if capacity set successfully + * false if capacity already set + */ boolean trySetCapacity(int capacity); } diff --git a/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueueAsync.java b/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueueAsync.java index 0667e3586..2436dd2af 100644 --- a/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueueAsync.java +++ b/redisson/src/main/java/org/redisson/api/RBoundedBlockingQueueAsync.java @@ -28,6 +28,31 @@ import io.netty.util.concurrent.Future; */ public interface RBoundedBlockingQueueAsync extends RBlockingQueueAsync { + /** + * Sets queue capacity only if it is not set before. + * + * @param capacity - queue capacity + * @return true if capacity set successfully + * false if capacity already set + */ + Future trySetCapacityAsync(int capacity); + + /** + * Inserts the specified element into this queue, waiting up to the + * specified wait time if necessary for space to become available. + * + * @param e the element to add + * @param timeout how long to wait before giving up, in units of + * {@code unit} + * @param unit a {@code TimeUnit} determining how to interpret the + * {@code timeout} parameter + * @return {@code true} if successful, or {@code false} if + * the specified waiting time elapses before space is available + * @throws InterruptedException if interrupted while waiting + * @throws ClassCastException if the class of the specified element + * prevents it from being added to this queue + * @throws NullPointerException if the specified element is null + */ Future offerAsync(V e, long timeout, TimeUnit unit); }