## 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
`ConcurrentLinkedBlockingQueue(int capacity)`

Method Summary
`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>`

Copyright © 1998-2009 Bela Ban / Red Hat. All Rights Reserved.