Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/util/concurrent/BlockingQueue.java
/* * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */ package java.util.concurrent; import java.util.Collection; import java.util.Queue; /** * A {@link Queue} that additionally supports operations that wait for * the queue to become non-empty when retrieving an element, and wait * for space to become available in the queue when storing an element. * * <p>{@code BlockingQueue} methods come in four forms, with different ways * of handling operations that cannot be satisfied immediately, but may be * satisfied at some point in the future: * one throws an exception, the second returns a special value (either * {@code null} or {@code false}, depending on the operation), the third * blocks the current thread indefinitely until the operation can succeed, * and the fourth blocks for only a given maximum time limit before giving * up. These methods are summarized in the following table: * * <table class="plain"> * <caption>Summary of BlockingQueue methods</caption> * <tr> * <td></td> * <th scope="col" style="font-weight:normal; font-style:italic">Throws exception</th> * <th scope="col" style="font-weight:normal; font-style:italic">Special value</th> * <th scope="col" style="font-weight:normal; font-style:italic">Blocks</th> * <th scope="col" style="font-weight:normal; font-style:italic">Times out</th> * </tr> * <tr> * <th scope="row" style="text-align:left">Insert</th> * <td>{@link #add(Object) add(e)}</td> * <td>{@link #offer(Object) offer(e)}</td> * <td>{@link #put(Object) put(e)}</td> * <td>{@link #offer(Object, long, TimeUnit) offer(e, time, unit)}</td> * </tr> * <tr> * <th scope="row" style="text-align:left">Remove</th> * <td>{@link #remove() remove()}</td> * <td>{@link #poll() poll()}</td> * <td>{@link #take() take()}</td> * <td>{@link #poll(long, TimeUnit) poll(time, unit)}</td> * </tr> * <tr> * <th scope="row" style="text-align:left">Examine</th> * <td>{@link #element() element()}</td> * <td>{@link #peek() peek()}</td> * <td style="font-style: italic">not applicable</td> * <td style="font-style: italic">not applicable</td> * </tr> * </table> * * <p>A {@code BlockingQueue} does not accept {@code null} elements. * Implementations throw {@code NullPointerException} on attempts * to {@code add}, {@code put} or {@code offer} a {@code null}. A * {@code null} is used as a sentinel value to indicate failure of * {@code poll} operations. * * <p>A {@code BlockingQueue} may be capacity bounded. At any given * time it may have a {@code remainingCapacity} beyond which no * additional elements can be {@code put} without blocking. * A {@code BlockingQueue} without any intrinsic capacity constraints always * reports a remaining capacity of {@code Integer.MAX_VALUE}. * * <p>{@code BlockingQueue} implementations are designed to be used * primarily for producer-consumer queues, but additionally support * the {@link Collection} interface. So, for example, it is * possible to remove an arbitrary element from a queue using * {@code remove(x)}. However, such operations are in general * <em>not</em> performed very efficiently, and are intended for only * occasional use, such as when a queued message is cancelled. * * <p>{@code BlockingQueue} implementations are thread-safe. All * queuing methods achieve their effects atomically using internal * locks or other forms of concurrency control. However, the * <em>bulk</em> Collection operations {@code addAll}, * {@code containsAll}, {@code retainAll} and {@code removeAll} are * <em>not</em> necessarily performed atomically unless specified * otherwise in an implementation. So it is possible, for example, for * {@code addAll(c)} to fail (throwing an exception) after adding * only some of the elements in {@code c}. * * <p>A {@code BlockingQueue} does <em>not</em> intrinsically support * any kind of "close" or "shutdown" operation to * indicate that no more items will be added. The needs and usage of * such features tend to be implementation-dependent. For example, a * common tactic is for producers to insert special * <em>end-of-stream</em> or <em>poison</em> objects, that are * interpreted accordingly when taken by consumers. * * <p> * Usage example, based on a typical producer-consumer scenario. * Note that a {@code BlockingQueue} can safely be used with multiple * producers and multiple consumers. * <pre> {@code * class Producer implements Runnable { * private final BlockingQueue queue; * Producer(BlockingQueue q) { queue = q; } * public void run() { * try { * while (true) { queue.put(produce()); } * } catch (InterruptedException ex) { ... handle ...} * } * Object produce() { ... } * } * * class Consumer implements Runnable { * private final BlockingQueue queue; * Consumer(BlockingQueue q) { queue = q; } * public void run() { * try { * while (true) { consume(queue.take()); } * } catch (InterruptedException ex) { ... handle ...} * } * void consume(Object x) { ... } * } * * class Setup { * void main() { * BlockingQueue q = new SomeQueueImplementation(); * Producer p = new Producer(q); * Consumer c1 = new Consumer(q); * Consumer c2 = new Consumer(q); * new Thread(p).start(); * new Thread(c1).start(); * new Thread(c2).start(); * } * }}</pre> * * <p>Memory consistency effects: As with other concurrent * collections, actions in a thread prior to placing an object into a * {@code BlockingQueue} * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a> * actions subsequent to the access or removal of that element from * the {@code BlockingQueue} in another thread. * * <p>This interface is a member of the * <a href="{@docRoot}/java.base/java/util/package-summary.html#CollectionsFramework"> * Java Collections Framework</a>. * * @since 1.5 * @author Doug Lea * @param <E> the type of elements held in this queue */ public interface BlockingQueue<E> extends Queue<E> { /** * Inserts the specified element into this queue if it is possible to do * so immediately without violating capacity restrictions, returning * {@code true} upon success and throwing an * {@code IllegalStateException} if no space is currently available. * When using a capacity-restricted queue, it is generally preferable to * use {@link #offer(Object) offer}. * * @param e the element to add * @return {@code true} (as specified by {@link Collection#add}) * @throws IllegalStateException if the element cannot be added at this * time due to capacity restrictions * @throws ClassCastException if the class of the specified element * prevents it from being added to this queue * @throws NullPointerException if the specified element is null * @throws IllegalArgumentException if some property of the specified * element prevents it from being added to this queue */ boolean add(E e); /** * Inserts the specified element into this queue if it is possible to do * so immediately without violating capacity restrictions, returning * {@code true} upon success and {@code false} if no space is currently * available. When using a capacity-restricted queue, this method is * generally preferable to {@link #add}, which can fail to insert an * element only by throwing an exception. * * @param e the element to add * @return {@code true} if the element was added to this queue, else * {@code false} * @throws ClassCastException if the class of the specified element * prevents it from being added to this queue * @throws NullPointerException if the specified element is null * @throws IllegalArgumentException if some property of the specified * element prevents it from being added to this queue */ boolean offer(E e); /** * Inserts the specified element into this queue, waiting if necessary * for space to become available. * * @param e the element to add * @throws InterruptedException if interrupted while waiting * @throws ClassCastException if the class of the specified element * prevents it from being added to this queue * @throws NullPointerException if the specified element is null * @throws IllegalArgumentException if some property of the specified * element prevents it from being added to this queue */ void put(E e) throws InterruptedException; /** * Inserts the specified element into this queue, waiting up to the * specified wait time if necessary for space to become available. * * @param e the element to add * @param timeout how long to wait before giving up, in units of * {@code unit} * @param unit a {@code TimeUnit} determining how to interpret the * {@code timeout} parameter * @return {@code true} if successful, or {@code false} if * the specified waiting time elapses before space is available * @throws InterruptedException if interrupted while waiting * @throws ClassCastException if the class of the specified element * prevents it from being added to this queue * @throws NullPointerException if the specified element is null * @throws IllegalArgumentException if some property of the specified * element prevents it from being added to this queue */ boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException; /** * Retrieves and removes the head of this queue, waiting if necessary * until an element becomes available. * * @return the head of this queue * @throws InterruptedException if interrupted while waiting */ E take() throws InterruptedException; /** * Retrieves and removes the head of this queue, waiting up to the * specified wait time if necessary for an element to become available. * * @param timeout how long to wait before giving up, in units of * {@code unit} * @param unit a {@code TimeUnit} determining how to interpret the * {@code timeout} parameter * @return the head of this queue, or {@code null} if the * specified waiting time elapses before an element is available * @throws InterruptedException if interrupted while waiting */ E poll(long timeout, TimeUnit unit) throws InterruptedException; /** * Returns the number of additional elements that this queue can ideally * (in the absence of memory or resource constraints) accept without * blocking, or {@code Integer.MAX_VALUE} if there is no intrinsic * limit. * * <p>Note that you <em>cannot</em> always tell if an attempt to insert * an element will succeed by inspecting {@code remainingCapacity} * because it may be the case that another thread is about to * insert or remove an element. * * @return the remaining capacity */ int remainingCapacity(); /** * Removes a single instance of the specified element from this queue, * if it is present. More formally, removes an element {@code e} such * that {@code o.equals(e)}, if this queue contains one or more such * elements. * Returns {@code true} if this queue contained the specified element * (or equivalently, if this queue changed as a result of the call). * * @param o element to be removed from this queue, if present * @return {@code true} if this queue changed as a result of the call * @throws ClassCastException if the class of the specified element * is incompatible with this queue * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>) * @throws NullPointerException if the specified element is null * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>) */ boolean remove(Object o); /** * Returns {@code true} if this queue contains the specified element. * More formally, returns {@code true} if and only if this queue contains * at least one element {@code e} such that {@code o.equals(e)}. * * @param o object to be checked for containment in this queue * @return {@code true} if this queue contains the specified element * @throws ClassCastException if the class of the specified element * is incompatible with this queue * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>) * @throws NullPointerException if the specified element is null * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>) */ boolean contains(Object o); /** * Removes all available elements from this queue and adds them * to the given collection. This operation may be more * efficient than repeatedly polling this queue. A failure * encountered while attempting to add elements to * collection {@code c} may result in elements being in neither, * either or both collections when the associated exception is * thrown. Attempts to drain a queue to itself result in * {@code IllegalArgumentException}. Further, the behavior of * this operation is undefined if the specified collection is * modified while the operation is in progress. * * @param c the collection to transfer elements into * @return the number of elements transferred * @throws UnsupportedOperationException if addition of elements * is not supported by the specified collection * @throws ClassCastException if the class of an element of this queue * prevents it from being added to the specified collection * @throws NullPointerException if the specified collection is null * @throws IllegalArgumentException if the specified collection is this * queue, or some property of an element of this queue prevents * it from being added to the specified collection */ int drainTo(Collection<? super E> c); /** * Removes at most the given number of available elements from * this queue and adds them to the given collection. A failure * encountered while attempting to add elements to * collection {@code c} may result in elements being in neither, * either or both collections when the associated exception is * thrown. Attempts to drain a queue to itself result in * {@code IllegalArgumentException}. Further, the behavior of * this operation is undefined if the specified collection is * modified while the operation is in progress. * * @param c the collection to transfer elements into * @param maxElements the maximum number of elements to transfer * @return the number of elements transferred * @throws UnsupportedOperationException if addition of elements * is not supported by the specified collection * @throws ClassCastException if the class of an element of this queue * prevents it from being added to the specified collection * @throws NullPointerException if the specified collection is null * @throws IllegalArgumentException if the specified collection is this * queue, or some property of an element of this queue prevents * it from being added to the specified collection */ int drainTo(Collection<? super E> c, int maxElements); }
⏎ java/util/concurrent/BlockingQueue.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 205141👍, 0💬
Popular Posts:
JAX-WS is an API for building web services and clients. It is the next generation Web Services API r...
xml-commons Resolver Source Code Files are provided in the source package file, xml-commons-resolver...
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime e...
Jackson is "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java"....
If you are a Java developer, it is very often that you need to use some 3rd party libraries to perfo...