My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/util/concurrent/locks/AbstractQueuedSynchronizer.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/util/concurrent/locks/AbstractQueuedSynchronizer.java+2330−0

@@ -0,0 +1,2330 @@
	1	+/*
	2	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	3	+ *
	4	+ * This code is free software; you can redistribute it and/or modify it
	5	+ * under the terms of the GNU General Public License version 2 only, as
	6	+ * published by the Free Software Foundation. Oracle designates this
	7	+ * particular file as subject to the "Classpath" exception as provided
	8	+ * by Oracle in the LICENSE file that accompanied this code.
	9	+ *
	10	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	11	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	13	+ * version 2 for more details (a copy is included in the LICENSE file that
	14	+ * accompanied this code).
	15	+ *
	16	+ * You should have received a copy of the GNU General Public License version
	17	+ * 2 along with this work; if not, write to the Free Software Foundation,
	18	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	19	+ *
	20	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	21	+ * or visit www.oracle.com if you need additional information or have any
	22	+ * questions.
	23	+ */
	24	+
	25	+/*
	26	+ * This file is available under and governed by the GNU General Public
	27	+ * License version 2 only, as published by the Free Software Foundation.
	28	+ * However, the following notice accompanied the original version of this
	29	+ * file:
	30	+ *
	31	+ * Written by Doug Lea with assistance from members of JCP JSR-166
	32	+ * Expert Group and released to the public domain, as explained at
	33	+ * http://creativecommons.org/publicdomain/zero/1.0/
	34	+ */
	35	+
	36	+package java.util.concurrent.locks;
	37	+import java.util.*;
	38	+import java.util.concurrent.*;
	39	+import java.util.concurrent.atomic.*;
	40	+import sun.misc.Unsafe;
	41	+
	42	+/**
	43	+ * Provides a framework for implementing blocking locks and related
	44	+ * synchronizers (semaphores, events, etc) that rely on
	45	+ * first-in-first-out (FIFO) wait queues. This class is designed to
	46	+ * be a useful basis for most kinds of synchronizers that rely on a
	47	+ * single atomic <tt>int</tt> value to represent state. Subclasses
	48	+ * must define the protected methods that change this state, and which
	49	+ * define what that state means in terms of this object being acquired
	50	+ * or released. Given these, the other methods in this class carry
	51	+ * out all queuing and blocking mechanics. Subclasses can maintain
	52	+ * other state fields, but only the atomically updated <tt>int</tt>
	53	+ * value manipulated using methods {@link #getState}, {@link
	54	+ * #setState} and {@link #compareAndSetState} is tracked with respect
	55	+ * to synchronization.
	56	+ *
	57	+ * <p>Subclasses should be defined as non-public internal helper
	58	+ * classes that are used to implement the synchronization properties
	59	+ * of their enclosing class. Class
	60	+ * <tt>AbstractQueuedSynchronizer</tt> does not implement any
	61	+ * synchronization interface. Instead it defines methods such as
	62	+ * {@link #acquireInterruptibly} that can be invoked as
	63	+ * appropriate by concrete locks and related synchronizers to
	64	+ * implement their public methods.
	65	+ *
	66	+ * <p>This class supports either or both a default <em>exclusive</em>
	67	+ * mode and a <em>shared</em> mode. When acquired in exclusive mode,
	68	+ * attempted acquires by other threads cannot succeed. Shared mode
	69	+ * acquires by multiple threads may (but need not) succeed. This class
	70	+ * does not "understand" these differences except in the
	71	+ * mechanical sense that when a shared mode acquire succeeds, the next
	72	+ * waiting thread (if one exists) must also determine whether it can
	73	+ * acquire as well. Threads waiting in the different modes share the
	74	+ * same FIFO queue. Usually, implementation subclasses support only
	75	+ * one of these modes, but both can come into play for example in a
	76	+ * {@link ReadWriteLock}. Subclasses that support only exclusive or
	77	+ * only shared modes need not define the methods supporting the unused mode.
	78	+ *
	79	+ * <p>This class defines a nested {@link ConditionObject} class that
	80	+ * can be used as a {@link Condition} implementation by subclasses
	81	+ * supporting exclusive mode for which method {@link
	82	+ * #isHeldExclusively} reports whether synchronization is exclusively
	83	+ * held with respect to the current thread, method {@link #release}
	84	+ * invoked with the current {@link #getState} value fully releases
	85	+ * this object, and {@link #acquire}, given this saved state value,
	86	+ * eventually restores this object to its previous acquired state. No
	87	+ * <tt>AbstractQueuedSynchronizer</tt> method otherwise creates such a
	88	+ * condition, so if this constraint cannot be met, do not use it. The
	89	+ * behavior of {@link ConditionObject} depends of course on the
	90	+ * semantics of its synchronizer implementation.
	91	+ *
	92	+ * <p>This class provides inspection, instrumentation, and monitoring
	93	+ * methods for the internal queue, as well as similar methods for
	94	+ * condition objects. These can be exported as desired into classes
	95	+ * using an <tt>AbstractQueuedSynchronizer</tt> for their
	96	+ * synchronization mechanics.
	97	+ *
	98	+ * <p>Serialization of this class stores only the underlying atomic
	99	+ * integer maintaining state, so deserialized objects have empty
	100	+ * thread queues. Typical subclasses requiring serializability will
	101	+ * define a <tt>readObject</tt> method that restores this to a known
	102	+ * initial state upon deserialization.
	103	+ *
	104	+ * <h3>Usage</h3>
	105	+ *
	106	+ * <p>To use this class as the basis of a synchronizer, redefine the
	107	+ * following methods, as applicable, by inspecting and/or modifying
	108	+ * the synchronization state using {@link #getState}, {@link
	109	+ * #setState} and/or {@link #compareAndSetState}:
	110	+ *
	111	+ * <ul>
	112	+ * <li> {@link #tryAcquire}
	113	+ * <li> {@link #tryRelease}
	114	+ * <li> {@link #tryAcquireShared}
	115	+ * <li> {@link #tryReleaseShared}
	116	+ * <li> {@link #isHeldExclusively}
	117	+ *</ul>
	118	+ *
	119	+ * Each of these methods by default throws {@link
	120	+ * UnsupportedOperationException}. Implementations of these methods
	121	+ * must be internally thread-safe, and should in general be short and
	122	+ * not block. Defining these methods is the <em>only</em> supported
	123	+ * means of using this class. All other methods are declared
	124	+ * <tt>final</tt> because they cannot be independently varied.
	125	+ *
	126	+ * <p>You may also find the inherited methods from {@link
	127	+ * AbstractOwnableSynchronizer} useful to keep track of the thread
	128	+ * owning an exclusive synchronizer. You are encouraged to use them
	129	+ * -- this enables monitoring and diagnostic tools to assist users in
	130	+ * determining which threads hold locks.
	131	+ *
	132	+ * <p>Even though this class is based on an internal FIFO queue, it
	133	+ * does not automatically enforce FIFO acquisition policies. The core
	134	+ * of exclusive synchronization takes the form:
	135	+ *
	136	+ * <pre>
	137	+ * Acquire:
	138	+ * while (!tryAcquire(arg)) {
	139	+ * <em>enqueue thread if it is not already queued</em>;
	140	+ * <em>possibly block current thread</em>;
	141	+ * }
	142	+ *
	143	+ * Release:
	144	+ * if (tryRelease(arg))
	145	+ * <em>unblock the first queued thread</em>;
	146	+ * </pre>
	147	+ *
	148	+ * (Shared mode is similar but may involve cascading signals.)
	149	+ *
	150	+ * <p><a name="barging">Because checks in acquire are invoked before
	151	+ * enqueuing, a newly acquiring thread may <em>barge</em> ahead of
	152	+ * others that are blocked and queued. However, you can, if desired,
	153	+ * define <tt>tryAcquire</tt> and/or <tt>tryAcquireShared</tt> to
	154	+ * disable barging by internally invoking one or more of the inspection
	155	+ * methods, thereby providing a <em>fair</em> FIFO acquisition order.
	156	+ * In particular, most fair synchronizers can define <tt>tryAcquire</tt>
	157	+ * to return <tt>false</tt> if {@link #hasQueuedPredecessors} (a method
	158	+ * specifically designed to be used by fair synchronizers) returns
	159	+ * <tt>true</tt>. Other variations are possible.
	160	+ *
	161	+ * <p>Throughput and scalability are generally highest for the
	162	+ * default barging (also known as <em>greedy</em>,
	163	+ * <em>renouncement</em>, and <em>convoy-avoidance</em>) strategy.
	164	+ * While this is not guaranteed to be fair or starvation-free, earlier
	165	+ * queued threads are allowed to recontend before later queued
	166	+ * threads, and each recontention has an unbiased chance to succeed
	167	+ * against incoming threads. Also, while acquires do not
	168	+ * "spin" in the usual sense, they may perform multiple
	169	+ * invocations of <tt>tryAcquire</tt> interspersed with other
	170	+ * computations before blocking. This gives most of the benefits of
	171	+ * spins when exclusive synchronization is only briefly held, without
	172	+ * most of the liabilities when it isn't. If so desired, you can
	173	+ * augment this by preceding calls to acquire methods with
	174	+ * "fast-path" checks, possibly prechecking {@link #hasContended}
	175	+ * and/or {@link #hasQueuedThreads} to only do so if the synchronizer
	176	+ * is likely not to be contended.
	177	+ *
	178	+ * <p>This class provides an efficient and scalable basis for
	179	+ * synchronization in part by specializing its range of use to
	180	+ * synchronizers that can rely on <tt>int</tt> state, acquire, and
	181	+ * release parameters, and an internal FIFO wait queue. When this does
	182	+ * not suffice, you can build synchronizers from a lower level using
	183	+ * {@link java.util.concurrent.atomic atomic} classes, your own custom
	184	+ * {@link java.util.Queue} classes, and {@link LockSupport} blocking
	185	+ * support.
	186	+ *
	187	+ * <h3>Usage Examples</h3>
	188	+ *
	189	+ * <p>Here is a non-reentrant mutual exclusion lock class that uses
	190	+ * the value zero to represent the unlocked state, and one to
	191	+ * represent the locked state. While a non-reentrant lock
	192	+ * does not strictly require recording of the current owner
	193	+ * thread, this class does so anyway to make usage easier to monitor.
	194	+ * It also supports conditions and exposes
	195	+ * one of the instrumentation methods:
	196	+ *
	197	+ * <pre>
	198	+ * class Mutex implements Lock, java.io.Serializable {
	199	+ *
	200	+ * // Our internal helper class
	201	+ * private static class Sync extends AbstractQueuedSynchronizer {
	202	+ * // Report whether in locked state
	203	+ * protected boolean isHeldExclusively() {
	204	+ * return getState() == 1;
	205	+ * }
	206	+ *
	207	+ * // Acquire the lock if state is zero
	208	+ * public boolean tryAcquire(int acquires) {
	209	+ * assert acquires == 1; // Otherwise unused
	210	+ * if (compareAndSetState(0, 1)) {
	211	+ * setExclusiveOwnerThread(Thread.currentThread());
	212	+ * return true;
	213	+ * }
	214	+ * return false;
	215	+ * }
	216	+ *
	217	+ * // Release the lock by setting state to zero
	218	+ * protected boolean tryRelease(int releases) {
	219	+ * assert releases == 1; // Otherwise unused
	220	+ * if (getState() == 0) throw new IllegalMonitorStateException();
	221	+ * setExclusiveOwnerThread(null);
	222	+ * setState(0);
	223	+ * return true;
	224	+ * }
	225	+ *
	226	+ * // Provide a Condition
	227	+ * Condition newCondition() { return new ConditionObject(); }
	228	+ *
	229	+ * // Deserialize properly
	230	+ * private void readObject(ObjectInputStream s)
	231	+ * throws IOException, ClassNotFoundException {
	232	+ * s.defaultReadObject();
	233	+ * setState(0); // reset to unlocked state
	234	+ * }
	235	+ * }
	236	+ *
	237	+ * // The sync object does all the hard work. We just forward to it.
	238	+ * private final Sync sync = new Sync();
	239	+ *
	240	+ * public void lock() { sync.acquire(1); }
	241	+ * public boolean tryLock() { return sync.tryAcquire(1); }
	242	+ * public void unlock() { sync.release(1); }
	243	+ * public Condition newCondition() { return sync.newCondition(); }
	244	+ * public boolean isLocked() { return sync.isHeldExclusively(); }
	245	+ * public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
	246	+ * public void lockInterruptibly() throws InterruptedException {
	247	+ * sync.acquireInterruptibly(1);
	248	+ * }
	249	+ * public boolean tryLock(long timeout, TimeUnit unit)
	250	+ * throws InterruptedException {
	251	+ * return sync.tryAcquireNanos(1, unit.toNanos(timeout));
	252	+ * }
	253	+ * }
	254	+ * </pre>
	255	+ *
	256	+ * <p>Here is a latch class that is like a {@link CountDownLatch}
	257	+ * except that it only requires a single <tt>signal</tt> to
	258	+ * fire. Because a latch is non-exclusive, it uses the <tt>shared</tt>
	259	+ * acquire and release methods.
	260	+ *
	261	+ * <pre>
	262	+ * class BooleanLatch {
	263	+ *
	264	+ * private static class Sync extends AbstractQueuedSynchronizer {
	265	+ * boolean isSignalled() { return getState() != 0; }
	266	+ *
	267	+ * protected int tryAcquireShared(int ignore) {
	268	+ * return isSignalled() ? 1 : -1;
	269	+ * }
	270	+ *
	271	+ * protected boolean tryReleaseShared(int ignore) {
	272	+ * setState(1);
	273	+ * return true;
	274	+ * }
	275	+ * }
	276	+ *
	277	+ * private final Sync sync = new Sync();
	278	+ * public boolean isSignalled() { return sync.isSignalled(); }
	279	+ * public void signal() { sync.releaseShared(1); }
	280	+ * public void await() throws InterruptedException {
	281	+ * sync.acquireSharedInterruptibly(1);
	282	+ * }
	283	+ * }
	284	+ * </pre>
	285	+ *
	286	+ * @since 1.5
	287	+ * @author Doug Lea
	288	+ */
	289	+public abstract class AbstractQueuedSynchronizer
	290	+ extends AbstractOwnableSynchronizer
	291	+ implements java.io.Serializable {
	292	+
	293	+ private static final long serialVersionUID = 7373984972572414691L;
	294	+
	295	+ /**
	296	+ * Creates a new <tt>AbstractQueuedSynchronizer</tt> instance
	297	+ * with initial synchronization state of zero.
	298	+ */
	299	+ protected AbstractQueuedSynchronizer() { }
	300	+
	301	+ /**
	302	+ * Wait queue node class.
	303	+ *
	304	+ * <p>The wait queue is a variant of a "CLH" (Craig, Landin, and
	305	+ * Hagersten) lock queue. CLH locks are normally used for
	306	+ * spinlocks. We instead use them for blocking synchronizers, but
	307	+ * use the same basic tactic of holding some of the control
	308	+ * information about a thread in the predecessor of its node. A
	309	+ * "status" field in each node keeps track of whether a thread
	310	+ * should block. A node is signalled when its predecessor
	311	+ * releases. Each node of the queue otherwise serves as a
	312	+ * specific-notification-style monitor holding a single waiting
	313	+ * thread. The status field does NOT control whether threads are
	314	+ * granted locks etc though. A thread may try to acquire if it is
	315	+ * first in the queue. But being first does not guarantee success;
	316	+ * it only gives the right to contend. So the currently released
	317	+ * contender thread may need to rewait.
	318	+ *
	319	+ * <p>To enqueue into a CLH lock, you atomically splice it in as new
	320	+ * tail. To dequeue, you just set the head field.
	321	+ * <pre>
	322	+ * +------+ prev +-----+ +-----+
	323	+ * head \| \| <---- \| \| <---- \| \| tail
	324	+ * +------+ +-----+ +-----+
	325	+ * </pre>
	326	+ *
	327	+ * <p>Insertion into a CLH queue requires only a single atomic
	328	+ * operation on "tail", so there is a simple atomic point of
	329	+ * demarcation from unqueued to queued. Similarly, dequeing
	330	+ * involves only updating the "head". However, it takes a bit
	331	+ * more work for nodes to determine who their successors are,
	332	+ * in part to deal with possible cancellation due to timeouts
	333	+ * and interrupts.
	334	+ *
	335	+ * <p>The "prev" links (not used in original CLH locks), are mainly
	336	+ * needed to handle cancellation. If a node is cancelled, its
	337	+ * successor is (normally) relinked to a non-cancelled
	338	+ * predecessor. For explanation of similar mechanics in the case
	339	+ * of spin locks, see the papers by Scott and Scherer at
	340	+ * http://www.cs.rochester.edu/u/scott/synchronization/
	341	+ *
	342	+ * <p>We also use "next" links to implement blocking mechanics.
	343	+ * The thread id for each node is kept in its own node, so a
	344	+ * predecessor signals the next node to wake up by traversing
	345	+ * next link to determine which thread it is. Determination of
	346	+ * successor must avoid races with newly queued nodes to set
	347	+ * the "next" fields of their predecessors. This is solved
	348	+ * when necessary by checking backwards from the atomically
	349	+ * updated "tail" when a node's successor appears to be null.
	350	+ * (Or, said differently, the next-links are an optimization
	351	+ * so that we don't usually need a backward scan.)
	352	+ *
	353	+ * <p>Cancellation introduces some conservatism to the basic
	354	+ * algorithms. Since we must poll for cancellation of other
	355	+ * nodes, we can miss noticing whether a cancelled node is
	356	+ * ahead or behind us. This is dealt with by always unparking
	357	+ * successors upon cancellation, allowing them to stabilize on
	358	+ * a new predecessor, unless we can identify an uncancelled
	359	+ * predecessor who will carry this responsibility.
	360	+ *
	361	+ * <p>CLH queues need a dummy header node to get started. But
	362	+ * we don't create them on construction, because it would be wasted
	363	+ * effort if there is never contention. Instead, the node
	364	+ * is constructed and head and tail pointers are set upon first
	365	+ * contention.
	366	+ *
	367	+ * <p>Threads waiting on Conditions use the same nodes, but
	368	+ * use an additional link. Conditions only need to link nodes
	369	+ * in simple (non-concurrent) linked queues because they are
	370	+ * only accessed when exclusively held. Upon await, a node is
	371	+ * inserted into a condition queue. Upon signal, the node is
	372	+ * transferred to the main queue. A special value of status
	373	+ * field is used to mark which queue a node is on.
	374	+ *
	375	+ * <p>Thanks go to Dave Dice, Mark Moir, Victor Luchangco, Bill
	376	+ * Scherer and Michael Scott, along with members of JSR-166
	377	+ * expert group, for helpful ideas, discussions, and critiques
	378	+ * on the design of this class.
	379	+ */
	380	+ static final class Node {
	381	+ /** Marker to indicate a node is waiting in shared mode */
	382	+ static final Node SHARED = new Node();
	383	+ /** Marker to indicate a node is waiting in exclusive mode */
	384	+ static final Node EXCLUSIVE = null;
	385	+
	386	+ /** waitStatus value to indicate thread has cancelled */
	387	+ static final int CANCELLED = 1;
	388	+ /** waitStatus value to indicate successor's thread needs unparking */
	389	+ static final int SIGNAL = -1;
	390	+ /** waitStatus value to indicate thread is waiting on condition */
	391	+ static final int CONDITION = -2;
	392	+ /**
	393	+ * waitStatus value to indicate the next acquireShared should
	394	+ * unconditionally propagate
	395	+ */
	396	+ static final int PROPAGATE = -3;
	397	+
	398	+ /**
	399	+ * Status field, taking on only the values:
	400	+ * SIGNAL: The successor of this node is (or will soon be)
	401	+ * blocked (via park), so the current node must
	402	+ * unpark its successor when it releases or
	403	+ * cancels. To avoid races, acquire methods must
	404	+ * first indicate they need a signal,
	405	+ * then retry the atomic acquire, and then,
	406	+ * on failure, block.
	407	+ * CANCELLED: This node is cancelled due to timeout or interrupt.
	408	+ * Nodes never leave this state. In particular,
	409	+ * a thread with cancelled node never again blocks.
	410	+ * CONDITION: This node is currently on a condition queue.
	411	+ * It will not be used as a sync queue node
	412	+ * until transferred, at which time the status
	413	+ * will be set to 0. (Use of this value here has
	414	+ * nothing to do with the other uses of the
	415	+ * field, but simplifies mechanics.)
	416	+ * PROPAGATE: A releaseShared should be propagated to other
	417	+ * nodes. This is set (for head node only) in
	418	+ * doReleaseShared to ensure propagation
	419	+ * continues, even if other operations have
	420	+ * since intervened.
	421	+ * 0: None of the above
	422	+ *
	423	+ * The values are arranged numerically to simplify use.
	424	+ * Non-negative values mean that a node doesn't need to
	425	+ * signal. So, most code doesn't need to check for particular
	426	+ * values, just for sign.
	427	+ *
	428	+ * The field is initialized to 0 for normal sync nodes, and
	429	+ * CONDITION for condition nodes. It is modified using CAS
	430	+ * (or when possible, unconditional volatile writes).
	431	+ */
	432	+ volatile int waitStatus;
	433	+
	434	+ /**
	435	+ * Link to predecessor node that current node/thread relies on
	436	+ * for checking waitStatus. Assigned during enqueing, and nulled
	437	+ * out (for sake of GC) only upon dequeuing. Also, upon
	438	+ * cancellation of a predecessor, we short-circuit while
	439	+ * finding a non-cancelled one, which will always exist
	440	+ * because the head node is never cancelled: A node becomes
	441	+ * head only as a result of successful acquire. A
	442	+ * cancelled thread never succeeds in acquiring, and a thread only
	443	+ * cancels itself, not any other node.
	444	+ */
	445	+ volatile Node prev;
	446	+
	447	+ /**
	448	+ * Link to the successor node that the current node/thread
	449	+ * unparks upon release. Assigned during enqueuing, adjusted
	450	+ * when bypassing cancelled predecessors, and nulled out (for
	451	+ * sake of GC) when dequeued. The enq operation does not
	452	+ * assign next field of a predecessor until after attachment,
	453	+ * so seeing a null next field does not necessarily mean that
	454	+ * node is at end of queue. However, if a next field appears
	455	+ * to be null, we can scan prev's from the tail to
	456	+ * double-check. The next field of cancelled nodes is set to
	457	+ * point to the node itself instead of null, to make life
	458	+ * easier for isOnSyncQueue.
	459	+ */
	460	+ volatile Node next;
	461	+
	462	+ /**
	463	+ * The thread that enqueued this node. Initialized on
	464	+ * construction and nulled out after use.
	465	+ */
	466	+ volatile Thread thread;
	467	+
	468	+ /**
	469	+ * Link to next node waiting on condition, or the special
	470	+ * value SHARED. Because condition queues are accessed only
	471	+ * when holding in exclusive mode, we just need a simple
	472	+ * linked queue to hold nodes while they are waiting on
	473	+ * conditions. They are then transferred to the queue to
	474	+ * re-acquire. And because conditions can only be exclusive,
	475	+ * we save a field by using special value to indicate shared
	476	+ * mode.
	477	+ */
	478	+ Node nextWaiter;
	479	+
	480	+ /**
	481	+ * Returns true if node is waiting in shared mode
	482	+ */
	483	+ final boolean isShared() {
	484	+ return nextWaiter == SHARED;
	485	+ }
	486	+
	487	+ /**
	488	+ * Returns previous node, or throws NullPointerException if null.
	489	+ * Use when predecessor cannot be null. The null check could
	490	+ * be elided, but is present to help the VM.
	491	+ *
	492	+ * @return the predecessor of this node
	493	+ */
	494	+ final Node predecessor() throws NullPointerException {
	495	+ Node p = prev;
	496	+ if (p == null)
	497	+ throw new NullPointerException();
	498	+ else
	499	+ return p;
	500	+ }
	501	+
	502	+ Node() { // Used to establish initial head or SHARED marker
	503	+ }
	504	+
	505	+ Node(Thread thread, Node mode) { // Used by addWaiter
	506	+ this.nextWaiter = mode;
	507	+ this.thread = thread;
	508	+ }
	509	+
	510	+ Node(Thread thread, int waitStatus) { // Used by Condition
	511	+ this.waitStatus = waitStatus;
	512	+ this.thread = thread;
	513	+ }
	514	+ }
	515	+
	516	+ /**
	517	+ * Head of the wait queue, lazily initialized. Except for
	518	+ * initialization, it is modified only via method setHead. Note:
	519	+ * If head exists, its waitStatus is guaranteed not to be
	520	+ * CANCELLED.
	521	+ */
	522	+ private transient volatile Node head;
	523	+
	524	+ /**
	525	+ * Tail of the wait queue, lazily initialized. Modified only via
	526	+ * method enq to add new wait node.
	527	+ */
	528	+ private transient volatile Node tail;
	529	+
	530	+ /**
	531	+ * The synchronization state.
	532	+ */
	533	+ private volatile int state;
	534	+
	535	+ /**
	536	+ * Returns the current value of synchronization state.
	537	+ * This operation has memory semantics of a <tt>volatile</tt> read.
	538	+ * @return current state value
	539	+ */
	540	+ protected final int getState() {
	541	+ return state;
	542	+ }
	543	+
	544	+ /**
	545	+ * Sets the value of synchronization state.
	546	+ * This operation has memory semantics of a <tt>volatile</tt> write.
	547	+ * @param newState the new state value
	548	+ */
	549	+ protected final void setState(int newState) {
	550	+ state = newState;
	551	+ }
	552	+
	553	+ /**
	554	+ * Atomically sets synchronization state to the given updated
	555	+ * value if the current state value equals the expected value.
	556	+ * This operation has memory semantics of a <tt>volatile</tt> read
	557	+ * and write.
	558	+ *
	559	+ * @param expect the expected value
	560	+ * @param update the new value
	561	+ * @return true if successful. False return indicates that the actual
	562	+ * value was not equal to the expected value.
	563	+ */
	564	+ protected final boolean compareAndSetState(int expect, int update) {
	565	+ // See below for intrinsics setup to support this
	566	+ return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
	567	+ }
	568	+
	569	+ // Queuing utilities
	570	+
	571	+ /**
	572	+ * The number of nanoseconds for which it is faster to spin
	573	+ * rather than to use timed park. A rough estimate suffices
	574	+ * to improve responsiveness with very short timeouts.
	575	+ */
	576	+ static final long spinForTimeoutThreshold = 1000L;
	577	+
	578	+ /**
	579	+ * Inserts node into queue, initializing if necessary. See picture above.
	580	+ * @param node the node to insert
	581	+ * @return node's predecessor
	582	+ */
	583	+ private Node enq(final Node node) {
	584	+ for (;;) {
	585	+ Node t = tail;
	586	+ if (t == null) { // Must initialize
	587	+ if (compareAndSetHead(new Node()))
	588	+ tail = head;
	589	+ } else {
	590	+ node.prev = t;
	591	+ if (compareAndSetTail(t, node)) {
	592	+ t.next = node;
	593	+ return t;
	594	+ }
	595	+ }
	596	+ }
	597	+ }
	598	+
	599	+ /**
	600	+ * Creates and enqueues node for current thread and given mode.
	601	+ *
	602	+ * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
	603	+ * @return the new node
	604	+ */
	605	+ private Node addWaiter(Node mode) {
	606	+ Node node = new Node(Thread.currentThread(), mode);
	607	+ // Try the fast path of enq; backup to full enq on failure
	608	+ Node pred = tail;
	609	+ if (pred != null) {
	610	+ node.prev = pred;
	611	+ if (compareAndSetTail(pred, node)) {
	612	+ pred.next = node;
	613	+ return node;
	614	+ }
	615	+ }
	616	+ enq(node);
	617	+ return node;
	618	+ }
	619	+
	620	+ /**
	621	+ * Sets head of queue to be node, thus dequeuing. Called only by
	622	+ * acquire methods. Also nulls out unused fields for sake of GC
	623	+ * and to suppress unnecessary signals and traversals.
	624	+ *
	625	+ * @param node the node
	626	+ */
	627	+ private void setHead(Node node) {
	628	+ head = node;
	629	+ node.thread = null;
	630	+ node.prev = null;
	631	+ }
	632	+
	633	+ /**
	634	+ * Wakes up node's successor, if one exists.
	635	+ *
	636	+ * @param node the node
	637	+ */
	638	+ private void unparkSuccessor(Node node) {
	639	+ /*
	640	+ * If status is negative (i.e., possibly needing signal) try
	641	+ * to clear in anticipation of signalling. It is OK if this
	642	+ * fails or if status is changed by waiting thread.
	643	+ */
	644	+ int ws = node.waitStatus;
	645	+ if (ws < 0)
	646	+ compareAndSetWaitStatus(node, ws, 0);
	647	+
	648	+ /*
	649	+ * Thread to unpark is held in successor, which is normally
	650	+ * just the next node. But if cancelled or apparently null,
	651	+ * traverse backwards from tail to find the actual
	652	+ * non-cancelled successor.
	653	+ */
	654	+ Node s = node.next;
	655	+ if (s == null \|\| s.waitStatus > 0) {
	656	+ s = null;
	657	+ for (Node t = tail; t != null && t != node; t = t.prev)
	658	+ if (t.waitStatus <= 0)
	659	+ s = t;
	660	+ }
	661	+ if (s != null)
	662	+ LockSupport.unpark(s.thread);
	663	+ }
	664	+
	665	+ /**
	666	+ * Release action for shared mode -- signal successor and ensure
	667	+ * propagation. (Note: For exclusive mode, release just amounts
	668	+ * to calling unparkSuccessor of head if it needs signal.)
	669	+ */
	670	+ private void doReleaseShared() {
	671	+ /*
	672	+ * Ensure that a release propagates, even if there are other
	673	+ * in-progress acquires/releases. This proceeds in the usual
	674	+ * way of trying to unparkSuccessor of head if it needs
	675	+ * signal. But if it does not, status is set to PROPAGATE to
	676	+ * ensure that upon release, propagation continues.
	677	+ * Additionally, we must loop in case a new node is added
	678	+ * while we are doing this. Also, unlike other uses of
	679	+ * unparkSuccessor, we need to know if CAS to reset status
	680	+ * fails, if so rechecking.
	681	+ */
	682	+ for (;;) {
	683	+ Node h = head;
	684	+ if (h != null && h != tail) {
	685	+ int ws = h.waitStatus;
	686	+ if (ws == Node.SIGNAL) {
	687	+ if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
	688	+ continue; // loop to recheck cases
	689	+ unparkSuccessor(h);
	690	+ }
	691	+ else if (ws == 0 &&
	692	+ !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
	693	+ continue; // loop on failed CAS
	694	+ }
	695	+ if (h == head) // loop if head changed
	696	+ break;
	697	+ }
	698	+ }
	699	+
	700	+ /**
	701	+ * Sets head of queue, and checks if successor may be waiting
	702	+ * in shared mode, if so propagating if either propagate > 0 or
	703	+ * PROPAGATE status was set.
	704	+ *
	705	+ * @param node the node
	706	+ * @param propagate the return value from a tryAcquireShared
	707	+ */
	708	+ private void setHeadAndPropagate(Node node, int propagate) {
	709	+ Node h = head; // Record old head for check below
	710	+ setHead(node);
	711	+ /*
	712	+ * Try to signal next queued node if:
	713	+ * Propagation was indicated by caller,
	714	+ * or was recorded (as h.waitStatus) by a previous operation
	715	+ * (note: this uses sign-check of waitStatus because
	716	+ * PROPAGATE status may transition to SIGNAL.)
	717	+ * and
	718	+ * The next node is waiting in shared mode,
	719	+ * or we don't know, because it appears null
	720	+ *
	721	+ * The conservatism in both of these checks may cause
	722	+ * unnecessary wake-ups, but only when there are multiple
	723	+ * racing acquires/releases, so most need signals now or soon
	724	+ * anyway.
	725	+ */
	726	+ if (propagate > 0 \|\| h == null \|\| h.waitStatus < 0) {
	727	+ Node s = node.next;
	728	+ if (s == null \|\| s.isShared())
	729	+ doReleaseShared();
	730	+ }
	731	+ }
	732	+
	733	+ // Utilities for various versions of acquire
	734	+
	735	+ /**
	736	+ * Cancels an ongoing attempt to acquire.
	737	+ *
	738	+ * @param node the node
	739	+ */
	740	+ private void cancelAcquire(Node node) {
	741	+ // Ignore if node doesn't exist
	742	+ if (node == null)
	743	+ return;
	744	+
	745	+ node.thread = null;
	746	+
	747	+ // Skip cancelled predecessors
	748	+ Node pred = node.prev;
	749	+ while (pred.waitStatus > 0)
	750	+ node.prev = pred = pred.prev;
	751	+
	752	+ // predNext is the apparent node to unsplice. CASes below will
	753	+ // fail if not, in which case, we lost race vs another cancel
	754	+ // or signal, so no further action is necessary.
	755	+ Node predNext = pred.next;
	756	+
	757	+ // Can use unconditional write instead of CAS here.
	758	+ // After this atomic step, other Nodes can skip past us.
	759	+ // Before, we are free of interference from other threads.
	760	+ node.waitStatus = Node.CANCELLED;
	761	+
	762	+ // If we are the tail, remove ourselves.
	763	+ if (node == tail && compareAndSetTail(node, pred)) {
	764	+ compareAndSetNext(pred, predNext, null);
	765	+ } else {
	766	+ // If successor needs signal, try to set pred's next-link
	767	+ // so it will get one. Otherwise wake it up to propagate.
	768	+ int ws;
	769	+ if (pred != head &&
	770	+ ((ws = pred.waitStatus) == Node.SIGNAL \|\|
	771	+ (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
	772	+ pred.thread != null) {
	773	+ Node next = node.next;
	774	+ if (next != null && next.waitStatus <= 0)
	775	+ compareAndSetNext(pred, predNext, next);
	776	+ } else {
	777	+ unparkSuccessor(node);
	778	+ }
	779	+
	780	+ node.next = node; // help GC
	781	+ }
	782	+ }
	783	+
	784	+ /**
	785	+ * Checks and updates status for a node that failed to acquire.
	786	+ * Returns true if thread should block. This is the main signal
	787	+ * control in all acquire loops. Requires that pred == node.prev
	788	+ *
	789	+ * @param pred node's predecessor holding status
	790	+ * @param node the node
	791	+ * @return {@code true} if thread should block
	792	+ */
	793	+ private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	794	+ int ws = pred.waitStatus;
	795	+ if (ws == Node.SIGNAL)
	796	+ /*
	797	+ * This node has already set status asking a release
	798	+ * to signal it, so it can safely park.
	799	+ */
	800	+ return true;
	801	+ if (ws > 0) {
	802	+ /*
	803	+ * Predecessor was cancelled. Skip over predecessors and
	804	+ * indicate retry.
	805	+ */
	806	+ do {
	807	+ node.prev = pred = pred.prev;
	808	+ } while (pred.waitStatus > 0);
	809	+ pred.next = node;
	810	+ } else {
	811	+ /*
	812	+ * waitStatus must be 0 or PROPAGATE. Indicate that we
	813	+ * need a signal, but don't park yet. Caller will need to
	814	+ * retry to make sure it cannot acquire before parking.
	815	+ */
	816	+ compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
	817	+ }
	818	+ return false;
	819	+ }
	820	+
	821	+ /**
	822	+ * Convenience method to interrupt current thread.
	823	+ */
	824	+ private static void selfInterrupt() {
	825	+ Thread.currentThread().interrupt();
	826	+ }
	827	+
	828	+ /**
	829	+ * Convenience method to park and then check if interrupted
	830	+ *
	831	+ * @return {@code true} if interrupted
	832	+ */
	833	+ private final boolean parkAndCheckInterrupt() {
	834	+ LockSupport.park(this);
	835	+ return Thread.interrupted();
	836	+ }
	837	+
	838	+ /*
	839	+ * Various flavors of acquire, varying in exclusive/shared and
	840	+ * control modes. Each is mostly the same, but annoyingly
	841	+ * different. Only a little bit of factoring is possible due to
	842	+ * interactions of exception mechanics (including ensuring that we
	843	+ * cancel if tryAcquire throws exception) and other control, at
	844	+ * least not without hurting performance too much.
	845	+ */
	846	+
	847	+ /**
	848	+ * Acquires in exclusive uninterruptible mode for thread already in
	849	+ * queue. Used by condition wait methods as well as acquire.
	850	+ *
	851	+ * @param node the node
	852	+ * @param arg the acquire argument
	853	+ * @return {@code true} if interrupted while waiting
	854	+ */
	855	+ final boolean acquireQueued(final Node node, int arg) {
	856	+ boolean failed = true;
	857	+ try {
	858	+ boolean interrupted = false;
	859	+ for (;;) {
	860	+ final Node p = node.predecessor();
	861	+ if (p == head && tryAcquire(arg)) {
	862	+ setHead(node);
	863	+ p.next = null; // help GC
	864	+ failed = false;
	865	+ return interrupted;
	866	+ }
	867	+ if (shouldParkAfterFailedAcquire(p, node) &&
	868	+ parkAndCheckInterrupt())
	869	+ interrupted = true;
	870	+ }
	871	+ } finally {
	872	+ if (failed)
	873	+ cancelAcquire(node);
	874	+ }
	875	+ }
	876	+
	877	+ /**
	878	+ * Acquires in exclusive interruptible mode.
	879	+ * @param arg the acquire argument
	880	+ */
	881	+ private void doAcquireInterruptibly(int arg)
	882	+ throws InterruptedException {
	883	+ final Node node = addWaiter(Node.EXCLUSIVE);
	884	+ boolean failed = true;
	885	+ try {
	886	+ for (;;) {
	887	+ final Node p = node.predecessor();
	888	+ if (p == head && tryAcquire(arg)) {
	889	+ setHead(node);
	890	+ p.next = null; // help GC
	891	+ failed = false;
	892	+ return;
	893	+ }
	894	+ if (shouldParkAfterFailedAcquire(p, node) &&
	895	+ parkAndCheckInterrupt())
	896	+ throw new InterruptedException();
	897	+ }
	898	+ } finally {
	899	+ if (failed)
	900	+ cancelAcquire(node);
	901	+ }
	902	+ }
	903	+
	904	+ /**
	905	+ * Acquires in exclusive timed mode.
	906	+ *
	907	+ * @param arg the acquire argument
	908	+ * @param nanosTimeout max wait time
	909	+ * @return {@code true} if acquired
	910	+ */
	911	+ private boolean doAcquireNanos(int arg, long nanosTimeout)
	912	+ throws InterruptedException {
	913	+ long lastTime = System.nanoTime();
	914	+ final Node node = addWaiter(Node.EXCLUSIVE);
	915	+ boolean failed = true;
	916	+ try {
	917	+ for (;;) {
	918	+ final Node p = node.predecessor();
	919	+ if (p == head && tryAcquire(arg)) {
	920	+ setHead(node);
	921	+ p.next = null; // help GC
	922	+ failed = false;
	923	+ return true;
	924	+ }
	925	+ if (nanosTimeout <= 0)
	926	+ return false;
	927	+ if (shouldParkAfterFailedAcquire(p, node) &&
	928	+ nanosTimeout > spinForTimeoutThreshold)
	929	+ LockSupport.parkNanos(this, nanosTimeout);
	930	+ long now = System.nanoTime();
	931	+ nanosTimeout -= now - lastTime;
	932	+ lastTime = now;
	933	+ if (Thread.interrupted())
	934	+ throw new InterruptedException();
	935	+ }
	936	+ } finally {
	937	+ if (failed)
	938	+ cancelAcquire(node);
	939	+ }
	940	+ }
	941	+
	942	+ /**
	943	+ * Acquires in shared uninterruptible mode.
	944	+ * @param arg the acquire argument
	945	+ */
	946	+ private void doAcquireShared(int arg) {
	947	+ final Node node = addWaiter(Node.SHARED);
	948	+ boolean failed = true;
	949	+ try {
	950	+ boolean interrupted = false;
	951	+ for (;;) {
	952	+ final Node p = node.predecessor();
	953	+ if (p == head) {
	954	+ int r = tryAcquireShared(arg);
	955	+ if (r >= 0) {
	956	+ setHeadAndPropagate(node, r);
	957	+ p.next = null; // help GC
	958	+ if (interrupted)
	959	+ selfInterrupt();
	960	+ failed = false;
	961	+ return;
	962	+ }
	963	+ }
	964	+ if (shouldParkAfterFailedAcquire(p, node) &&
	965	+ parkAndCheckInterrupt())
	966	+ interrupted = true;
	967	+ }
	968	+ } finally {
	969	+ if (failed)
	970	+ cancelAcquire(node);
	971	+ }
	972	+ }
	973	+
	974	+ /**
	975	+ * Acquires in shared interruptible mode.
	976	+ * @param arg the acquire argument
	977	+ */
	978	+ private void doAcquireSharedInterruptibly(int arg)
	979	+ throws InterruptedException {
	980	+ final Node node = addWaiter(Node.SHARED);
	981	+ boolean failed = true;
	982	+ try {
	983	+ for (;;) {
	984	+ final Node p = node.predecessor();
	985	+ if (p == head) {
	986	+ int r = tryAcquireShared(arg);
	987	+ if (r >= 0) {
	988	+ setHeadAndPropagate(node, r);
	989	+ p.next = null; // help GC
	990	+ failed = false;
	991	+ return;
	992	+ }
	993	+ }
	994	+ if (shouldParkAfterFailedAcquire(p, node) &&
	995	+ parkAndCheckInterrupt())
	996	+ throw new InterruptedException();
	997	+ }
	998	+ } finally {
	999	+ if (failed)
	1000	+ cancelAcquire(node);
	1001	+ }
	1002	+ }
	1003	+
	1004	+ /**
	1005	+ * Acquires in shared timed mode.
	1006	+ *
	1007	+ * @param arg the acquire argument
	1008	+ * @param nanosTimeout max wait time
	1009	+ * @return {@code true} if acquired
	1010	+ */
	1011	+ private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
	1012	+ throws InterruptedException {
	1013	+
	1014	+ long lastTime = System.nanoTime();
	1015	+ final Node node = addWaiter(Node.SHARED);
	1016	+ boolean failed = true;
	1017	+ try {
	1018	+ for (;;) {
	1019	+ final Node p = node.predecessor();
	1020	+ if (p == head) {
	1021	+ int r = tryAcquireShared(arg);
	1022	+ if (r >= 0) {
	1023	+ setHeadAndPropagate(node, r);
	1024	+ p.next = null; // help GC
	1025	+ failed = false;
	1026	+ return true;
	1027	+ }
	1028	+ }
	1029	+ if (nanosTimeout <= 0)
	1030	+ return false;
	1031	+ if (shouldParkAfterFailedAcquire(p, node) &&
	1032	+ nanosTimeout > spinForTimeoutThreshold)
	1033	+ LockSupport.parkNanos(this, nanosTimeout);
	1034	+ long now = System.nanoTime();
	1035	+ nanosTimeout -= now - lastTime;
	1036	+ lastTime = now;
	1037	+ if (Thread.interrupted())
	1038	+ throw new InterruptedException();
	1039	+ }
	1040	+ } finally {
	1041	+ if (failed)
	1042	+ cancelAcquire(node);
	1043	+ }
	1044	+ }
	1045	+
	1046	+ // Main exported methods
	1047	+
	1048	+ /**
	1049	+ * Attempts to acquire in exclusive mode. This method should query
	1050	+ * if the state of the object permits it to be acquired in the
	1051	+ * exclusive mode, and if so to acquire it.
	1052	+ *
	1053	+ * <p>This method is always invoked by the thread performing
	1054	+ * acquire. If this method reports failure, the acquire method
	1055	+ * may queue the thread, if it is not already queued, until it is
	1056	+ * signalled by a release from some other thread. This can be used
	1057	+ * to implement method {@link Lock#tryLock()}.
	1058	+ *
	1059	+ * <p>The default
	1060	+ * implementation throws {@link UnsupportedOperationException}.
	1061	+ *
	1062	+ * @param arg the acquire argument. This value is always the one
	1063	+ * passed to an acquire method, or is the value saved on entry
	1064	+ * to a condition wait. The value is otherwise uninterpreted
	1065	+ * and can represent anything you like.
	1066	+ * @return {@code true} if successful. Upon success, this object has
	1067	+ * been acquired.
	1068	+ * @throws IllegalMonitorStateException if acquiring would place this
	1069	+ * synchronizer in an illegal state. This exception must be
	1070	+ * thrown in a consistent fashion for synchronization to work
	1071	+ * correctly.
	1072	+ * @throws UnsupportedOperationException if exclusive mode is not supported
	1073	+ */
	1074	+ protected boolean tryAcquire(int arg) {
	1075	+ throw new UnsupportedOperationException();
	1076	+ }
	1077	+
	1078	+ /**
	1079	+ * Attempts to set the state to reflect a release in exclusive
	1080	+ * mode.
	1081	+ *
	1082	+ * <p>This method is always invoked by the thread performing release.
	1083	+ *
	1084	+ * <p>The default implementation throws
	1085	+ * {@link UnsupportedOperationException}.
	1086	+ *
	1087	+ * @param arg the release argument. This value is always the one
	1088	+ * passed to a release method, or the current state value upon
	1089	+ * entry to a condition wait. The value is otherwise
	1090	+ * uninterpreted and can represent anything you like.
	1091	+ * @return {@code true} if this object is now in a fully released
	1092	+ * state, so that any waiting threads may attempt to acquire;
	1093	+ * and {@code false} otherwise.
	1094	+ * @throws IllegalMonitorStateException if releasing would place this
	1095	+ * synchronizer in an illegal state. This exception must be
	1096	+ * thrown in a consistent fashion for synchronization to work
	1097	+ * correctly.
	1098	+ * @throws UnsupportedOperationException if exclusive mode is not supported
	1099	+ */
	1100	+ protected boolean tryRelease(int arg) {
	1101	+ throw new UnsupportedOperationException();
	1102	+ }
	1103	+
	1104	+ /**
	1105	+ * Attempts to acquire in shared mode. This method should query if
	1106	+ * the state of the object permits it to be acquired in the shared
	1107	+ * mode, and if so to acquire it.
	1108	+ *
	1109	+ * <p>This method is always invoked by the thread performing
	1110	+ * acquire. If this method reports failure, the acquire method
	1111	+ * may queue the thread, if it is not already queued, until it is
	1112	+ * signalled by a release from some other thread.
	1113	+ *
	1114	+ * <p>The default implementation throws {@link
	1115	+ * UnsupportedOperationException}.
	1116	+ *
	1117	+ * @param arg the acquire argument. This value is always the one
	1118	+ * passed to an acquire method, or is the value saved on entry
	1119	+ * to a condition wait. The value is otherwise uninterpreted
	1120	+ * and can represent anything you like.
	1121	+ * @return a negative value on failure; zero if acquisition in shared
	1122	+ * mode succeeded but no subsequent shared-mode acquire can
	1123	+ * succeed; and a positive value if acquisition in shared
	1124	+ * mode succeeded and subsequent shared-mode acquires might
	1125	+ * also succeed, in which case a subsequent waiting thread
	1126	+ * must check availability. (Support for three different
	1127	+ * return values enables this method to be used in contexts
	1128	+ * where acquires only sometimes act exclusively.) Upon
	1129	+ * success, this object has been acquired.
	1130	+ * @throws IllegalMonitorStateException if acquiring would place this
	1131	+ * synchronizer in an illegal state. This exception must be
	1132	+ * thrown in a consistent fashion for synchronization to work
	1133	+ * correctly.
	1134	+ * @throws UnsupportedOperationException if shared mode is not supported
	1135	+ */
	1136	+ protected int tryAcquireShared(int arg) {
	1137	+ throw new UnsupportedOperationException();
	1138	+ }
	1139	+
	1140	+ /**
	1141	+ * Attempts to set the state to reflect a release in shared mode.
	1142	+ *
	1143	+ * <p>This method is always invoked by the thread performing release.
	1144	+ *
	1145	+ * <p>The default implementation throws
	1146	+ * {@link UnsupportedOperationException}.
	1147	+ *
	1148	+ * @param arg the release argument. This value is always the one
	1149	+ * passed to a release method, or the current state value upon
	1150	+ * entry to a condition wait. The value is otherwise
	1151	+ * uninterpreted and can represent anything you like.
	1152	+ * @return {@code true} if this release of shared mode may permit a
	1153	+ * waiting acquire (shared or exclusive) to succeed; and
	1154	+ * {@code false} otherwise
	1155	+ * @throws IllegalMonitorStateException if releasing would place this
	1156	+ * synchronizer in an illegal state. This exception must be
	1157	+ * thrown in a consistent fashion for synchronization to work
	1158	+ * correctly.
	1159	+ * @throws UnsupportedOperationException if shared mode is not supported
	1160	+ */
	1161	+ protected boolean tryReleaseShared(int arg) {
	1162	+ throw new UnsupportedOperationException();
	1163	+ }
	1164	+
	1165	+ /**
	1166	+ * Returns {@code true} if synchronization is held exclusively with
	1167	+ * respect to the current (calling) thread. This method is invoked
	1168	+ * upon each call to a non-waiting {@link ConditionObject} method.
	1169	+ * (Waiting methods instead invoke {@link #release}.)
	1170	+ *
	1171	+ * <p>The default implementation throws {@link
	1172	+ * UnsupportedOperationException}. This method is invoked
	1173	+ * internally only within {@link ConditionObject} methods, so need
	1174	+ * not be defined if conditions are not used.
	1175	+ *
	1176	+ * @return {@code true} if synchronization is held exclusively;
	1177	+ * {@code false} otherwise
	1178	+ * @throws UnsupportedOperationException if conditions are not supported
	1179	+ */
	1180	+ protected boolean isHeldExclusively() {
	1181	+ throw new UnsupportedOperationException();
	1182	+ }
	1183	+
	1184	+ /**
	1185	+ * Acquires in exclusive mode, ignoring interrupts. Implemented
	1186	+ * by invoking at least once {@link #tryAcquire},
	1187	+ * returning on success. Otherwise the thread is queued, possibly
	1188	+ * repeatedly blocking and unblocking, invoking {@link
	1189	+ * #tryAcquire} until success. This method can be used
	1190	+ * to implement method {@link Lock#lock}.
	1191	+ *
	1192	+ * @param arg the acquire argument. This value is conveyed to
	1193	+ * {@link #tryAcquire} but is otherwise uninterpreted and
	1194	+ * can represent anything you like.
	1195	+ */
	1196	+ public final void acquire(int arg) {
	1197	+ if (!tryAcquire(arg) &&
	1198	+ acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
	1199	+ selfInterrupt();
	1200	+ }
	1201	+
	1202	+ /**
	1203	+ * Acquires in exclusive mode, aborting if interrupted.
	1204	+ * Implemented by first checking interrupt status, then invoking
	1205	+ * at least once {@link #tryAcquire}, returning on
	1206	+ * success. Otherwise the thread is queued, possibly repeatedly
	1207	+ * blocking and unblocking, invoking {@link #tryAcquire}
	1208	+ * until success or the thread is interrupted. This method can be
	1209	+ * used to implement method {@link Lock#lockInterruptibly}.
	1210	+ *
	1211	+ * @param arg the acquire argument. This value is conveyed to
	1212	+ * {@link #tryAcquire} but is otherwise uninterpreted and
	1213	+ * can represent anything you like.
	1214	+ * @throws InterruptedException if the current thread is interrupted
	1215	+ */
	1216	+ public final void acquireInterruptibly(int arg)
	1217	+ throws InterruptedException {
	1218	+ if (Thread.interrupted())
	1219	+ throw new InterruptedException();
	1220	+ if (!tryAcquire(arg))
	1221	+ doAcquireInterruptibly(arg);
	1222	+ }
	1223	+
	1224	+ /**
	1225	+ * Attempts to acquire in exclusive mode, aborting if interrupted,
	1226	+ * and failing if the given timeout elapses. Implemented by first
	1227	+ * checking interrupt status, then invoking at least once {@link
	1228	+ * #tryAcquire}, returning on success. Otherwise, the thread is
	1229	+ * queued, possibly repeatedly blocking and unblocking, invoking
	1230	+ * {@link #tryAcquire} until success or the thread is interrupted
	1231	+ * or the timeout elapses. This method can be used to implement
	1232	+ * method {@link Lock#tryLock(long, TimeUnit)}.
	1233	+ *
	1234	+ * @param arg the acquire argument. This value is conveyed to
	1235	+ * {@link #tryAcquire} but is otherwise uninterpreted and
	1236	+ * can represent anything you like.
	1237	+ * @param nanosTimeout the maximum number of nanoseconds to wait
	1238	+ * @return {@code true} if acquired; {@code false} if timed out
	1239	+ * @throws InterruptedException if the current thread is interrupted
	1240	+ */
	1241	+ public final boolean tryAcquireNanos(int arg, long nanosTimeout)
	1242	+ throws InterruptedException {
	1243	+ if (Thread.interrupted())
	1244	+ throw new InterruptedException();
	1245	+ return tryAcquire(arg) \|\|
	1246	+ doAcquireNanos(arg, nanosTimeout);
	1247	+ }
	1248	+
	1249	+ /**
	1250	+ * Releases in exclusive mode. Implemented by unblocking one or
	1251	+ * more threads if {@link #tryRelease} returns true.
	1252	+ * This method can be used to implement method {@link Lock#unlock}.
	1253	+ *
	1254	+ * @param arg the release argument. This value is conveyed to
	1255	+ * {@link #tryRelease} but is otherwise uninterpreted and
	1256	+ * can represent anything you like.
	1257	+ * @return the value returned from {@link #tryRelease}
	1258	+ */
	1259	+ public final boolean release(int arg) {
	1260	+ if (tryRelease(arg)) {
	1261	+ Node h = head;
	1262	+ if (h != null && h.waitStatus != 0)
	1263	+ unparkSuccessor(h);
	1264	+ return true;
	1265	+ }
	1266	+ return false;
	1267	+ }
	1268	+
	1269	+ /**
	1270	+ * Acquires in shared mode, ignoring interrupts. Implemented by
	1271	+ * first invoking at least once {@link #tryAcquireShared},
	1272	+ * returning on success. Otherwise the thread is queued, possibly
	1273	+ * repeatedly blocking and unblocking, invoking {@link
	1274	+ * #tryAcquireShared} until success.
	1275	+ *
	1276	+ * @param arg the acquire argument. This value is conveyed to
	1277	+ * {@link #tryAcquireShared} but is otherwise uninterpreted
	1278	+ * and can represent anything you like.
	1279	+ */
	1280	+ public final void acquireShared(int arg) {
	1281	+ if (tryAcquireShared(arg) < 0)
	1282	+ doAcquireShared(arg);
	1283	+ }
	1284	+
	1285	+ /**
	1286	+ * Acquires in shared mode, aborting if interrupted. Implemented
	1287	+ * by first checking interrupt status, then invoking at least once
	1288	+ * {@link #tryAcquireShared}, returning on success. Otherwise the
	1289	+ * thread is queued, possibly repeatedly blocking and unblocking,
	1290	+ * invoking {@link #tryAcquireShared} until success or the thread
	1291	+ * is interrupted.
	1292	+ * @param arg the acquire argument
	1293	+ * This value is conveyed to {@link #tryAcquireShared} but is
	1294	+ * otherwise uninterpreted and can represent anything
	1295	+ * you like.
	1296	+ * @throws InterruptedException if the current thread is interrupted
	1297	+ */
	1298	+ public final void acquireSharedInterruptibly(int arg)
	1299	+ throws InterruptedException {
	1300	+ if (Thread.interrupted())
	1301	+ throw new InterruptedException();
	1302	+ if (tryAcquireShared(arg) < 0)
	1303	+ doAcquireSharedInterruptibly(arg);
	1304	+ }
	1305	+
	1306	+ /**
	1307	+ * Attempts to acquire in shared mode, aborting if interrupted, and
	1308	+ * failing if the given timeout elapses. Implemented by first
	1309	+ * checking interrupt status, then invoking at least once {@link
	1310	+ * #tryAcquireShared}, returning on success. Otherwise, the
	1311	+ * thread is queued, possibly repeatedly blocking and unblocking,
	1312	+ * invoking {@link #tryAcquireShared} until success or the thread
	1313	+ * is interrupted or the timeout elapses.
	1314	+ *
	1315	+ * @param arg the acquire argument. This value is conveyed to
	1316	+ * {@link #tryAcquireShared} but is otherwise uninterpreted
	1317	+ * and can represent anything you like.
	1318	+ * @param nanosTimeout the maximum number of nanoseconds to wait
	1319	+ * @return {@code true} if acquired; {@code false} if timed out
	1320	+ * @throws InterruptedException if the current thread is interrupted
	1321	+ */
	1322	+ public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
	1323	+ throws InterruptedException {
	1324	+ if (Thread.interrupted())
	1325	+ throw new InterruptedException();
	1326	+ return tryAcquireShared(arg) >= 0 \|\|
	1327	+ doAcquireSharedNanos(arg, nanosTimeout);
	1328	+ }
	1329	+
	1330	+ /**
	1331	+ * Releases in shared mode. Implemented by unblocking one or more
	1332	+ * threads if {@link #tryReleaseShared} returns true.
	1333	+ *
	1334	+ * @param arg the release argument. This value is conveyed to
	1335	+ * {@link #tryReleaseShared} but is otherwise uninterpreted
	1336	+ * and can represent anything you like.
	1337	+ * @return the value returned from {@link #tryReleaseShared}
	1338	+ */
	1339	+ public final boolean releaseShared(int arg) {
	1340	+ if (tryReleaseShared(arg)) {
	1341	+ doReleaseShared();
	1342	+ return true;
	1343	+ }
	1344	+ return false;
	1345	+ }
	1346	+
	1347	+ // Queue inspection methods
	1348	+
	1349	+ /**
	1350	+ * Queries whether any threads are waiting to acquire. Note that
	1351	+ * because cancellations due to interrupts and timeouts may occur
	1352	+ * at any time, a {@code true} return does not guarantee that any
	1353	+ * other thread will ever acquire.
	1354	+ *
	1355	+ * <p>In this implementation, this operation returns in
	1356	+ * constant time.
	1357	+ *
	1358	+ * @return {@code true} if there may be other threads waiting to acquire
	1359	+ */
	1360	+ public final boolean hasQueuedThreads() {
	1361	+ return head != tail;
	1362	+ }
	1363	+
	1364	+ /**
	1365	+ * Queries whether any threads have ever contended to acquire this
	1366	+ * synchronizer; that is if an acquire method has ever blocked.
	1367	+ *
	1368	+ * <p>In this implementation, this operation returns in
	1369	+ * constant time.
	1370	+ *
	1371	+ * @return {@code true} if there has ever been contention
	1372	+ */
	1373	+ public final boolean hasContended() {
	1374	+ return head != null;
	1375	+ }
	1376	+
	1377	+ /**
	1378	+ * Returns the first (longest-waiting) thread in the queue, or
	1379	+ * {@code null} if no threads are currently queued.
	1380	+ *
	1381	+ * <p>In this implementation, this operation normally returns in
	1382	+ * constant time, but may iterate upon contention if other threads are
	1383	+ * concurrently modifying the queue.
	1384	+ *
	1385	+ * @return the first (longest-waiting) thread in the queue, or
	1386	+ * {@code null} if no threads are currently queued
	1387	+ */
	1388	+ public final Thread getFirstQueuedThread() {
	1389	+ // handle only fast path, else relay
	1390	+ return (head == tail) ? null : fullGetFirstQueuedThread();
	1391	+ }
	1392	+
	1393	+ /**
	1394	+ * Version of getFirstQueuedThread called when fastpath fails
	1395	+ */
	1396	+ private Thread fullGetFirstQueuedThread() {
	1397	+ /*
	1398	+ * The first node is normally head.next. Try to get its
	1399	+ * thread field, ensuring consistent reads: If thread
	1400	+ * field is nulled out or s.prev is no longer head, then
	1401	+ * some other thread(s) concurrently performed setHead in
	1402	+ * between some of our reads. We try this twice before
	1403	+ * resorting to traversal.
	1404	+ */
	1405	+ Node h, s;
	1406	+ Thread st;
	1407	+ if (((h = head) != null && (s = h.next) != null &&
	1408	+ s.prev == head && (st = s.thread) != null) \|\|
	1409	+ ((h = head) != null && (s = h.next) != null &&
	1410	+ s.prev == head && (st = s.thread) != null))
	1411	+ return st;
	1412	+
	1413	+ /*
	1414	+ * Head's next field might not have been set yet, or may have
	1415	+ * been unset after setHead. So we must check to see if tail
	1416	+ * is actually first node. If not, we continue on, safely
	1417	+ * traversing from tail back to head to find first,
	1418	+ * guaranteeing termination.
	1419	+ */
	1420	+
	1421	+ Node t = tail;
	1422	+ Thread firstThread = null;
	1423	+ while (t != null && t != head) {
	1424	+ Thread tt = t.thread;
	1425	+ if (tt != null)
	1426	+ firstThread = tt;
	1427	+ t = t.prev;
	1428	+ }
	1429	+ return firstThread;
	1430	+ }
	1431	+
	1432	+ /**
	1433	+ * Returns true if the given thread is currently queued.
	1434	+ *
	1435	+ * <p>This implementation traverses the queue to determine
	1436	+ * presence of the given thread.
	1437	+ *
	1438	+ * @param thread the thread
	1439	+ * @return {@code true} if the given thread is on the queue
	1440	+ * @throws NullPointerException if the thread is null
	1441	+ */
	1442	+ public final boolean isQueued(Thread thread) {
	1443	+ if (thread == null)
	1444	+ throw new NullPointerException();
	1445	+ for (Node p = tail; p != null; p = p.prev)
	1446	+ if (p.thread == thread)
	1447	+ return true;
	1448	+ return false;
	1449	+ }
	1450	+
	1451	+ /**
	1452	+ * Returns {@code true} if the apparent first queued thread, if one
	1453	+ * exists, is waiting in exclusive mode. If this method returns
	1454	+ * {@code true}, and the current thread is attempting to acquire in
	1455	+ * shared mode (that is, this method is invoked from {@link
	1456	+ * #tryAcquireShared}) then it is guaranteed that the current thread
	1457	+ * is not the first queued thread. Used only as a heuristic in
	1458	+ * ReentrantReadWriteLock.
	1459	+ */
	1460	+ final boolean apparentlyFirstQueuedIsExclusive() {
	1461	+ Node h, s;
	1462	+ return (h = head) != null &&
	1463	+ (s = h.next) != null &&
	1464	+ !s.isShared() &&
	1465	+ s.thread != null;
	1466	+ }
	1467	+
	1468	+ /**
	1469	+ * Queries whether any threads have been waiting to acquire longer
	1470	+ * than the current thread.
	1471	+ *
	1472	+ * <p>An invocation of this method is equivalent to (but may be
	1473	+ * more efficient than):
	1474	+ * <pre> {@code
	1475	+ * getFirstQueuedThread() != Thread.currentThread() &&
	1476	+ * hasQueuedThreads()}</pre>
	1477	+ *
	1478	+ * <p>Note that because cancellations due to interrupts and
	1479	+ * timeouts may occur at any time, a {@code true} return does not
	1480	+ * guarantee that some other thread will acquire before the current
	1481	+ * thread. Likewise, it is possible for another thread to win a
	1482	+ * race to enqueue after this method has returned {@code false},
	1483	+ * due to the queue being empty.
	1484	+ *
	1485	+ * <p>This method is designed to be used by a fair synchronizer to
	1486	+ * avoid <a href="AbstractQueuedSynchronizer#barging">barging</a>.
	1487	+ * Such a synchronizer's {@link #tryAcquire} method should return
	1488	+ * {@code false}, and its {@link #tryAcquireShared} method should
	1489	+ * return a negative value, if this method returns {@code true}
	1490	+ * (unless this is a reentrant acquire). For example, the {@code
	1491	+ * tryAcquire} method for a fair, reentrant, exclusive mode
	1492	+ * synchronizer might look like this:
	1493	+ *
	1494	+ * <pre> {@code
	1495	+ * protected boolean tryAcquire(int arg) {
	1496	+ * if (isHeldExclusively()) {
	1497	+ * // A reentrant acquire; increment hold count
	1498	+ * return true;
	1499	+ * } else if (hasQueuedPredecessors()) {
	1500	+ * return false;
	1501	+ * } else {
	1502	+ * // try to acquire normally
	1503	+ * }
	1504	+ * }}</pre>
	1505	+ *
	1506	+ * @return {@code true} if there is a queued thread preceding the
	1507	+ * current thread, and {@code false} if the current thread
	1508	+ * is at the head of the queue or the queue is empty
	1509	+ * @since 1.7
	1510	+ */
	1511	+ public final boolean hasQueuedPredecessors() {
	1512	+ // The correctness of this depends on head being initialized
	1513	+ // before tail and on head.next being accurate if the current
	1514	+ // thread is first in queue.
	1515	+ Node t = tail; // Read fields in reverse initialization order
	1516	+ Node h = head;
	1517	+ Node s;
	1518	+ return h != t &&
	1519	+ ((s = h.next) == null \|\| s.thread != Thread.currentThread());
	1520	+ }
	1521	+
	1522	+
	1523	+ // Instrumentation and monitoring methods
	1524	+
	1525	+ /**
	1526	+ * Returns an estimate of the number of threads waiting to
	1527	+ * acquire. The value is only an estimate because the number of
	1528	+ * threads may change dynamically while this method traverses
	1529	+ * internal data structures. This method is designed for use in
	1530	+ * monitoring system state, not for synchronization
	1531	+ * control.
	1532	+ *
	1533	+ * @return the estimated number of threads waiting to acquire
	1534	+ */
	1535	+ public final int getQueueLength() {
	1536	+ int n = 0;
	1537	+ for (Node p = tail; p != null; p = p.prev) {
	1538	+ if (p.thread != null)
	1539	+ ++n;
	1540	+ }
	1541	+ return n;
	1542	+ }
	1543	+
	1544	+ /**
	1545	+ * Returns a collection containing threads that may be waiting to
	1546	+ * acquire. Because the actual set of threads may change
	1547	+ * dynamically while constructing this result, the returned
	1548	+ * collection is only a best-effort estimate. The elements of the
	1549	+ * returned collection are in no particular order. This method is
	1550	+ * designed to facilitate construction of subclasses that provide
	1551	+ * more extensive monitoring facilities.
	1552	+ *
	1553	+ * @return the collection of threads
	1554	+ */
	1555	+ public final Collection<Thread> getQueuedThreads() {
	1556	+ ArrayList<Thread> list = new ArrayList<Thread>();
	1557	+ for (Node p = tail; p != null; p = p.prev) {
	1558	+ Thread t = p.thread;
	1559	+ if (t != null)
	1560	+ list.add(t);
	1561	+ }
	1562	+ return list;
	1563	+ }
	1564	+
	1565	+ /**
	1566	+ * Returns a collection containing threads that may be waiting to
	1567	+ * acquire in exclusive mode. This has the same properties
	1568	+ * as {@link #getQueuedThreads} except that it only returns
	1569	+ * those threads waiting due to an exclusive acquire.
	1570	+ *
	1571	+ * @return the collection of threads
	1572	+ */
	1573	+ public final Collection<Thread> getExclusiveQueuedThreads() {
	1574	+ ArrayList<Thread> list = new ArrayList<Thread>();
	1575	+ for (Node p = tail; p != null; p = p.prev) {
	1576	+ if (!p.isShared()) {
	1577	+ Thread t = p.thread;
	1578	+ if (t != null)
	1579	+ list.add(t);
	1580	+ }
	1581	+ }
	1582	+ return list;
	1583	+ }
	1584	+
	1585	+ /**
	1586	+ * Returns a collection containing threads that may be waiting to
	1587	+ * acquire in shared mode. This has the same properties
	1588	+ * as {@link #getQueuedThreads} except that it only returns
	1589	+ * those threads waiting due to a shared acquire.
	1590	+ *
	1591	+ * @return the collection of threads
	1592	+ */
	1593	+ public final Collection<Thread> getSharedQueuedThreads() {
	1594	+ ArrayList<Thread> list = new ArrayList<Thread>();
	1595	+ for (Node p = tail; p != null; p = p.prev) {
	1596	+ if (p.isShared()) {
	1597	+ Thread t = p.thread;
	1598	+ if (t != null)
	1599	+ list.add(t);
	1600	+ }
	1601	+ }
	1602	+ return list;
	1603	+ }
	1604	+
	1605	+ /**
	1606	+ * Returns a string identifying this synchronizer, as well as its state.
	1607	+ * The state, in brackets, includes the String {@code "State ="}
	1608	+ * followed by the current value of {@link #getState}, and either
	1609	+ * {@code "nonempty"} or {@code "empty"} depending on whether the
	1610	+ * queue is empty.
	1611	+ *
	1612	+ * @return a string identifying this synchronizer, as well as its state
	1613	+ */
	1614	+ public String toString() {
	1615	+ int s = getState();
	1616	+ String q = hasQueuedThreads() ? "non" : "";
	1617	+ return super.toString() +
	1618	+ "[State = " + s + ", " + q + "empty queue]";
	1619	+ }
	1620	+
	1621	+
	1622	+ // Internal support methods for Conditions
	1623	+
	1624	+ /**
	1625	+ * Returns true if a node, always one that was initially placed on
	1626	+ * a condition queue, is now waiting to reacquire on sync queue.
	1627	+ * @param node the node
	1628	+ * @return true if is reacquiring
	1629	+ */
	1630	+ final boolean isOnSyncQueue(Node node) {
	1631	+ if (node.waitStatus == Node.CONDITION \|\| node.prev == null)
	1632	+ return false;
	1633	+ if (node.next != null) // If has successor, it must be on queue
	1634	+ return true;
	1635	+ /*
	1636	+ * node.prev can be non-null, but not yet on queue because
	1637	+ * the CAS to place it on queue can fail. So we have to
	1638	+ * traverse from tail to make sure it actually made it. It
	1639	+ * will always be near the tail in calls to this method, and
	1640	+ * unless the CAS failed (which is unlikely), it will be
	1641	+ * there, so we hardly ever traverse much.
	1642	+ */
	1643	+ return findNodeFromTail(node);
	1644	+ }
	1645	+
	1646	+ /**
	1647	+ * Returns true if node is on sync queue by searching backwards from tail.
	1648	+ * Called only when needed by isOnSyncQueue.
	1649	+ * @return true if present
	1650	+ */
	1651	+ private boolean findNodeFromTail(Node node) {
	1652	+ Node t = tail;
	1653	+ for (;;) {
	1654	+ if (t == node)
	1655	+ return true;
	1656	+ if (t == null)
	1657	+ return false;
	1658	+ t = t.prev;
	1659	+ }
	1660	+ }
	1661	+
	1662	+ /**
	1663	+ * Transfers a node from a condition queue onto sync queue.
	1664	+ * Returns true if successful.
	1665	+ * @param node the node
	1666	+ * @return true if successfully transferred (else the node was
	1667	+ * cancelled before signal).
	1668	+ */
	1669	+ final boolean transferForSignal(Node node) {
	1670	+ /*
	1671	+ * If cannot change waitStatus, the node has been cancelled.
	1672	+ */
	1673	+ if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
	1674	+ return false;
	1675	+
	1676	+ /*
	1677	+ * Splice onto queue and try to set waitStatus of predecessor to
	1678	+ * indicate that thread is (probably) waiting. If cancelled or
	1679	+ * attempt to set waitStatus fails, wake up to resync (in which
	1680	+ * case the waitStatus can be transiently and harmlessly wrong).
	1681	+ */
	1682	+ Node p = enq(node);
	1683	+ int ws = p.waitStatus;
	1684	+ if (ws > 0 \|\| !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
	1685	+ LockSupport.unpark(node.thread);
	1686	+ return true;
	1687	+ }
	1688	+
	1689	+ /**
	1690	+ * Transfers node, if necessary, to sync queue after a cancelled
	1691	+ * wait. Returns true if thread was cancelled before being
	1692	+ * signalled.
	1693	+ * @param current the waiting thread
	1694	+ * @param node its node
	1695	+ * @return true if cancelled before the node was signalled
	1696	+ */
	1697	+ final boolean transferAfterCancelledWait(Node node) {
	1698	+ if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
	1699	+ enq(node);
	1700	+ return true;
	1701	+ }
	1702	+ /*
	1703	+ * If we lost out to a signal(), then we can't proceed
	1704	+ * until it finishes its enq(). Cancelling during an
	1705	+ * incomplete transfer is both rare and transient, so just
	1706	+ * spin.
	1707	+ */
	1708	+ while (!isOnSyncQueue(node))
	1709	+ Thread.yield();
	1710	+ return false;
	1711	+ }
	1712	+
	1713	+ /**
	1714	+ * Invokes release with current state value; returns saved state.
	1715	+ * Cancels node and throws exception on failure.
	1716	+ * @param node the condition node for this wait
	1717	+ * @return previous sync state
	1718	+ */
	1719	+ final int fullyRelease(Node node) {
	1720	+ boolean failed = true;
	1721	+ try {
	1722	+ int savedState = getState();
	1723	+ if (release(savedState)) {
	1724	+ failed = false;
	1725	+ return savedState;
	1726	+ } else {
	1727	+ throw new IllegalMonitorStateException();
	1728	+ }
	1729	+ } finally {
	1730	+ if (failed)
	1731	+ node.waitStatus = Node.CANCELLED;
	1732	+ }
	1733	+ }
	1734	+
	1735	+ // Instrumentation methods for conditions
	1736	+
	1737	+ /**
	1738	+ * Queries whether the given ConditionObject
	1739	+ * uses this synchronizer as its lock.
	1740	+ *
	1741	+ * @param condition the condition
	1742	+ * @return <tt>true</tt> if owned
	1743	+ * @throws NullPointerException if the condition is null
	1744	+ */
	1745	+ public final boolean owns(ConditionObject condition) {
	1746	+ if (condition == null)
	1747	+ throw new NullPointerException();
	1748	+ return condition.isOwnedBy(this);
	1749	+ }
	1750	+
	1751	+ /**
	1752	+ * Queries whether any threads are waiting on the given condition
	1753	+ * associated with this synchronizer. Note that because timeouts
	1754	+ * and interrupts may occur at any time, a <tt>true</tt> return
	1755	+ * does not guarantee that a future <tt>signal</tt> will awaken
	1756	+ * any threads. This method is designed primarily for use in
	1757	+ * monitoring of the system state.
	1758	+ *
	1759	+ * @param condition the condition
	1760	+ * @return <tt>true</tt> if there are any waiting threads
	1761	+ * @throws IllegalMonitorStateException if exclusive synchronization
	1762	+ * is not held
	1763	+ * @throws IllegalArgumentException if the given condition is
	1764	+ * not associated with this synchronizer
	1765	+ * @throws NullPointerException if the condition is null
	1766	+ */
	1767	+ public final boolean hasWaiters(ConditionObject condition) {
	1768	+ if (!owns(condition))
	1769	+ throw new IllegalArgumentException("Not owner");
	1770	+ return condition.hasWaiters();
	1771	+ }
	1772	+
	1773	+ /**
	1774	+ * Returns an estimate of the number of threads waiting on the
	1775	+ * given condition associated with this synchronizer. Note that
	1776	+ * because timeouts and interrupts may occur at any time, the
	1777	+ * estimate serves only as an upper bound on the actual number of
	1778	+ * waiters. This method is designed for use in monitoring of the
	1779	+ * system state, not for synchronization control.
	1780	+ *
	1781	+ * @param condition the condition
	1782	+ * @return the estimated number of waiting threads
	1783	+ * @throws IllegalMonitorStateException if exclusive synchronization
	1784	+ * is not held
	1785	+ * @throws IllegalArgumentException if the given condition is
	1786	+ * not associated with this synchronizer
	1787	+ * @throws NullPointerException if the condition is null
	1788	+ */
	1789	+ public final int getWaitQueueLength(ConditionObject condition) {
	1790	+ if (!owns(condition))
	1791	+ throw new IllegalArgumentException("Not owner");
	1792	+ return condition.getWaitQueueLength();
	1793	+ }
	1794	+
	1795	+ /**
	1796	+ * Returns a collection containing those threads that may be
	1797	+ * waiting on the given condition associated with this
	1798	+ * synchronizer. Because the actual set of threads may change
	1799	+ * dynamically while constructing this result, the returned
	1800	+ * collection is only a best-effort estimate. The elements of the
	1801	+ * returned collection are in no particular order.
	1802	+ *
	1803	+ * @param condition the condition
	1804	+ * @return the collection of threads
	1805	+ * @throws IllegalMonitorStateException if exclusive synchronization
	1806	+ * is not held
	1807	+ * @throws IllegalArgumentException if the given condition is
	1808	+ * not associated with this synchronizer
	1809	+ * @throws NullPointerException if the condition is null
	1810	+ */
	1811	+ public final Collection<Thread> getWaitingThreads(ConditionObject condition) {
	1812	+ if (!owns(condition))
	1813	+ throw new IllegalArgumentException("Not owner");
	1814	+ return condition.getWaitingThreads();
	1815	+ }
	1816	+
	1817	+ /**
	1818	+ * Condition implementation for a {@link
	1819	+ * AbstractQueuedSynchronizer} serving as the basis of a {@link
	1820	+ * Lock} implementation.
	1821	+ *
	1822	+ * <p>Method documentation for this class describes mechanics,
	1823	+ * not behavioral specifications from the point of view of Lock
	1824	+ * and Condition users. Exported versions of this class will in
	1825	+ * general need to be accompanied by documentation describing
	1826	+ * condition semantics that rely on those of the associated
	1827	+ * <tt>AbstractQueuedSynchronizer</tt>.
	1828	+ *
	1829	+ * <p>This class is Serializable, but all fields are transient,
	1830	+ * so deserialized conditions have no waiters.
	1831	+ */
	1832	+ public class ConditionObject implements Condition, java.io.Serializable {
	1833	+ private static final long serialVersionUID = 1173984872572414699L;
	1834	+ /** First node of condition queue. */
	1835	+ private transient Node firstWaiter;
	1836	+ /** Last node of condition queue. */
	1837	+ private transient Node lastWaiter;
	1838	+
	1839	+ /**
	1840	+ * Creates a new <tt>ConditionObject</tt> instance.
	1841	+ */
	1842	+ public ConditionObject() { }
	1843	+
	1844	+ // Internal methods
	1845	+
	1846	+ /**
	1847	+ * Adds a new waiter to wait queue.
	1848	+ * @return its new wait node
	1849	+ */
	1850	+ private Node addConditionWaiter() {
	1851	+ Node t = lastWaiter;
	1852	+ // If lastWaiter is cancelled, clean out.
	1853	+ if (t != null && t.waitStatus != Node.CONDITION) {
	1854	+ unlinkCancelledWaiters();
	1855	+ t = lastWaiter;
	1856	+ }
	1857	+ Node node = new Node(Thread.currentThread(), Node.CONDITION);
	1858	+ if (t == null)
	1859	+ firstWaiter = node;
	1860	+ else
	1861	+ t.nextWaiter = node;
	1862	+ lastWaiter = node;
	1863	+ return node;
	1864	+ }
	1865	+
	1866	+ /**
	1867	+ * Removes and transfers nodes until hit non-cancelled one or
	1868	+ * null. Split out from signal in part to encourage compilers
	1869	+ * to inline the case of no waiters.
	1870	+ * @param first (non-null) the first node on condition queue
	1871	+ */
	1872	+ private void doSignal(Node first) {
	1873	+ do {
	1874	+ if ( (firstWaiter = first.nextWaiter) == null)
	1875	+ lastWaiter = null;
	1876	+ first.nextWaiter = null;
	1877	+ } while (!transferForSignal(first) &&
	1878	+ (first = firstWaiter) != null);
	1879	+ }
	1880	+
	1881	+ /**
	1882	+ * Removes and transfers all nodes.
	1883	+ * @param first (non-null) the first node on condition queue
	1884	+ */
	1885	+ private void doSignalAll(Node first) {
	1886	+ lastWaiter = firstWaiter = null;
	1887	+ do {
	1888	+ Node next = first.nextWaiter;
	1889	+ first.nextWaiter = null;
	1890	+ transferForSignal(first);
	1891	+ first = next;
	1892	+ } while (first != null);
	1893	+ }
	1894	+
	1895	+ /**
	1896	+ * Unlinks cancelled waiter nodes from condition queue.
	1897	+ * Called only while holding lock. This is called when
	1898	+ * cancellation occurred during condition wait, and upon
	1899	+ * insertion of a new waiter when lastWaiter is seen to have
	1900	+ * been cancelled. This method is needed to avoid garbage
	1901	+ * retention in the absence of signals. So even though it may
	1902	+ * require a full traversal, it comes into play only when
	1903	+ * timeouts or cancellations occur in the absence of
	1904	+ * signals. It traverses all nodes rather than stopping at a
	1905	+ * particular target to unlink all pointers to garbage nodes
	1906	+ * without requiring many re-traversals during cancellation
	1907	+ * storms.
	1908	+ */
	1909	+ private void unlinkCancelledWaiters() {
	1910	+ Node t = firstWaiter;
	1911	+ Node trail = null;
	1912	+ while (t != null) {
	1913	+ Node next = t.nextWaiter;
	1914	+ if (t.waitStatus != Node.CONDITION) {
	1915	+ t.nextWaiter = null;
	1916	+ if (trail == null)
	1917	+ firstWaiter = next;
	1918	+ else
	1919	+ trail.nextWaiter = next;
	1920	+ if (next == null)
	1921	+ lastWaiter = trail;
	1922	+ }
	1923	+ else
	1924	+ trail = t;
	1925	+ t = next;
	1926	+ }
	1927	+ }
	1928	+
	1929	+ // public methods
	1930	+
	1931	+ /**
	1932	+ * Moves the longest-waiting thread, if one exists, from the
	1933	+ * wait queue for this condition to the wait queue for the
	1934	+ * owning lock.
	1935	+ *
	1936	+ * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
	1937	+ * returns {@code false}
	1938	+ */
	1939	+ public final void signal() {
	1940	+ if (!isHeldExclusively())
	1941	+ throw new IllegalMonitorStateException();
	1942	+ Node first = firstWaiter;
	1943	+ if (first != null)
	1944	+ doSignal(first);
	1945	+ }
	1946	+
	1947	+ /**
	1948	+ * Moves all threads from the wait queue for this condition to
	1949	+ * the wait queue for the owning lock.
	1950	+ *
	1951	+ * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
	1952	+ * returns {@code false}
	1953	+ */
	1954	+ public final void signalAll() {
	1955	+ if (!isHeldExclusively())
	1956	+ throw new IllegalMonitorStateException();
	1957	+ Node first = firstWaiter;
	1958	+ if (first != null)
	1959	+ doSignalAll(first);
	1960	+ }
	1961	+
	1962	+ /**
	1963	+ * Implements uninterruptible condition wait.
	1964	+ * <ol>
	1965	+ * <li> Save lock state returned by {@link #getState}.
	1966	+ * <li> Invoke {@link #release} with
	1967	+ * saved state as argument, throwing
	1968	+ * IllegalMonitorStateException if it fails.
	1969	+ * <li> Block until signalled.
	1970	+ * <li> Reacquire by invoking specialized version of
	1971	+ * {@link #acquire} with saved state as argument.
	1972	+ * </ol>
	1973	+ */
	1974	+ public final void awaitUninterruptibly() {
	1975	+ Node node = addConditionWaiter();
	1976	+ int savedState = fullyRelease(node);
	1977	+ boolean interrupted = false;
	1978	+ while (!isOnSyncQueue(node)) {
	1979	+ LockSupport.park(this);
	1980	+ if (Thread.interrupted())
	1981	+ interrupted = true;
	1982	+ }
	1983	+ if (acquireQueued(node, savedState) \|\| interrupted)
	1984	+ selfInterrupt();
	1985	+ }
	1986	+
	1987	+ /*
	1988	+ * For interruptible waits, we need to track whether to throw
	1989	+ * InterruptedException, if interrupted while blocked on
	1990	+ * condition, versus reinterrupt current thread, if
	1991	+ * interrupted while blocked waiting to re-acquire.
	1992	+ */
	1993	+
	1994	+ /** Mode meaning to reinterrupt on exit from wait */
	1995	+ private static final int REINTERRUPT = 1;
	1996	+ /** Mode meaning to throw InterruptedException on exit from wait */
	1997	+ private static final int THROW_IE = -1;
	1998	+
	1999	+ /**
	2000	+ * Checks for interrupt, returning THROW_IE if interrupted
	2001	+ * before signalled, REINTERRUPT if after signalled, or
	2002	+ * 0 if not interrupted.
	2003	+ */
	2004	+ private int checkInterruptWhileWaiting(Node node) {
	2005	+ return Thread.interrupted() ?
	2006	+ (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
	2007	+ 0;
	2008	+ }
	2009	+
	2010	+ /**
	2011	+ * Throws InterruptedException, reinterrupts current thread, or
	2012	+ * does nothing, depending on mode.
	2013	+ */
	2014	+ private void reportInterruptAfterWait(int interruptMode)
	2015	+ throws InterruptedException {
	2016	+ if (interruptMode == THROW_IE)
	2017	+ throw new InterruptedException();
	2018	+ else if (interruptMode == REINTERRUPT)
	2019	+ selfInterrupt();
	2020	+ }
	2021	+
	2022	+ /**
	2023	+ * Implements interruptible condition wait.
	2024	+ * <ol>
	2025	+ * <li> If current thread is interrupted, throw InterruptedException.
	2026	+ * <li> Save lock state returned by {@link #getState}.
	2027	+ * <li> Invoke {@link #release} with
	2028	+ * saved state as argument, throwing
	2029	+ * IllegalMonitorStateException if it fails.
	2030	+ * <li> Block until signalled or interrupted.
	2031	+ * <li> Reacquire by invoking specialized version of
	2032	+ * {@link #acquire} with saved state as argument.
	2033	+ * <li> If interrupted while blocked in step 4, throw InterruptedException.
	2034	+ * </ol>
	2035	+ */
	2036	+ public final void await() throws InterruptedException {
	2037	+ if (Thread.interrupted())
	2038	+ throw new InterruptedException();
	2039	+ Node node = addConditionWaiter();
	2040	+ int savedState = fullyRelease(node);
	2041	+ int interruptMode = 0;
	2042	+ while (!isOnSyncQueue(node)) {
	2043	+ LockSupport.park(this);
	2044	+ if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
	2045	+ break;
	2046	+ }
	2047	+ if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
	2048	+ interruptMode = REINTERRUPT;
	2049	+ if (node.nextWaiter != null) // clean up if cancelled
	2050	+ unlinkCancelledWaiters();
	2051	+ if (interruptMode != 0)
	2052	+ reportInterruptAfterWait(interruptMode);
	2053	+ }
	2054	+
	2055	+ /**
	2056	+ * Implements timed condition wait.
	2057	+ * <ol>
	2058	+ * <li> If current thread is interrupted, throw InterruptedException.
	2059	+ * <li> Save lock state returned by {@link #getState}.
	2060	+ * <li> Invoke {@link #release} with
	2061	+ * saved state as argument, throwing
	2062	+ * IllegalMonitorStateException if it fails.
	2063	+ * <li> Block until signalled, interrupted, or timed out.
	2064	+ * <li> Reacquire by invoking specialized version of
	2065	+ * {@link #acquire} with saved state as argument.
	2066	+ * <li> If interrupted while blocked in step 4, throw InterruptedException.
	2067	+ * </ol>
	2068	+ */
	2069	+ public final long awaitNanos(long nanosTimeout)
	2070	+ throws InterruptedException {
	2071	+ if (Thread.interrupted())
	2072	+ throw new InterruptedException();
	2073	+ Node node = addConditionWaiter();
	2074	+ int savedState = fullyRelease(node);
	2075	+ long lastTime = System.nanoTime();
	2076	+ int interruptMode = 0;
	2077	+ while (!isOnSyncQueue(node)) {
	2078	+ if (nanosTimeout <= 0L) {
	2079	+ transferAfterCancelledWait(node);
	2080	+ break;
	2081	+ }
	2082	+ LockSupport.parkNanos(this, nanosTimeout);
	2083	+ if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
	2084	+ break;
	2085	+
	2086	+ long now = System.nanoTime();
	2087	+ nanosTimeout -= now - lastTime;
	2088	+ lastTime = now;
	2089	+ }
	2090	+ if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
	2091	+ interruptMode = REINTERRUPT;
	2092	+ if (node.nextWaiter != null)
	2093	+ unlinkCancelledWaiters();
	2094	+ if (interruptMode != 0)
	2095	+ reportInterruptAfterWait(interruptMode);
	2096	+ return nanosTimeout - (System.nanoTime() - lastTime);
	2097	+ }
	2098	+
	2099	+ /**
	2100	+ * Implements absolute timed condition wait.
	2101	+ * <ol>
	2102	+ * <li> If current thread is interrupted, throw InterruptedException.
	2103	+ * <li> Save lock state returned by {@link #getState}.
	2104	+ * <li> Invoke {@link #release} with
	2105	+ * saved state as argument, throwing
	2106	+ * IllegalMonitorStateException if it fails.
	2107	+ * <li> Block until signalled, interrupted, or timed out.
	2108	+ * <li> Reacquire by invoking specialized version of
	2109	+ * {@link #acquire} with saved state as argument.
	2110	+ * <li> If interrupted while blocked in step 4, throw InterruptedException.
	2111	+ * <li> If timed out while blocked in step 4, return false, else true.
	2112	+ * </ol>
	2113	+ */
	2114	+ public final boolean awaitUntil(Date deadline)
	2115	+ throws InterruptedException {
	2116	+ if (deadline == null)
	2117	+ throw new NullPointerException();
	2118	+ long abstime = deadline.getTime();
	2119	+ if (Thread.interrupted())
	2120	+ throw new InterruptedException();
	2121	+ Node node = addConditionWaiter();
	2122	+ int savedState = fullyRelease(node);
	2123	+ boolean timedout = false;
	2124	+ int interruptMode = 0;
	2125	+ while (!isOnSyncQueue(node)) {
	2126	+ if (System.currentTimeMillis() > abstime) {
	2127	+ timedout = transferAfterCancelledWait(node);
	2128	+ break;
	2129	+ }
	2130	+ LockSupport.parkUntil(this, abstime);
	2131	+ if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
	2132	+ break;
	2133	+ }
	2134	+ if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
	2135	+ interruptMode = REINTERRUPT;
	2136	+ if (node.nextWaiter != null)
	2137	+ unlinkCancelledWaiters();
	2138	+ if (interruptMode != 0)
	2139	+ reportInterruptAfterWait(interruptMode);
	2140	+ return !timedout;
	2141	+ }
	2142	+
	2143	+ /**
	2144	+ * Implements timed condition wait.
	2145	+ * <ol>
	2146	+ * <li> If current thread is interrupted, throw InterruptedException.
	2147	+ * <li> Save lock state returned by {@link #getState}.
	2148	+ * <li> Invoke {@link #release} with
	2149	+ * saved state as argument, throwing
	2150	+ * IllegalMonitorStateException if it fails.
	2151	+ * <li> Block until signalled, interrupted, or timed out.
	2152	+ * <li> Reacquire by invoking specialized version of
	2153	+ * {@link #acquire} with saved state as argument.
	2154	+ * <li> If interrupted while blocked in step 4, throw InterruptedException.
	2155	+ * <li> If timed out while blocked in step 4, return false, else true.
	2156	+ * </ol>
	2157	+ */
	2158	+ public final boolean await(long time, TimeUnit unit)
	2159	+ throws InterruptedException {
	2160	+ if (unit == null)
	2161	+ throw new NullPointerException();
	2162	+ long nanosTimeout = unit.toNanos(time);
	2163	+ if (Thread.interrupted())
	2164	+ throw new InterruptedException();
	2165	+ Node node = addConditionWaiter();
	2166	+ int savedState = fullyRelease(node);
	2167	+ long lastTime = System.nanoTime();
	2168	+ boolean timedout = false;
	2169	+ int interruptMode = 0;
	2170	+ while (!isOnSyncQueue(node)) {
	2171	+ if (nanosTimeout <= 0L) {
	2172	+ timedout = transferAfterCancelledWait(node);
	2173	+ break;
	2174	+ }
	2175	+ if (nanosTimeout >= spinForTimeoutThreshold)
	2176	+ LockSupport.parkNanos(this, nanosTimeout);
	2177	+ if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
	2178	+ break;
	2179	+ long now = System.nanoTime();
	2180	+ nanosTimeout -= now - lastTime;
	2181	+ lastTime = now;
	2182	+ }
	2183	+ if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
	2184	+ interruptMode = REINTERRUPT;
	2185	+ if (node.nextWaiter != null)
	2186	+ unlinkCancelledWaiters();
	2187	+ if (interruptMode != 0)
	2188	+ reportInterruptAfterWait(interruptMode);
	2189	+ return !timedout;
	2190	+ }
	2191	+
	2192	+ // support for instrumentation
	2193	+
	2194	+ /**
	2195	+ * Returns true if this condition was created by the given
	2196	+ * synchronization object.
	2197	+ *
	2198	+ * @return {@code true} if owned
	2199	+ */
	2200	+ final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {
	2201	+ return sync == AbstractQueuedSynchronizer.this;
	2202	+ }
	2203	+
	2204	+ /**
	2205	+ * Queries whether any threads are waiting on this condition.
	2206	+ * Implements {@link AbstractQueuedSynchronizer#hasWaiters}.
	2207	+ *
	2208	+ * @return {@code true} if there are any waiting threads
	2209	+ * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
	2210	+ * returns {@code false}
	2211	+ */
	2212	+ protected final boolean hasWaiters() {
	2213	+ if (!isHeldExclusively())
	2214	+ throw new IllegalMonitorStateException();
	2215	+ for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
	2216	+ if (w.waitStatus == Node.CONDITION)
	2217	+ return true;
	2218	+ }
	2219	+ return false;
	2220	+ }
	2221	+
	2222	+ /**
	2223	+ * Returns an estimate of the number of threads waiting on
	2224	+ * this condition.
	2225	+ * Implements {@link AbstractQueuedSynchronizer#getWaitQueueLength}.
	2226	+ *
	2227	+ * @return the estimated number of waiting threads
	2228	+ * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
	2229	+ * returns {@code false}
	2230	+ */
	2231	+ protected final int getWaitQueueLength() {
	2232	+ if (!isHeldExclusively())
	2233	+ throw new IllegalMonitorStateException();
	2234	+ int n = 0;
	2235	+ for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
	2236	+ if (w.waitStatus == Node.CONDITION)
	2237	+ ++n;
	2238	+ }
	2239	+ return n;
	2240	+ }
	2241	+
	2242	+ /**
	2243	+ * Returns a collection containing those threads that may be
	2244	+ * waiting on this Condition.
	2245	+ * Implements {@link AbstractQueuedSynchronizer#getWaitingThreads}.
	2246	+ *
	2247	+ * @return the collection of threads
	2248	+ * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
	2249	+ * returns {@code false}
	2250	+ */
	2251	+ protected final Collection<Thread> getWaitingThreads() {
	2252	+ if (!isHeldExclusively())
	2253	+ throw new IllegalMonitorStateException();
	2254	+ ArrayList<Thread> list = new ArrayList<Thread>();
	2255	+ for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
	2256	+ if (w.waitStatus == Node.CONDITION) {
	2257	+ Thread t = w.thread;
	2258	+ if (t != null)
	2259	+ list.add(t);
	2260	+ }
	2261	+ }
	2262	+ return list;
	2263	+ }
	2264	+ }
	2265	+
	2266	+ /**
	2267	+ * Setup to support compareAndSet. We need to natively implement
	2268	+ * this here: For the sake of permitting future enhancements, we
	2269	+ * cannot explicitly subclass AtomicInteger, which would be
	2270	+ * efficient and useful otherwise. So, as the lesser of evils, we
	2271	+ * natively implement using hotspot intrinsics API. And while we
	2272	+ * are at it, we do the same for other CASable fields (which could
	2273	+ * otherwise be done with atomic field updaters).
	2274	+ */
	2275	+ private static final Unsafe unsafe = Unsafe.getUnsafe();
	2276	+ private static final long stateOffset;
	2277	+ private static final long headOffset;
	2278	+ private static final long tailOffset;
	2279	+ private static final long waitStatusOffset;
	2280	+ private static final long nextOffset;
	2281	+
	2282	+ static {
	2283	+ try {
	2284	+ stateOffset = unsafe.objectFieldOffset
	2285	+ (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
	2286	+ headOffset = unsafe.objectFieldOffset
	2287	+ (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
	2288	+ tailOffset = unsafe.objectFieldOffset
	2289	+ (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
	2290	+ waitStatusOffset = unsafe.objectFieldOffset
	2291	+ (Node.class.getDeclaredField("waitStatus"));
	2292	+ nextOffset = unsafe.objectFieldOffset
	2293	+ (Node.class.getDeclaredField("next"));
	2294	+
	2295	+ } catch (Exception ex) { throw new Error(ex); }
	2296	+ }
	2297	+
	2298	+ /**
	2299	+ * CAS head field. Used only by enq.
	2300	+ */
	2301	+ private final boolean compareAndSetHead(Node update) {
	2302	+ return unsafe.compareAndSwapObject(this, headOffset, null, update);
	2303	+ }
	2304	+
	2305	+ /**
	2306	+ * CAS tail field. Used only by enq.
	2307	+ */
	2308	+ private final boolean compareAndSetTail(Node expect, Node update) {
	2309	+ return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
	2310	+ }
	2311	+
	2312	+ /**
	2313	+ * CAS waitStatus field of a node.
	2314	+ */
	2315	+ private static final boolean compareAndSetWaitStatus(Node node,
	2316	+ int expect,
	2317	+ int update) {
	2318	+ return unsafe.compareAndSwapInt(node, waitStatusOffset,
	2319	+ expect, update);
	2320	+ }
	2321	+
	2322	+ /**
	2323	+ * CAS next field of a node.
	2324	+ */
	2325	+ private static final boolean compareAndSetNext(Node node,
	2326	+ Node expect,
	2327	+ Node update) {
	2328	+ return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
	2329	+ }
	2330	+}