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