OpenJDK 27 · java.util.concurrent.LinkedBlockingDeque

Modifier and Type	Class and Description
private abstract class	LinkedBlockingDeque.AbstractItr Base class for LinkedBlockingDeque iterators.
private class	LinkedBlockingDeque.DescendingItr Descending iterator
private class	LinkedBlockingDeque.Itr Forward iterator
private class	LinkedBlockingDeque.LBDSpliterator A customized variant of Spliterators.IteratorSpliterator.
pack-priv static class	LinkedBlockingDeque.Node<E> Doubly-linked list node class

Modifier and Type	Field and Description
private final int	capacity
private transient volatile int	count Number of items in the deque
pack-priv transient LinkedBlockingDeque.Node<E>	first Pointer to first node.
pack-priv transient LinkedBlockingDeque.Node<E>	last Pointer to last node.
pack-priv final ReentrantLock	lock
private final Condition	notEmpty
private final Condition	notFull
private static final long	serialVersionUID

Access	Constructor and Description
public	LinkedBlockingDeque() Creates a `LinkedBlockingDeque` with a capacity of `Integer#MAX_VALUE`.
public	LinkedBlockingDeque(int the capacity of this deque capacity) Creates a `LinkedBlockingDeque` with the given (fixed) capacity.
public	LinkedBlockingDeque(Collection<? extends E> the collection of elements to initially contain c) Creates a `LinkedBlockingDeque` with a capacity of `Integer#MAX_VALUE`, initially containing the elements of the given collection, added in traversal order of the collection's iterator.

Method Summary

Modifier and Type	Method and Description
public boolean	add(E e) Overrides java.util.AbstractQueue.add. Implements java.util.concurrent.BlockingDeque.add, java.util.Queue.add, java.util.Collection.add. Inserts the specified element at the end of this deque unless it would violate capacity restrictions.
public boolean	Returns: `true` if this deque changed as a result of the call addAll(Collection<? extends E> the elements to be inserted into this deque c) Overrides java.util.AbstractQueue.addAll. Implements java.util.Collection.addAll, java.util.Deque.addAll. Appends all of the elements in the specified collection to the end of this deque, in the order that they are returned by the specified collection's iterator.
public void	addFirst(E e) Implements java.util.concurrent.BlockingDeque.addFirst. Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an `IllegalStateException` if no space is currently available.
public void	addLast(E e) Implements java.util.concurrent.BlockingDeque.addLast. Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an `IllegalStateException` if no space is currently available.
private boolean	bulkRemove(Predicate<? super E> filter) Implementation of bulk remove methods.
pack-priv void	checkInvariants()
public void	clear() Overrides java.util.AbstractQueue.clear. Implements java.util.Collection.clear. Atomically removes all of the elements from this deque.
public boolean	Returns: `true` if this deque contains the specified element contains(Object object to be checked for containment in this deque o) Overrides java.util.AbstractCollection.contains. Implements java.util.concurrent.BlockingDeque.contains, java.util.Collection.contains. Returns `true` if this deque contains the specified element.
public Iterator<E>	Returns: an iterator over the elements in this deque in reverse order descendingIterator() Implements java.util.Deque.descendingIterator. Returns an iterator over the elements in this deque in reverse sequential order.
public int	drainTo(Collection<? super E> c) Implements java.util.concurrent.BlockingQueue.drainTo. Removes all available elements from this queue and adds them to the given collection.
public int	drainTo(Collection<? super E> c, int maxElements) Implements java.util.concurrent.BlockingQueue.drainTo. Removes at most the given number of available elements from this queue and adds them to the given collection.
public E	Returns: the head of the queue represented by this deque element() Overrides java.util.AbstractQueue.element. Implements java.util.concurrent.BlockingDeque.element, java.util.Queue.element. Retrieves, but does not remove, the head of the queue represented by this deque.
public void	forEach(Consumer<? super E> action) Overrides default java.lang.Iterable.forEach. Performs the given action for each element of the `Iterable` until all elements have been processed or the action throws an exception.
pack-priv void	forEachFrom(Consumer<? super E> action, LinkedBlockingDeque.Node<E> p) Runs action on each element found during a traversal starting at p.
public E	getFirst() Implements java.util.Deque.getFirst. Retrieves, but does not remove, the first element of this deque.
public E	getLast() Implements java.util.Deque.getLast. Retrieves, but does not remove, the last element of this deque.
public Iterator<E>	Returns: an iterator over the elements in this deque in proper sequence iterator() Implements abstract java.util.AbstractCollection.iterator. Implements java.util.concurrent.BlockingDeque.iterator, java.util.Collection.iterator. Returns an iterator over the elements in this deque in proper sequence.
private boolean	Returns: true if the node was added; false otherwise linkFirst(LinkedBlockingDeque.Node<E> node) Links node as first element, or returns false if full.
private boolean	Returns: true if the node was added; false otherwise linkLast(LinkedBlockingDeque.Node<E> node) Links node as last element, or returns false if full.
public boolean	offer(E e) Implements java.util.concurrent.BlockingDeque.offer, java.util.Queue.offer. Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and `false` if no space is currently available.
public boolean	offer(E e, long timeout, TimeUnit unit) Implements java.util.concurrent.BlockingDeque.offer. Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque), waiting up to the specified wait time if necessary for space to become available.
public boolean	offerFirst(E e) Implements java.util.concurrent.BlockingDeque.offerFirst. Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and `false` if no space is currently available.
public boolean	offerFirst(E e, long timeout, TimeUnit unit) Implements java.util.concurrent.BlockingDeque.offerFirst. Inserts the specified element at the front of this deque, waiting up to the specified wait time if necessary for space to become available.
public boolean	offerLast(E e) Implements java.util.concurrent.BlockingDeque.offerLast. Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions, returning `true` upon success and `false` if no space is currently available.
public boolean	offerLast(E e, long timeout, TimeUnit unit) Implements java.util.concurrent.BlockingDeque.offerLast. Inserts the specified element at the end of this deque, waiting up to the specified wait time if necessary for space to become available.
public E	peek() Implements java.util.concurrent.BlockingDeque.peek, java.util.Queue.peek. Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque), or returns `null` if this deque is empty.
public E	peekFirst() Implements java.util.Deque.peekFirst. Retrieves, but does not remove, the first element of this deque, or returns `null` if this deque is empty.
public E	peekLast() Implements java.util.Deque.peekLast. Retrieves, but does not remove, the last element of this deque, or returns `null` if this deque is empty.
public E	poll() Implements java.util.concurrent.BlockingDeque.poll, java.util.Queue.poll. Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns `null` if this deque is empty.
public E	poll(long timeout, TimeUnit unit) Implements java.util.concurrent.BlockingDeque.poll. Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), waiting up to the specified wait time if necessary for an element to become available.
public E	pollFirst() Implements java.util.Deque.pollFirst. Retrieves and removes the first element of this deque, or returns `null` if this deque is empty.
public E	pollFirst(long timeout, TimeUnit unit) Implements java.util.concurrent.BlockingDeque.pollFirst. Retrieves and removes the first element of this deque, waiting up to the specified wait time if necessary for an element to become available.
public E	pollLast() Implements java.util.Deque.pollLast. Retrieves and removes the last element of this deque, or returns `null` if this deque is empty.
public E	pollLast(long timeout, TimeUnit unit) Implements java.util.concurrent.BlockingDeque.pollLast. Retrieves and removes the last element of this deque, waiting up to the specified wait time if necessary for an element to become available.
public E	pop() Implements java.util.Deque.pop. Pops an element from the stack represented by this deque.
public void	push(E e) Implements java.util.concurrent.BlockingDeque.push. Pushes an element onto the stack represented by this deque (in other words, at the head of this deque) if it is possible to do so immediately without violating capacity restrictions, throwing an `IllegalStateException` if no space is currently available.
public void	put(E e) Implements java.util.concurrent.BlockingDeque.put. Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque), waiting if necessary for space to become available.
public void	putFirst(E e) Implements java.util.concurrent.BlockingDeque.putFirst. Inserts the specified element at the front of this deque, waiting if necessary for space to become available.
public void	putLast(E e) Implements java.util.concurrent.BlockingDeque.putLast. Inserts the specified element at the end of this deque, waiting if necessary for space to become available.
private void	readObject(ObjectInputStream the stream s) Reconstitutes this deque from a stream (that is, deserializes it).
public int	remainingCapacity() Implements java.util.concurrent.BlockingQueue.remainingCapacity. Returns the number of additional elements that this deque can ideally (in the absence of memory or resource constraints) accept without blocking.
public E	Returns: the head of the queue represented by this deque remove() Overrides java.util.AbstractQueue.remove. Implements java.util.concurrent.BlockingDeque.remove, java.util.Queue.remove. Retrieves and removes the head of the queue represented by this deque.
public boolean	Returns: `true` if this deque changed as a result of the call remove(Object element to be removed from this deque, if present o) Overrides java.util.AbstractCollection.remove. Implements java.util.concurrent.BlockingDeque.remove, java.util.Collection.remove. Removes the first occurrence of the specified element from this deque.
public boolean	removeAll(Collection<?> c) Overrides java.util.AbstractCollection.removeAll. Implements java.util.Collection.removeAll. Removes all of this collection's elements that are also contained in the specified collection (optional operation).
public E	removeFirst() Implements java.util.Deque.removeFirst. Retrieves and removes the first element of this deque.
public boolean	removeFirstOccurrence(Object o) Implements java.util.concurrent.BlockingDeque.removeFirstOccurrence. Removes the first occurrence of the specified element from this deque.
public boolean	removeIf(Predicate<? super E> filter) Overrides default java.util.Collection.removeIf. Removes all of the elements of this collection that satisfy the given predicate (optional operation).
public E	removeLast() Implements java.util.Deque.removeLast. Retrieves and removes the last element of this deque.
public boolean	removeLastOccurrence(Object o) Implements java.util.concurrent.BlockingDeque.removeLastOccurrence. Removes the last occurrence of the specified element from this deque.
public boolean	retainAll(Collection<?> c) Overrides java.util.AbstractCollection.retainAll. Implements java.util.Collection.retainAll. Retains only the elements in this collection that are contained in the specified collection (optional operation).
public int	Returns: the number of elements in this deque size() Implements abstract java.util.AbstractCollection.size. Implements java.util.concurrent.BlockingDeque.size, java.util.Collection.size. Returns the number of elements in this deque.
public Spliterator<E>	Returns: a `Spliterator` over the elements in this deque spliterator() Overrides default java.util.Collection.spliterator. Returns a `Spliterator` over the elements in this deque.
pack-priv LinkedBlockingDeque.Node<E>	succ(LinkedBlockingDeque.Node<E> p) Used for any element traversal that is not entirely under lock.
public E	take() Implements java.util.concurrent.BlockingDeque.take. Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), waiting if necessary until an element becomes available.
public E	takeFirst() Implements java.util.concurrent.BlockingDeque.takeFirst. Retrieves and removes the first element of this deque, waiting if necessary until an element becomes available.
public E	takeLast() Implements java.util.concurrent.BlockingDeque.takeLast. Retrieves and removes the last element of this deque, waiting if necessary until an element becomes available.
public Object[]	Returns: an array containing all of the elements in this deque toArray() Overrides java.util.AbstractCollection.toArray. Implements java.util.Collection.toArray. Returns an array containing all of the elements in this deque, in proper sequence (from first to last element).
public <T> T[]	Returns: an array containing all of the elements in this deque toArray(T[] the array into which the elements of the deque are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose a) Overrides java.util.AbstractCollection.toArray. Implements java.util.Collection.toArray. Returns an array containing all of the elements in this deque, in proper sequence; the runtime type of the returned array is that of the specified array.
public String	toString() Overrides java.util.AbstractCollection.toString. Returns a string representation of this collection.
pack-priv void	unlink(LinkedBlockingDeque.Node<E> x) Unlinks x.
private E	unlinkFirst() Removes and returns first element, or null if empty.
private E	unlinkLast() Removes and returns last element, or null if empty.
private void	writeObject(ObjectOutputStream the stream s) Saves this deque to a stream (that is, serializes it).

public Class LinkedBlockingDeque<E>

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary