CircularBlockingQueue (Apache ZooKeeper - Server 3.7.0 API)
Date: 2021-03-17

org.apache.zookeeper.util

## Class CircularBlockingQueue<E>

- java.lang.Object
- - org.apache.zookeeper.util.CircularBlockingQueue<E>

- All Implemented Interfaces:
    Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>

      public class CircularBlockingQueue<E>
      extends Object
      implements BlockingQueue<E>

  A bounded blocking queue backed by an array. This queue orders elements FIFO (first-in-first-out). The head of the queue is that element that has been on the queue the longest time. The tail of the queue is that element that has been on the queue the shortest time. New elements are inserted at the tail of the queue, and the queue retrieval operations obtain elements at the head of the queue. If the queue is full, the head of the queue (the oldest element) will be removed to make room for the newest element.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `CircularBlockingQueue(int queueSize)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `add(E e)`
    `boolean` | `addAll(Collection<? extends E> arg0)`
    `void` | `clear()`
    `boolean` | `contains(Object o)`
    `boolean` | `containsAll(Collection<?> arg0)`
    `int` | `drainTo(Collection<? super E> c)`
    `int` | `drainTo(Collection<? super E> c, int maxElements)`
    `E` | `element()`
    `long` | `getDroppedCount()` Returns the number of elements that were dropped from the queue because the queue was full when a new element was offered.
    `boolean` | `isEmpty()`
    `Iterator<E>` | `iterator()`
    `boolean` | `offer(E e)` This method differs from `BlockingQueue.offer(Object)` in that it will remove the oldest queued element (the element at the front of the queue) in order to make room for any new elements if the queue is full.
    `boolean` | `offer(E e, long timeout, TimeUnit unit)`
    `E` | `peek()`
    `E` | `poll()`
    `E` | `poll(long timeout, TimeUnit unit)`
    `void` | `put(E e)`
    `int` | `remainingCapacity()`
    `E` | `remove()`
    `boolean` | `remove(Object o)`
    `boolean` | `removeAll(Collection<?> arg0)`
    `boolean` | `retainAll(Collection<?> arg0)`
    `int` | `size()`
    `E` | `take()`
    `Object[]` | `toArray()`
    `<T> T[]` | `toArray(T[] arg0)`

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

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

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

      `equals, hashCode, parallelStream, removeIf, spliterator, stream`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach`

- - ### Constructor Detail

    - #### CircularBlockingQueue

          public CircularBlockingQueue(int queueSize)

  - ### Method Detail

    - #### offer

          public boolean offer(E e)

      This method differs from `BlockingQueue.offer(Object)` in that it will remove the oldest queued element (the element at the front of the queue) in order to make room for any new elements if the queue is full.
      Specified by:
        `offer` in interface `BlockingQueue<E>`
      Specified by:
        `offer` in interface `Queue<E>`
      Parameters:
        `e` - the element to add
      Returns:
        true since it will make room for any new elements if required

    - #### poll

          public E poll(long timeout,
                        TimeUnit unit)
                 throws InterruptedException

      Specified by:
        `poll` in interface `BlockingQueue<E>`
      Throws:
        `InterruptedException`

    - #### take

          public E take()
                 throws InterruptedException

      Specified by:
        `take` in interface `BlockingQueue<E>`
      Throws:
        `InterruptedException`

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `Collection<E>`

    - #### size

          public int size()

      Specified by:
        `size` in interface `Collection<E>`

    - #### getDroppedCount

          public long getDroppedCount()

      Returns the number of elements that were dropped from the queue because the queue was full when a new element was offered.
      Returns:
        The number of elements dropped (lost) from the queue

    - #### drainTo

          public int drainTo(Collection<? super E> c)

      Specified by:
        `drainTo` in interface `BlockingQueue<E>`

    - #### poll

          public E poll()

      Specified by:
        `poll` in interface `Queue<E>`

    - #### element

          public E element()

      Specified by:
        `element` in interface `Queue<E>`

    - #### peek

          public E peek()

      Specified by:
        `peek` in interface `Queue<E>`

    - #### remove

          public E remove()

      Specified by:
        `remove` in interface `Queue<E>`

    - #### addAll

          public boolean addAll(Collection<? extends E> arg0)

      Specified by:
        `addAll` in interface `Collection<E>`

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `Collection<E>`

    - #### containsAll

          public boolean containsAll(Collection<?> arg0)

      Specified by:
        `containsAll` in interface `Collection<E>`

    - #### iterator

          public Iterator<E> iterator()

      Specified by:
        `iterator` in interface `Iterable<E>`
      Specified by:
        `iterator` in interface `Collection<E>`

    - #### removeAll

          public boolean removeAll(Collection<?> arg0)

      Specified by:
        `removeAll` in interface `Collection<E>`

    - #### retainAll

          public boolean retainAll(Collection<?> arg0)

      Specified by:
        `retainAll` in interface `Collection<E>`

    - #### toArray

          public Object[] toArray()

      Specified by:
        `toArray` in interface `Collection<E>`

    - #### toArray

          public <T> T[] toArray(T[] arg0)

      Specified by:
        `toArray` in interface `Collection<E>`

    - #### add

          public boolean add(E e)

      Specified by:
        `add` in interface `Collection<E>`
      Specified by:
        `add` in interface `BlockingQueue<E>`
      Specified by:
        `add` in interface `Queue<E>`

    - #### contains

          public boolean contains(Object o)

      Specified by:
        `contains` in interface `Collection<E>`
      Specified by:
        `contains` in interface `BlockingQueue<E>`

    - #### drainTo

          public int drainTo(Collection<? super E> c,
                             int maxElements)

      Specified by:
        `drainTo` in interface `BlockingQueue<E>`

    - #### offer

          public boolean offer(E e,
                               long timeout,
                               TimeUnit unit)
                        throws InterruptedException

      Specified by:
        `offer` in interface `BlockingQueue<E>`
      Throws:
        `InterruptedException`

    - #### put

          public void put(E e)
                   throws InterruptedException

      Specified by:
        `put` in interface `BlockingQueue<E>`
      Throws:
        `InterruptedException`

    - #### remainingCapacity

          public int remainingCapacity()

      Specified by:
        `remainingCapacity` in interface `BlockingQueue<E>`

    - #### remove

          public boolean remove(Object o)

      Specified by:
        `remove` in interface `Collection<E>`
      Specified by:
        `remove` in interface `BlockingQueue<E>`

Copyright © 2008–2021 The Apache Software Foundation. All rights reserved.