/libcore/luni/src/main/java/java/lang/ref/ |
H A D | ReferenceQueue.java | 30 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 D | FinalizerReference.java | 31 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 D | ArrayDeque.java | 62 * 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 D | ConcurrentLinkedQueue.java | 23 * 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 D | LinkedBlockingQueue.java | 25 * 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 D | ArrayBlockingQueue.java | 23 * <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 D | ConcurrentLinkedDeque.java | 122 * 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 D | LinkedTransferQueue.java | 24 * 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 D | SynchronousQueue.java | 25 * <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 D | ConcurrentSkipListMap.java | 238 * 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 D | Class.java | 1410 * @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 D | AbstractQueuedLongSynchronizer.java | 67 * 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 D | AbstractQueuedSynchronizer.java | 296 * 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...] |