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

/libcore/luni/src/main/java/java/lang/ref/
H A DReferenceQueue.java30 private Reference<? extends T> head; field in class:ReferenceQueue
47 if (head == null) {
53 ret = head;
55 if (head == head.queueNext) {
56 head = null;
58 head = head.queueNext;
95 if (head != null) {
103 } while (head
[all...]
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;
94 // We search the list for that FinalizerReference (it should be at or near the head),
96 for (FinalizerReference<?> r = head; r != null; r = r.next) {
/libcore/luni/src/main/java/java/util/
H A DArrayDeque.java62 * thus avoiding head and tail wrapping around to equal each
69 * The index of the element at the head of the deque (which is the
73 private transient int head; field in class:ArrayDeque
115 * when head and tail have wrapped around to become equal.
118 assert head == tail;
119 int p = head;
129 head = 0;
141 if (head < tail) {
142 System.arraycopy(elements, head, a, 0, size());
143 } else if (head > tai
[all...]
/libcore/luni/src/main/java/java/util/concurrent/
H A DConcurrentLinkedQueue.java23 * The <em>head</em> of the queue is that element that has been on the
28 * operations obtain elements at the head of the queue.
96 * head as well.
98 * Nodes that are reachable from head. CASing the item
100 * queue. Reachability of all elements from head must remain
102 * head to advance. A dequeued Node may remain in use
116 * self-link implicitly means to advance to head.
118 * Both head and tail are permitted to lag. In fact, failing to
122 * that is, we update head/tail when the current pointer appears
125 * Since head an
205 private transient volatile Node<E> head; field in class:ConcurrentLinkedQueue
[all...]
H A DLinkedBlockingQueue.java25 * The <em>head</em> of the queue is that element that has been on the
30 * operations obtain elements at the head of the queue.
85 * self-link implicitly means to advance to head.next.
97 * - this Node, meaning the successor is head.next
113 * Invariant: head.item == null
115 transient Node<E> head; field in class:LinkedBlockingQueue
174 * Removes a node from head of queue.
180 // assert head.item == null;
181 Node<E> h = head;
184 head
[all...]
H A DArrayBlockingQueue.java23 * <em>head</em> of the queue is that element that has been on the
27 * operations obtain elements at the head of the queue.
706 * The elements will be returned in order from first (head) to last (tail).
728 * not at head) would cause iterators to sometimes lose their
790 private Node head; field in class:ArrayBlockingQueue.Itrs
812 // assert head != null;
820 p = head;
833 p = head;
845 head = next;
868 head
[all...]
H A DConcurrentLinkedDeque.java122 * The deque object has two node references, "head" and "tail".
123 * The head and tail are only approximations to the first and last
125 * following prev pointers from head; likewise for tail. However,
126 * it is permissible for head and tail to be referring to deleted
158 * head or tail.
177 * the nodes pointed at by head/tail never get gc-unlinked, since
178 * head/tail are needed to get "back on track" by other nodes that
193 * pointers from head), and p.next == null && p.prev == p means
228 * - the first node is always O(1) reachable from head via prev links
230 * - head !
237 private transient volatile Node<E> head; field in class:ConcurrentLinkedDeque
[all...]
H A DLinkedTransferQueue.java24 * to any given producer. The <em>head</em> of the queue is that
81 * It maintains two pointer fields, "head", pointing to a
88 * head tail
94 * overhead limitations when maintaining (via CAS) these head and
131 * updates on head/tail fields.
134 * never versus always updating queue (head and tail) pointers.
141 * head tail
147 * between the value of "head" and the first unmatched node, and
155 * virtue of only sometimes updating head or tail pointers when
177 * be further reduced without increasing contention of head
531 transient volatile Node head; field in class:LinkedTransferQueue
[all...]
H A DSynchronousQueue.java25 * <em>head</em> of the queue is the element that the first queued
128 * old head pointers), but references in Queue nodes must be
270 /** The head (top) of the stack */
271 volatile SNode head; field in class:SynchronousQueue.TransferStack
274 return h == head &&
282 * and CASes of head and to avoid surges of garbage when CASes
321 SNode h = head;
334 if ((h = head) != null && h.next == s)
389 * to be at the head of the stack, calls to park are
434 * Returns true if node s is at head o
567 transient volatile QNode head; field in class:SynchronousQueue.TransferQueue
[all...]
H A DConcurrentSkipListMap.java238 * tree-like structure) also uses CAS. The head index has initial
240 * than the current level adds a level to the head index by
241 * CAS'ing on a new top-most head. To maintain good performance
307 * The topmost head index of the skiplist.
309 private transient volatile HeadIndex<K,V> head; field in class:ConcurrentSkipListMap
344 head = new HeadIndex<K,V>(new Node<K,V>(null, BASE_HEADER, null),
349 * compareAndSet head node
360 * headed by a dummy node accessible as head.node. The value field
383 * header node (head.node), which also has a null key.
685 Index<K,V> q = head;
[all...]
/libcore/luni/src/main/java/java/lang/
H A DClass.java1410 * @param head the first source array
1414 private static <T extends Object> T[] arraycopy(T[] result, T[] head, T[] tail) { argument
1415 System.arraycopy(head, 0, result, 0, head.length);
1416 System.arraycopy(tail, 0, result, head.length, tail.length);
/libcore/luni/src/main/java/java/util/concurrent/locks/
H A DAbstractQueuedLongSynchronizer.java67 * tail. To dequeue, you just set the head field.
70 * head | | <---- | | <---- | | tail
77 * involves only updating the "head". However, it takes a bit
111 * is constructed and head and tail pointers are set upon first
164 * nodes. This is set (for head node only) in
187 * because the head node is never cancelled: A node becomes
188 * head only as a result of successful acquire. A
249 Node() { // Used to establish initial head or SHARED marker
266 * If head exists, its waitStatus is guaranteed not to be
269 private transient volatile Node head; field in class:AbstractQueuedLongSynchronizer
[all...]
H A DAbstractQueuedSynchronizer.java296 * tail. To dequeue, you just set the head field.
299 * head | | <---- | | <---- | | tail
306 * involves only updating the "head". However, it takes a bit
340 * is constructed and head and tail pointers are set upon first
393 * nodes. This is set (for head node only) in
416 * because the head node is never cancelled: A node becomes
417 * head only as a result of successful acquire. A
478 Node() { // Used to establish initial head or SHARED marker
495 * If head exists, its waitStatus is guaranteed not to be
498 private transient volatile Node head; field in class:AbstractQueuedSynchronizer
[all...]

Completed in 143 milliseconds