Searched defs:head (Results 1 - 13 of 13) sorted by relevance

/libcore/luni/src/main/java/java/lang/ref/
H A DFinalizerReference.java31 private static FinalizerReference<?> head = null; field in class:FinalizerReference
57 reference.next = head;
58 if (head != null) {
59 head.prev = reference;
61 head = reference;
74 head = next;
100 // We search the list for that FinalizerReference (it should be at or near the head),
102 for (FinalizerReference<?> r = head; r != null; r = r.next) {
/libcore/ojluni/src/main/java/java/lang/ref/
H A DReferenceQueue.java46 private Reference<? extends T> head = null; field in class:ReferenceQueue
84 head = r;
122 if (head != null) {
123 Reference<? extends T> r = head;
124 if (head == tail) {
126 head = null;
128 head = head.queueNext;
150 if (head == null)
/libcore/luni/src/main/java/java/util/concurrent/
H A DConcurrentLinkedQueue.java27 * The <em>head</em> of the queue is that element that has been on the
32 * operations obtain elements at the head of the queue.
99 * head as well.
101 * Nodes that are reachable from head. CASing the item
103 * queue. Reachability of all elements from head must remain
105 * head to advance. A dequeued Node may remain in use
119 * self-link implicitly means to advance to head.
121 * Both head and tail are permitted to lag. In fact, failing to
125 * that is, we update head/tail when the current pointer appears
128 * Since head an
191 transient volatile Node<E> head; field in class:ConcurrentLinkedQueue
[all...]
H A DLinkedBlockingQueue.java28 * The <em>head</em> of the queue is that element that has been on the
33 * operations obtain elements at the head of the queue.
87 * self-link implicitly means to advance to head.next.
99 * - this Node, meaning the successor is head.next
115 * Invariant: head.item == null
117 transient Node<E> head; field in class:LinkedBlockingQueue
176 * Removes a node from head of queue.
182 // assert head.item == null;
183 Node<E> h = head;
186 head
[all...]
H A DArrayBlockingQueue.java28 * <em>head</em> of the queue is that element that has been on the
32 * operations obtain elements at the head of the queue.
681 * The elements will be returned in order from first (head) to last (tail).
699 * not at head) would cause iterators to sometimes lose their
761 private Node head; field in class:ArrayBlockingQueue.Itrs
783 // assert head != null;
791 p = head;
804 p = head;
816 head = next;
839 head
[all...]
H A DConcurrentLinkedDeque.java119 * The deque object has two node references, "head" and "tail".
120 * The head and tail are only approximations to the first and last
122 * following prev pointers from head; likewise for tail. However,
123 * it is permissible for head and tail to be referring to deleted
155 * head or tail.
174 * the nodes pointed at by head/tail never get gc-unlinked, since
175 * head/tail are needed to get "back on track" by other nodes that
190 * pointers from head), and p.next == null && p.prev == p means
225 * - the first node is always O(1) reachable from head via prev links
227 * - head !
234 private transient volatile Node<E> head; field in class:ConcurrentLinkedDeque
[all...]
H A DLinkedTransferQueue.java27 * to any given producer. The <em>head</em> of the queue is that
83 * It maintains two pointer fields, "head", pointing to a
90 * head tail
96 * overhead limitations when maintaining (via CAS) these head and
133 * updates on head/tail fields.
136 * never versus always updating queue (head and tail) pointers.
143 * head tail
149 * between the value of "head" and the first unmatched node, and
157 * virtue of only sometimes updating head or tail pointers when
179 * be further reduced without increasing contention of head
531 transient volatile Node head; field in class:LinkedTransferQueue
[all...]
H A DSynchronousQueue.java32 * <em>head</em> of the queue is the element that the first queued
135 * old head pointers), but references in Queue nodes must be
273 /** The head (top) of the stack */
274 volatile SNode head; field in class:SynchronousQueue.TransferStack
277 return h == head &&
285 * and CASes of head and to avoid surges of garbage when CASes
325 SNode h = head;
338 if ((h = head) != null && h.next == s)
393 * to be at the head of the stack, calls to park are
437 * Returns true if node s is at head o
566 transient volatile QNode head; field in class:SynchronousQueue.TransferQueue
[all...]
H A DConcurrentSkipListMap.java259 * tree-like structure) also uses CAS. The head index has initial
261 * than the current level adds a level to the head index by
262 * CAS'ing on a new top-most head. To maintain good performance
336 * The topmost head index of the skiplist.
338 private transient volatile HeadIndex<K,V> head; field in class:ConcurrentSkipListMap
367 head = new HeadIndex<K,V>(new Node<K,V>(null, BASE_HEADER, null),
372 * compareAndSet head node.
383 * headed by a dummy node accessible as head.node. The value field
406 * header node (head.node), which also has a null key.
638 for (Index<K,V> q = head,
[all...]
/libcore/ojluni/src/main/java/java/util/
H A DArrayDeque.java95 * thus avoiding head and tail wrapping around to equal each
102 * The index of the element at the head of the deque (which is the
106 transient int head; field in class:ArrayDeque
148 * when head and tail have wrapped around to become equal.
151 assert head == tail;
152 int p = head;
162 head = 0;
212 elements[head = (head - 1) & (elements.length - 1)] = e;
213 if (head
[all...]
/libcore/ojluni/src/main/java/sun/net/www/http/
H A DHttpClient.java590 public void writeRequests(MessageHeader head) { argument
591 requests = head;
596 public void writeRequests(MessageHeader head, argument
598 requests = head;
606 public void writeRequests(MessageHeader head, argument
610 writeRequests(head, pos);
/libcore/luni/src/main/java/java/util/concurrent/locks/
H A DAbstractQueuedLongSynchronizer.java54 * If head exists, its waitStatus is guaranteed not to be
57 private transient volatile Node head; field in class:AbstractQueuedLongSynchronizer
158 * Sets head of queue to be node, thus dequeuing. Called only by
165 head = node;
205 * to calling unparkSuccessor of head if it needs signal.)
211 * way of trying to unparkSuccessor of head if it needs
220 Node h = head;
232 if (h == head) // loop if head changed
238 * Sets head o
[all...]
H A DAbstractQueuedSynchronizer.java292 * tail. To dequeue, you just set the head field.
295 * head | | <---- | | <---- | | tail
302 * involves only updating the "head". However, it takes a bit
336 * is constructed and head and tail pointers are set upon first
389 * nodes. This is set (for head node only) in
412 * because the head node is never cancelled: A node becomes
413 * head only as a result of successful acquire. A
474 /** Establishes initial head or SHARED marker. */
523 * If head exists, its waitStatus is guaranteed not to be
526 private transient volatile Node head; field in class:AbstractQueuedSynchronizer
[all...]

Completed in 253 milliseconds