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
    Modifier and Type | Method and Description
    --- | ---
    `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.