comments added

redisson/src/main/java/org/redisson/api/RBlockingQueueAsync.java

@@ -43,16 +43,93 @@ public interface RBlockingQueueAsync<V> extends RQueueAsync<V> {
      */
     Future<V> 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<Integer> drainToAsync(Collection<? super V> 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<Integer> drainToAsync(Collection<? super V> c);
 
     Future<V> 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<V> 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<V> 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<Void> putAsync(V e);
 
 }

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<V> extends RBlockingQueue<V>, RBoundedBlockingQueueAsync<V> {
 
-    Future<Boolean> trySetCapacityAsync(int capacity);
-    
+    /**
+     * Sets queue capacity only if it is not set before.
+     *
+     * @param capacity - queue capacity
+     * @return <code>true</code> if capacity set successfully
+     *         <code>false</code> if capacity already set
+     */
     boolean trySetCapacity(int capacity);
     
 }

redisson/src/main/java/org/redisson/api/RBoundedBlockingQueueAsync.java

@@ -28,6 +28,31 @@ import io.netty.util.concurrent.Future;
  */
 public interface RBoundedBlockingQueueAsync<V> extends RBlockingQueueAsync<V> {
 
+    /**
+     * Sets queue capacity only if it is not set before.
+     *
+     * @param capacity - queue capacity
+     * @return <code>true</code> if capacity set successfully
+     *         <code>false</code> if capacity already set
+     */
+    Future<Boolean> 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<Boolean> offerAsync(V e, long timeout, TimeUnit unit);
 
 }