Lines Matching refs:next
118 * Nodes next v v v v v
130 * basic idea in these lists is to mark the "next" pointers of
138 * use direct CAS'able next pointers. On deletion, instead of
152 * algorithm of changing the next-pointer of a deleted node so
188 * n's next pointer.
190 * 2. CAS n's next pointer to point to a new marker node.
198 * 3. CAS b's next pointer over both n and its marker.
213 * just (b, n, f), although the next field of a marker is
214 * immutable, and once a next field is CAS'ed to point to a
225 * Index levels are maintained as lists with volatile next fields,
397 volatile Node<K,V> next;
402 Node(K key, Object value, Node<K,V> next) {
405 this.next = next;
415 Node(Node<K,V> next) {
418 this.next = next;
429 * compareAndSet next field
478 if (f == next && this == b.next) {
482 b.casNext(this, f.next);
524 (k.getDeclaredField("next"));
753 * (1) After reading n's next field, n is no longer assumed
790 Node<K,V> n = b.next;
794 Node<K,V> f = n.next;
795 if (n != b.next) // inconsistent read
851 Node<K,V> n = b.next;
854 Node<K,V> f = n.next;
855 if (n != b.next) // inconsistent read
971 // Track next level to insert in case of retries
1050 Node<K,V> n = b.next;
1054 Node<K,V> f = n.next;
1055 if (n != b.next) // inconsistent read
1132 Node<K,V> n = b.next;
1137 n.helpDelete(b, n.next);
1148 Node<K,V> n = b.next;
1151 Node<K,V> f = n.next;
1152 if (n != b.next)
1214 Node<K,V> n = b.next;
1218 Node<K,V> f = n.next; // inconsistent read
1219 if (n != b.next)
1254 if (r.node.next != null) {
1275 Node<K,V> n = b.next;
1283 Node<K,V> f = n.next;
1284 if (n != b.next) // inconsistent read
1332 Node<K,V> n = b.next;
1336 Node<K,V> f = n.next;
1337 if (n != b.next) // inconsistent read
1479 Map.Entry<? extends K, ? extends V> e = it.next();
1487 basepred.next = z;
1524 for (Node<K,V> n = findFirst(); n != null; n = n.next) {
1575 basepred.next = z;
1677 for (Node<K,V> n = findFirst(); n != null; n = n.next) {
1703 for (Node<K,V> n = findFirst(); n != null; n = n.next) {
1808 * <tt>iterator.next()</tt> do <em>not</em> support the
2196 /** the last node returned by next() */
2198 /** the next node to return from next(); */
2199 Node<K,V> next;
2200 /** Cache of next value field to maintain weak consistency */
2206 next = findFirst();
2207 if (next == null)
2209 Object x = next.value;
2210 if (x != null && x != next) {
2218 return next != null;
2221 /** Advances next to higher entry. */
2223 if (next == null)
2225 lastReturned = next;
2227 next = next.next;
2228 if (next == null)
2230 Object x = next.value;
2231 if (x != null && x != next) {
2251 public V next() {
2259 public K next() {
2260 Node<K,V> n = next;
2267 public Map.Entry<K,V> next() {
2268 Node<K,V> n = next;
2754 n = n.next) {
2770 n = n.next) {
2781 n = n.next) {
3001 /** the last node returned by next() */
3003 /** the next node to return from next(); */
3004 Node<K,V> next;
3005 /** Cache of next value field to maintain weak consistency */
3010 next = isDescending ? hiNode() : loNode();
3011 if (next == null)
3013 Object x = next.value;
3014 if (x != null && x != next) {
3015 if (! inBounds(next.key))
3016 next = null;
3025 return next != null;
3029 if (next == null)
3031 lastReturned = next;
3040 next = next.next;
3041 if (next == null)
3043 Object x = next.value;
3044 if (x != null && x != next) {
3045 if (tooHigh(next.key))
3046 next = null;
3056 next = m.findNear(lastReturned.key, LT);
3057 if (next == null)
3059 Object x = next.value;
3060 if (x != null && x != next) {
3061 if (tooLow(next.key))
3062 next = null;
3081 public V next() {
3089 public K next() {
3090 Node<K,V> n = next;
3097 public Map.Entry<K,V> next() {
3098 Node<K,V> n = next;