/libcore/luni/src/main/java/java/lang/ref/ |
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; 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 D | ReferenceQueue.java | 46 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 D | ConcurrentLinkedQueue.java | 27 * 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 D | LinkedBlockingQueue.java | 28 * 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 D | ArrayBlockingQueue.java | 28 * <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 D | ConcurrentLinkedDeque.java | 119 * 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 D | LinkedTransferQueue.java | 27 * 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 D | SynchronousQueue.java | 32 * <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 D | ConcurrentSkipListMap.java | 259 * 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 D | ArrayDeque.java | 95 * 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 D | HttpClient.java | 590 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 D | AbstractQueuedLongSynchronizer.java | 54 * 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 D | AbstractQueuedSynchronizer.java | 292 * 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...] |