Cross Reference: /libcore/ojluni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java

Lines Matching refs:head
320      * tail. To dequeue, you just set the head field.
323      * head |      | <---- |     | <---- |     |  tail
330      * involves only updating the "head". However, it takes a bit
364      * is constructed and head and tail pointers are set upon first
417          *               nodes. This is set (for head node only) in
440          * because the head node is never cancelled: A node becomes
441          * head only as a result of successful acquire. A
502         /** Establishes initial head or SHARED marker. */
551      * If head exists, its waitStatus is guaranteed not to be
554     private transient volatile Node head;
653      * Sets head of queue to be node, thus dequeuing. Called only by
660         head = node;
700      * to calling unparkSuccessor of head if it needs signal.)
706          * way of trying to unparkSuccessor of head if it needs
715             Node h = head;
727             if (h == head)                   // loop if head changed
733      * Sets head of queue, and checks if successor may be waiting
741         Node h = head; // Record old head for check below
760             (h = head) == null || h.waitStatus < 0) {
803             if (pred != head &&
894                 if (p == head && tryAcquire(arg)) {
919                 if (p == head && tryAcquire(arg)) {
950                 if (p == head && tryAcquire(arg)) {
982                 if (p == head) {
1012                 if (p == head) {
1046                 if (p == head) {
1286             Node h = head;
1386         return head != tail;
1399         return head != null;
1415         return (head == tail) ? null : fullGetFirstQueuedThread();
1423          * The first node is normally head.next. Try to get its
1425          * field is nulled out or s.prev is no longer head, then
1432         if (((h = head) != null && (s = h.next) != null &&
1433              s.prev == head && (st = s.thread) != null) ||
1434             ((h = head) != null && (s = h.next) != null &&
1435              s.prev == head && (st = s.thread) != null))
1442          * traversing from tail back to head to find first,
1447         for (Node p = tail; p != null && p != head; p = p.prev) {
1485         return (h = head) != null &&
1531      *         is at the head of the queue or the queue is empty
1535         // The correctness of this depends on head being initialized
1536         // before tail and on head.next being accurate if the current
1539         Node h = head;
2296                 (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
2309      * Initializes head and tail fields on first contention.