org.docx4j.com.google.common.collect

Class Queues

java.lang.Object

org.docx4j.com.google.common.collect.Queues

@GwtCompatible(emulated=true)
public final class Queues
extends java.lang.Object

Static utility methods pertaining to Queue and Deque instances. Also see this class's counterparts Lists, Sets, and Maps.

Since:

11.0

Author:

Kurt Alfred Kluever

Method Summary

Modifier and Type	Method and Description
static <E> int	drain(java.util.concurrent.BlockingQueue<E> q, java.util.Collection<? super E> buffer, int numElements, long timeout, java.util.concurrent.TimeUnit unit) Drains the queue as BlockingQueue.drainTo(Collection, int), but if the requested numElements elements are not available, it will wait for them up to the specified timeout.
static <E> int	drainUninterruptibly(java.util.concurrent.BlockingQueue<E> q, java.util.Collection<? super E> buffer, int numElements, long timeout, java.util.concurrent.TimeUnit unit) Drains the queue as drain(BlockingQueue, Collection, int, long, TimeUnit), but with a different behavior in case it is interrupted while waiting.
static <E> java.util.concurrent.ArrayBlockingQueue<E>	newArrayBlockingQueue(int capacity) Creates an empty ArrayBlockingQueue with the given (fixed) capacity and nonfair access policy.
static <E> java.util.ArrayDeque<E>	newArrayDeque() Creates an empty ArrayDeque.
static <E> java.util.concurrent.ConcurrentLinkedQueue<E>	newConcurrentLinkedQueue() Creates an empty ConcurrentLinkedQueue.
static <E> java.util.concurrent.LinkedBlockingDeque<E>	newLinkedBlockingDeque() Creates an empty LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.
static <E> java.util.concurrent.LinkedBlockingDeque<E>	newLinkedBlockingDeque(int capacity) Creates an empty LinkedBlockingDeque with the given (fixed) capacity.
static <E> java.util.concurrent.LinkedBlockingQueue<E>	newLinkedBlockingQueue() Creates an empty LinkedBlockingQueue with a capacity of Integer.MAX_VALUE.
static <E> java.util.concurrent.LinkedBlockingQueue<E>	newLinkedBlockingQueue(int capacity) Creates an empty LinkedBlockingQueue with the given (fixed) capacity.
static <E extends java.lang.Comparable> java.util.concurrent.PriorityBlockingQueue<E>	newPriorityBlockingQueue() Creates an empty PriorityBlockingQueue with the ordering given by its elements' natural ordering.
static <E extends java.lang.Comparable> java.util.PriorityQueue<E>	newPriorityQueue() Creates an empty PriorityQueue with the ordering given by its elements' natural ordering.
static <E> java.util.concurrent.SynchronousQueue<E>	newSynchronousQueue() Creates an empty SynchronousQueue with nonfair access policy.
static <E> java.util.Deque<E>	synchronizedDeque(java.util.Deque<E> deque) Returns a synchronized (thread-safe) deque backed by the specified deque.
static <E> java.util.Queue<E>	synchronizedQueue(java.util.Queue<E> queue) Returns a synchronized (thread-safe) queue backed by the specified queue.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

newArrayBlockingQueue

@GwtIncompatible
public static <E> java.util.concurrent.ArrayBlockingQueue<E> newArrayBlockingQueue(int capacity)

Creates an empty ArrayBlockingQueue with the given (fixed) capacity and nonfair access policy.

newArrayDeque

public static <E> java.util.ArrayDeque<E> newArrayDeque()

Creates an empty ArrayDeque.

Since:

12.0

newConcurrentLinkedQueue

@GwtIncompatible
public static <E> java.util.concurrent.ConcurrentLinkedQueue<E> newConcurrentLinkedQueue()

Creates an empty ConcurrentLinkedQueue.

newLinkedBlockingDeque

@GwtIncompatible
public static <E> java.util.concurrent.LinkedBlockingDeque<E> newLinkedBlockingDeque()

Creates an empty LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.

Since:

12.0

newLinkedBlockingDeque

@GwtIncompatible
public static <E> java.util.concurrent.LinkedBlockingDeque<E> newLinkedBlockingDeque(int capacity)

Creates an empty LinkedBlockingDeque with the given (fixed) capacity.

Throws:

java.lang.IllegalArgumentException - if capacity is less than 1

Since:

12.0

newLinkedBlockingQueue

@GwtIncompatible
public static <E> java.util.concurrent.LinkedBlockingQueue<E> newLinkedBlockingQueue()

Creates an empty LinkedBlockingQueue with a capacity of Integer.MAX_VALUE.

newLinkedBlockingQueue

@GwtIncompatible
public static <E> java.util.concurrent.LinkedBlockingQueue<E> newLinkedBlockingQueue(int capacity)

Creates an empty LinkedBlockingQueue with the given (fixed) capacity.

Throws:

java.lang.IllegalArgumentException - if capacity is less than 1

newPriorityBlockingQueue

@GwtIncompatible
public static <E extends java.lang.Comparable> java.util.concurrent.PriorityBlockingQueue<E> newPriorityBlockingQueue()

Creates an empty PriorityBlockingQueue with the ordering given by its elements' natural ordering.

Since:

11.0 (requires that E be Comparable since 15.0).

newPriorityQueue

public static <E extends java.lang.Comparable> java.util.PriorityQueue<E> newPriorityQueue()

Creates an empty PriorityQueue with the ordering given by its elements' natural ordering.

Since:

11.0 (requires that E be Comparable since 15.0).

newSynchronousQueue

@GwtIncompatible
public static <E> java.util.concurrent.SynchronousQueue<E> newSynchronousQueue()

Creates an empty SynchronousQueue with nonfair access policy.

drain

@Beta
 @CanIgnoreReturnValue
 @GwtIncompatible
public static <E> int drain(java.util.concurrent.BlockingQueue<E> q,
                                                                           java.util.Collection<? super E> buffer,
                                                                           int numElements,
                                                                           long timeout,
                                                                           java.util.concurrent.TimeUnit unit)
                                                                    throws java.lang.InterruptedException

Drains the queue as BlockingQueue.drainTo(Collection, int), but if the requested numElements elements are not available, it will wait for them up to the specified timeout.

Parameters:

q - the blocking queue to be drained

buffer - where to add the transferred elements

numElements - the number of elements to be waited for

timeout - how long to wait before giving up, in units of unit

unit - a TimeUnit determining how to interpret the timeout parameter

Returns:

the number of elements transferred

Throws:

java.lang.InterruptedException - if interrupted while waiting

drainUninterruptibly

@Beta
 @CanIgnoreReturnValue
 @GwtIncompatible
public static <E> int drainUninterruptibly(java.util.concurrent.BlockingQueue<E> q,
                                                                                          java.util.Collection<? super E> buffer,
                                                                                          int numElements,
                                                                                          long timeout,
                                                                                          java.util.concurrent.TimeUnit unit)

Drains the queue as drain(BlockingQueue, Collection, int, long, TimeUnit), but with a different behavior in case it is interrupted while waiting. In that case, the operation will continue as usual, and in the end the thread's interruption status will be set (no InterruptedException is thrown).

Parameters:

q - the blocking queue to be drained

buffer - where to add the transferred elements

numElements - the number of elements to be waited for

timeout - how long to wait before giving up, in units of unit

unit - a TimeUnit determining how to interpret the timeout parameter

Returns:

the number of elements transferred

synchronizedQueue

public static <E> java.util.Queue<E> synchronizedQueue(java.util.Queue<E> queue)

Returns a synchronized (thread-safe) queue backed by the specified queue. In order to guarantee serial access, it is critical that all access to the backing queue is accomplished through the returned queue.

It is imperative that the user manually synchronize on the returned queue when accessing the queue's iterator:

 Queue<E> queue = Queues.synchronizedQueue(MinMaxPriorityQueue.<E>create());
 ...
 queue.add(element);  // Needn't be in synchronized block
 ...
 synchronized (queue) {  // Must synchronize on queue!
   Iterator<E> i = queue.iterator(); // Must be in synchronized block
   while (i.hasNext()) {
     foo(i.next());
   }
 }
 

Failure to follow this advice may result in non-deterministic behavior.

The returned queue will be serializable if the specified queue is serializable.

Parameters:

queue - the queue to be wrapped in a synchronized view

Returns:

a synchronized view of the specified queue

Since:

14.0

synchronizedDeque

public static <E> java.util.Deque<E> synchronizedDeque(java.util.Deque<E> deque)

Returns a synchronized (thread-safe) deque backed by the specified deque. In order to guarantee serial access, it is critical that all access to the backing deque is accomplished through the returned deque.

It is imperative that the user manually synchronize on the returned deque when accessing any of the deque's iterators:

 Deque<E> deque = Queues.synchronizedDeque(Queues.<E>newArrayDeque());
 ...
 deque.add(element);  // Needn't be in synchronized block
 ...
 synchronized (deque) {  // Must synchronize on deque!
   Iterator<E> i = deque.iterator(); // Must be in synchronized block
   while (i.hasNext()) {
     foo(i.next());
   }
 }
 

Failure to follow this advice may result in non-deterministic behavior.

The returned deque will be serializable if the specified deque is serializable.

Parameters:

deque - the deque to be wrapped in a synchronized view

Returns:

a synchronized view of the specified deque

Since:

15.0