org.jgroups.util

## Class ConcurrentLinkedBlockingQueue<T>

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - java.util.AbstractQueue<E>
    - - java.util.concurrent.ConcurrentLinkedQueue<T>
      - - org.jgroups.util.ConcurrentLinkedBlockingQueue<T>

All Implemented Interfaces:
  java.io.Serializable, java.lang.Iterable<T>, java.util.Collection<T>, java.util.concurrent.BlockingQueue<T>, java.util.Queue<T>

    public class ConcurrentLinkedBlockingQueue<T>
    extends java.util.concurrent.ConcurrentLinkedQueue<T>
    implements java.util.concurrent.BlockingQueue<T>

Attempt at writing a fast transfer queue, which is bounded. The take() method blocks until there is an element, but the offer() method drops the element and returns if the queue is full (doesn't block). I thought this class would be useful in ThreadPoolExecutor, as a replacement for LinkedBlockingQueue, but the perf didn't change. I'll keep it for later reference ...

Author:
  Bela Ban
See Also:
  Serialized Form

### Constructor Summary

Constructors
Constructor and Description
`ConcurrentLinkedBlockingQueue(int capacity)`

### Method Summary

Methods
`int` `drainTo(java.util.Collection<? super T> c)`
`int` `drainTo(java.util.Collection<? super T> c, int maxElements)`
`boolean` `offer(T t)` Drops elements if capacity has been reached.
`boolean` `offer(T t, long timeout, java.util.concurrent.TimeUnit unit)`
`T` `poll()`
`T` `poll(long timeout, java.util.concurrent.TimeUnit unit)`
`void` `put(T t)`
`int` `remainingCapacity()`
`boolean` `remove(java.lang.Object o)`
`T` `take()`

### Methods inherited from class java.util.concurrent.ConcurrentLinkedQueue

`add, contains, isEmpty, iterator, peek, size, toArray, toArray`

### Methods inherited from class java.util.AbstractQueue

`addAll, clear, element, remove`

### Methods inherited from class java.util.AbstractCollection

`containsAll, removeAll, retainAll, toString`

### Methods inherited from class java.lang.Object

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

### Methods inherited from interface java.util.concurrent.BlockingQueue

`add, contains`

### Methods inherited from interface java.util.Queue

`element, peek, remove`

### Methods inherited from interface java.util.Collection

`addAll, clear, containsAll, equals, hashCode, isEmpty, iterator, removeAll, retainAll, size, toArray, toArray`

### Constructor Detail

#### ConcurrentLinkedBlockingQueue

    public ConcurrentLinkedBlockingQueue(int capacity)

### Method Detail

#### offer

    public boolean offer(T t)

Drops elements if capacity has been reached. That's OK for the ThreadPoolExecutor as dropped messages will get retransmitted

Specified by:
  `offer` in interface `java.util.concurrent.BlockingQueue<T>`
Specified by:
  `offer` in interface `java.util.Queue<T>`
Overrides:
  `offer` in class `java.util.concurrent.ConcurrentLinkedQueue<T>`
Parameters:
  `t` -
Returns:

#### take

    public T take()
           throws java.lang.InterruptedException

Specified by:
  `take` in interface `java.util.concurrent.BlockingQueue<T>`
Throws:
  `java.lang.InterruptedException`

#### poll

    public T poll()

Specified by:
  `poll` in interface `java.util.Queue<T>`
Overrides:
  `poll` in class `java.util.concurrent.ConcurrentLinkedQueue<T>`

#### poll

    public T poll(long timeout,
         java.util.concurrent.TimeUnit unit)
           throws java.lang.InterruptedException

Specified by:
  `poll` in interface `java.util.concurrent.BlockingQueue<T>`
Throws:
  `java.lang.InterruptedException`

#### remove

    public boolean remove(java.lang.Object o)

Specified by:
  `remove` in interface `java.util.Collection<T>`
Specified by:
  `remove` in interface `java.util.concurrent.BlockingQueue<T>`
Overrides:
  `remove` in class `java.util.concurrent.ConcurrentLinkedQueue<T>`

#### remainingCapacity

    public int remainingCapacity()

Specified by:
  `remainingCapacity` in interface `java.util.concurrent.BlockingQueue<T>`

#### drainTo

    public int drainTo(java.util.Collection<? super T> c)

Specified by:
  `drainTo` in interface `java.util.concurrent.BlockingQueue<T>`

#### put

    public void put(T t)
             throws java.lang.InterruptedException

Specified by:
  `put` in interface `java.util.concurrent.BlockingQueue<T>`
Throws:
  `java.lang.InterruptedException`

#### offer

    public boolean offer(T t,
                long timeout,
                java.util.concurrent.TimeUnit unit)
                  throws java.lang.InterruptedException

Specified by:
  `offer` in interface `java.util.concurrent.BlockingQueue<T>`
Throws:
  `java.lang.InterruptedException`

#### drainTo

    public int drainTo(java.util.Collection<? super T> c,
              int maxElements)

Specified by:
  `drainTo` in interface `java.util.concurrent.BlockingQueue<T>`