skywang12345

导航

统计
  • 随笔 - 278
  • 文章 - 0
  • 评论 - 1180
  • 引用 - 0
 

 

概要

本章对Java.util.concurrent包中的ConcurrentSkipListMap类进行详细的介绍。内容包括:
ConcurrentSkipListMap介绍
ConcurrentSkipListMap原理和数据结构
ConcurrentSkipListMap函数列表
ConcurrentSkipListMap源码分析(JDK1.7.0_40版本)
ConcurrentSkipListMap示例

转载请注明出处:http://www.cnblogs.com/skywang12345/p/3498556.html

 

ConcurrentSkipListMap介绍

ConcurrentSkipListMap是线程安全的有序的哈希表,适用于高并发的场景。
ConcurrentSkipListMap和TreeMap,它们虽然都是有序的哈希表。但是,第一,它们的线程安全机制不同,TreeMap是非线程安全的,而ConcurrentSkipListMap是线程安全的。第二,ConcurrentSkipListMap是通过跳表实现的,而TreeMap是通过红黑树实现的。
关于跳表(Skip List),它是平衡树的一种替代的数据结构,但是和红黑树不相同的是,跳表对于树的平衡的实现是基于一种随机化的算法的,这样也就是说跳表的插入和删除的工作是比较简单的。

 

ConcurrentSkipListMap原理和数据结构

ConcurrentSkipListMap的数据结构,如下图所示:

说明

先以数据“7,14,21,32,37,71,85”序列为例,来对跳表进行简单说明。

跳表分为许多层(level),每一层都可以看作是数据的索引,这些索引的意义就是加快跳表查找数据速度。每一层的数据都是有序的,上一层数据是下一层数据的子集,并且第一层(level 1)包含了全部的数据;层次越高,跳跃性越大,包含的数据越少。
跳表包含一个表头,它查找数据时,是从上往下,从左往右进行查找。现在“需要找出值为32的节点”为例,来对比说明跳表和普遍的链表。

情况1:链表中查找“32”节点
路径如下图1-02所示:

需要4步(红色部分表示路径)。

 

情况2:跳表中查找“32”节点
路径如下图1-03所示:

忽略索引垂直线路上路径的情况下,只需要2步(红色部分表示路径)。


下面说说Java中ConcurrentSkipListMap的数据结构。
(01) ConcurrentSkipListMap继承于AbstractMap类,也就意味着它是一个哈希表。
(02) Index是ConcurrentSkipListMap的内部类,它与“跳表中的索引相对应”。HeadIndex继承于Index,ConcurrentSkipListMap中含有一个HeadIndex的对象head,head是“跳表的表头”。
(03) Index是跳表中的索引,它包含“右索引的指针(right)”,“下索引的指针(down)”和“哈希表节点node”。node是Node的对象,Node也是ConcurrentSkipListMap中的内部类。

 

ConcurrentSkipListMap函数列表

// 构造一个新的空映射,该映射按照键的自然顺序进行排序。
ConcurrentSkipListMap()
// 构造一个新的空映射,该映射按照指定的比较器进行排序。
ConcurrentSkipListMap(Comparator<? super K> comparator)
// 构造一个新映射,该映射所包含的映射关系与给定映射包含的映射关系相同,并按照键的自然顺序进行排序。
ConcurrentSkipListMap(Map<? extends K,? extends V> m)
// 构造一个新映射,该映射所包含的映射关系与指定的有序映射包含的映射关系相同,使用的顺序也相同。
ConcurrentSkipListMap(SortedMap<K,? extends V> m)

// 返回与大于等于给定键的最小键关联的键-值映射关系;如果不存在这样的条目,则返回 null。
Map.Entry<K,V> ceilingEntry(K key)
// 返回大于等于给定键的最小键;如果不存在这样的键,则返回 null。
K ceilingKey(K key)
// 从此映射中移除所有映射关系。
void clear()
// 返回此 ConcurrentSkipListMap 实例的浅表副本。
ConcurrentSkipListMap<K,V> clone()
// 返回对此映射中的键进行排序的比较器;如果此映射使用键的自然顺序,则返回 null。
Comparator<? super K> comparator()
// 如果此映射包含指定键的映射关系,则返回 true。
boolean containsKey(Object key)
// 如果此映射为指定值映射一个或多个键,则返回 true。
boolean containsValue(Object value)
// 返回此映射中所包含键的逆序 NavigableSet 视图。
NavigableSet<K> descendingKeySet()
// 返回此映射中所包含映射关系的逆序视图。
ConcurrentNavigableMap<K,V> descendingMap()
// 返回此映射中所包含的映射关系的 Set 视图。
Set<Map.Entry<K,V>> entrySet()
// 比较指定对象与此映射的相等性。
boolean equals(Object o)
// 返回与此映射中的最小键关联的键-值映射关系;如果该映射为空,则返回 null。
Map.Entry<K,V> firstEntry()
// 返回此映射中当前第一个(最低)键。
K firstKey()
// 返回与小于等于给定键的最大键关联的键-值映射关系;如果不存在这样的键,则返回 null。
Map.Entry<K,V> floorEntry(K key)
// 返回小于等于给定键的最大键;如果不存在这样的键,则返回 null。
K floorKey(K key)
// 返回指定键所映射到的值;如果此映射不包含该键的映射关系,则返回 null。
V get(Object key)
// 返回此映射的部分视图,其键值严格小于 toKey。
ConcurrentNavigableMap<K,V> headMap(K toKey)
// 返回此映射的部分视图,其键小于(或等于,如果 inclusive 为 true)toKey。
ConcurrentNavigableMap<K,V> headMap(K toKey, boolean inclusive)
// 返回与严格大于给定键的最小键关联的键-值映射关系;如果不存在这样的键,则返回 null。
Map.Entry<K,V> higherEntry(K key)
// 返回严格大于给定键的最小键;如果不存在这样的键,则返回 null。
K higherKey(K key)
// 如果此映射未包含键-值映射关系,则返回 true。
boolean isEmpty()
// 返回此映射中所包含键的 NavigableSet 视图。
NavigableSet<K> keySet()
// 返回与此映射中的最大键关联的键-值映射关系;如果该映射为空,则返回 null。
Map.Entry<K,V> lastEntry()
// 返回映射中当前最后一个(最高)键。
K lastKey()
// 返回与严格小于给定键的最大键关联的键-值映射关系;如果不存在这样的键,则返回 null。
Map.Entry<K,V> lowerEntry(K key)
// 返回严格小于给定键的最大键;如果不存在这样的键,则返回 null。
K lowerKey(K key)
// 返回此映射中所包含键的 NavigableSet 视图。
NavigableSet<K> navigableKeySet()
// 移除并返回与此映射中的最小键关联的键-值映射关系;如果该映射为空,则返回 null。
Map.Entry<K,V> pollFirstEntry()
// 移除并返回与此映射中的最大键关联的键-值映射关系;如果该映射为空,则返回 null。
Map.Entry<K,V> pollLastEntry()
// 将指定值与此映射中的指定键关联。
V put(K key, V value)
// 如果指定键已经不再与某个值相关联,则将它与给定值关联。
V putIfAbsent(K key, V value)
// 从此映射中移除指定键的映射关系(如果存在)。
V remove(Object key)
// 只有目前将键的条目映射到给定值时,才移除该键的条目。
boolean remove(Object key, Object value)
// 只有目前将键的条目映射到某一值时,才替换该键的条目。
V replace(K key, V value)
// 只有目前将键的条目映射到给定值时,才替换该键的条目。
boolean replace(K key, V oldValue, V newValue)
// 返回此映射中的键-值映射关系数。
int size()
// 返回此映射的部分视图,其键的范围从 fromKey 到 toKey。
ConcurrentNavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
// 返回此映射的部分视图,其键值的范围从 fromKey(包括)到 toKey(不包括)。
ConcurrentNavigableMap<K,V> subMap(K fromKey, K toKey)
// 返回此映射的部分视图,其键大于等于 fromKey。
ConcurrentNavigableMap<K,V> tailMap(K fromKey)
// 返回此映射的部分视图,其键大于(或等于,如果 inclusive 为 true)fromKey。
ConcurrentNavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
// 返回此映射中所包含值的 Collection 视图。
Collection<V> values()

 

ConcurrentSkipListMap源码分析(JDK1.7.0_40版本)

ConcurrentSkipListMap.java的完整源码如下:

   1 /*
   2  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
   3  *
   4  *
   5  *
   6  *
   7  *
   8  *
   9  *
  10  *
  11  *
  12  *
  13  *
  14  *
  15  *
  16  *
  17  *
  18  *
  19  *
  20  *
  21  *
  22  *
  23  */
  24 
  25 /*
  26  *
  27  *
  28  *
  29  *
  30  *
  31  * Written by Doug Lea with assistance from members of JCP JSR-166
  32  * Expert Group and released to the public domain, as explained at
  33  * http://creativecommons.org/publicdomain/zero/1.0/
  34  */
  35 
  36 package java.util.concurrent;
  37 import java.util.*;
  38 import java.util.concurrent.atomic.*;
  39 
  40 /**
  41  * A scalable concurrent {@link ConcurrentNavigableMap} implementation.
  42  * The map is sorted according to the {@linkplain Comparable natural
  43  * ordering} of its keys, or by a {@link Comparator} provided at map
  44  * creation time, depending on which constructor is used.
  45  *
  46  * <p>This class implements a concurrent variant of <a
  47  * href="http://en.wikipedia.org/wiki/Skip_list" target="_top">SkipLists</a>
  48  * providing expected average <i>log(n)</i> time cost for the
  49  * <tt>containsKey</tt>, <tt>get</tt>, <tt>put</tt> and
  50  * <tt>remove</tt> operations and their variants.  Insertion, removal,
  51  * update, and access operations safely execute concurrently by
  52  * multiple threads.  Iterators are <i>weakly consistent</i>, returning
  53  * elements reflecting the state of the map at some point at or since
  54  * the creation of the iterator.  They do <em>not</em> throw {@link
  55  * ConcurrentModificationException}, and may proceed concurrently with
  56  * other operations. Ascending key ordered views and their iterators
  57  * are faster than descending ones.
  58  *
  59  * <p>All <tt>Map.Entry</tt> pairs returned by methods in this class
  60  * and its views represent snapshots of mappings at the time they were
  61  * produced. They do <em>not</em> support the <tt>Entry.setValue</tt>
  62  * method. (Note however that it is possible to change mappings in the
  63  * associated map using <tt>put</tt>, <tt>putIfAbsent</tt>, or
  64  * <tt>replace</tt>, depending on exactly which effect you need.)
  65  *
  66  * <p>Beware that, unlike in most collections, the <tt>size</tt>
  67  * method is <em>not</em> a constant-time operation. Because of the
  68  * asynchronous nature of these maps, determining the current number
  69  * of elements requires a traversal of the elements, and so may report
  70  * inaccurate results if this collection is modified during traversal.
  71  * Additionally, the bulk operations <tt>putAll</tt>, <tt>equals</tt>,
  72  * <tt>toArray</tt>, <tt>containsValue</tt>, and <tt>clear</tt> are
  73  * <em>not</em> guaranteed to be performed atomically. For example, an
  74  * iterator operating concurrently with a <tt>putAll</tt> operation
  75  * might view only some of the added elements.
  76  *
  77  * <p>This class and its views and iterators implement all of the
  78  * <em>optional</em> methods of the {@link Map} and {@link Iterator}
  79  * interfaces. Like most other concurrent collections, this class does
  80  * <em>not</em> permit the use of <tt>null</tt> keys or values because some
  81  * null return values cannot be reliably distinguished from the absence of
  82  * elements.
  83  *
  84  * <p>This class is a member of the
  85  * <a href="{@docRoot}/../technotes/guides/collections/index.html">
  86  * Java Collections Framework</a>.
  87  *
  88  * @author Doug Lea
  89  * @param <K> the type of keys maintained by this map
  90  * @param <V> the type of mapped values
  91  * @since 1.6
  92  */
  93 public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
  94     implements ConcurrentNavigableMap<K,V>,
  95                Cloneable,
  96                java.io.Serializable {
  97     /*
  98      * This class implements a tree-like two-dimensionally linked skip
  99      * list in which the index levels are represented in separate
 100      * nodes from the base nodes holding data.  There are two reasons
 101      * for taking this approach instead of the usual array-based
 102      * structure: 1) Array based implementations seem to encounter
 103      * more complexity and overhead 2) We can use cheaper algorithms
 104      * for the heavily-traversed index lists than can be used for the
 105      * base lists.  Here's a picture of some of the basics for a
 106      * possible list with 2 levels of index:
 107      *
 108      * Head nodes          Index nodes
 109      * +-+    right        +-+                      +-+
 110      * |2|---------------->| |--------------------->| |->null
 111      * +-+                 +-+                      +-+
 112      *  | down              |                        |
 113      *  v                   v                        v
 114      * +-+            +-+  +-+       +-+            +-+       +-+
 115      * |1|----------->| |->| |------>| |----------->| |------>| |->null
 116      * +-+            +-+  +-+       +-+            +-+       +-+
 117      *  v              |    |         |              |         |
 118      * Nodes  next     v    v         v              v         v
 119      * +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+
 120      * | |->|A|->|B|->|C|->|D|->|E|->|F|->|G|->|H|->|I|->|J|->|K|->null
 121      * +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+
 122      *
 123      * The base lists use a variant of the HM linked ordered set
 124      * algorithm. See Tim Harris, "A pragmatic implementation of
 125      * non-blocking linked lists"
 126      * http://www.cl.cam.ac.uk/~tlh20/publications.html and Maged
 127      * Michael "High Performance Dynamic Lock-Free Hash Tables and
 128      * List-Based Sets"
 129      * http://www.research.ibm.com/people/m/michael/pubs.htm.  The
 130      * basic idea in these lists is to mark the "next" pointers of
 131      * deleted nodes when deleting to avoid conflicts with concurrent
 132      * insertions, and when traversing to keep track of triples
 133      * (predecessor, node, successor) in order to detect when and how
 134      * to unlink these deleted nodes.
 135      *
 136      * Rather than using mark-bits to mark list deletions (which can
 137      * be slow and space-intensive using AtomicMarkedReference), nodes
 138      * use direct CAS'able next pointers.  On deletion, instead of
 139      * marking a pointer, they splice in another node that can be
 140      * thought of as standing for a marked pointer (indicating this by
 141      * using otherwise impossible field values).  Using plain nodes
 142      * acts roughly like "boxed" implementations of marked pointers,
 143      * but uses new nodes only when nodes are deleted, not for every
 144      * link.  This requires less space and supports faster
 145      * traversal. Even if marked references were better supported by
 146      * JVMs, traversal using this technique might still be faster
 147      * because any search need only read ahead one more node than
 148      * otherwise required (to check for trailing marker) rather than
 149      * unmasking mark bits or whatever on each read.
 150      *
 151      * This approach maintains the essential property needed in the HM
 152      * algorithm of changing the next-pointer of a deleted node so
 153      * that any other CAS of it will fail, but implements the idea by
 154      * changing the pointer to point to a different node, not by
 155      * marking it.  While it would be possible to further squeeze
 156      * space by defining marker nodes not to have key/value fields, it
 157      * isn't worth the extra type-testing overhead.  The deletion
 158      * markers are rarely encountered during traversal and are
 159      * normally quickly garbage collected. (Note that this technique
 160      * would not work well in systems without garbage collection.)
 161      *
 162      * In addition to using deletion markers, the lists also use
 163      * nullness of value fields to indicate deletion, in a style
 164      * similar to typical lazy-deletion schemes.  If a node's value is
 165      * null, then it is considered logically deleted and ignored even
 166      * though it is still reachable. This maintains proper control of
 167      * concurrent replace vs delete operations -- an attempted replace
 168      * must fail if a delete beat it by nulling field, and a delete
 169      * must return the last non-null value held in the field. (Note:
 170      * Null, rather than some special marker, is used for value fields
 171      * here because it just so happens to mesh with the Map API
 172      * requirement that method get returns null if there is no
 173      * mapping, which allows nodes to remain concurrently readable
 174      * even when deleted. Using any other marker value here would be
 175      * messy at best.)
 176      *
 177      * Here's the sequence of events for a deletion of node n with
 178      * predecessor b and successor f, initially:
 179      *
 180      *        +------+       +------+      +------+
 181      *   ...  |   b  |------>|   n  |----->|   f  | ...
 182      *        +------+       +------+      +------+
 183      *
 184      * 1. CAS n's value field from non-null to null.
 185      *    From this point on, no public operations encountering
 186      *    the node consider this mapping to exist. However, other
 187      *    ongoing insertions and deletions might still modify
 188      *    n's next pointer.
 189      *
 190      * 2. CAS n's next pointer to point to a new marker node.
 191      *    From this point on, no other nodes can be appended to n.
 192      *    which avoids deletion errors in CAS-based linked lists.
 193      *
 194      *        +------+       +------+      +------+       +------+
 195      *   ...  |   b  |------>|   n  |----->|marker|------>|   f  | ...
 196      *        +------+       +------+      +------+       +------+
 197      *
 198      * 3. CAS b's next pointer over both n and its marker.
 199      *    From this point on, no new traversals will encounter n,
 200      *    and it can eventually be GCed.
 201      *        +------+                                    +------+
 202      *   ...  |   b  |----------------------------------->|   f  | ...
 203      *        +------+                                    +------+
 204      *
 205      * A failure at step 1 leads to simple retry due to a lost race
 206      * with another operation. Steps 2-3 can fail because some other
 207      * thread noticed during a traversal a node with null value and
 208      * helped out by marking and/or unlinking.  This helping-out
 209      * ensures that no thread can become stuck waiting for progress of
 210      * the deleting thread.  The use of marker nodes slightly
 211      * complicates helping-out code because traversals must track
 212      * consistent reads of up to four nodes (b, n, marker, f), not
 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
 215      * marker, it never again changes, so this requires less care.
 216      *
 217      * Skip lists add indexing to this scheme, so that the base-level
 218      * traversals start close to the locations being found, inserted
 219      * or deleted -- usually base level traversals only traverse a few
 220      * nodes. This doesn't change the basic algorithm except for the
 221      * need to make sure base traversals start at predecessors (here,
 222      * b) that are not (structurally) deleted, otherwise retrying
 223      * after processing the deletion.
 224      *
 225      * Index levels are maintained as lists with volatile next fields,
 226      * using CAS to link and unlink.  Races are allowed in index-list
 227      * operations that can (rarely) fail to link in a new index node
 228      * or delete one. (We can't do this of course for data nodes.)
 229      * However, even when this happens, the index lists remain sorted,
 230      * so correctly serve as indices.  This can impact performance,
 231      * but since skip lists are probabilistic anyway, the net result
 232      * is that under contention, the effective "p" value may be lower
 233      * than its nominal value. And race windows are kept small enough
 234      * that in practice these failures are rare, even under a lot of
 235      * contention.
 236      *
 237      * The fact that retries (for both base and index lists) are
 238      * relatively cheap due to indexing allows some minor
 239      * simplifications of retry logic. Traversal restarts are
 240      * performed after most "helping-out" CASes. This isn't always
 241      * strictly necessary, but the implicit backoffs tend to help
 242      * reduce other downstream failed CAS's enough to outweigh restart
 243      * cost.  This worsens the worst case, but seems to improve even
 244      * highly contended cases.
 245      *
 246      * Unlike most skip-list implementations, index insertion and
 247      * deletion here require a separate traversal pass occuring after
 248      * the base-level action, to add or remove index nodes.  This adds
 249      * to single-threaded overhead, but improves contended
 250      * multithreaded performance by narrowing interference windows,
 251      * and allows deletion to ensure that all index nodes will be made
 252      * unreachable upon return from a public remove operation, thus
 253      * avoiding unwanted garbage retention. This is more important
 254      * here than in some other data structures because we cannot null
 255      * out node fields referencing user keys since they might still be
 256      * read by other ongoing traversals.
 257      *
 258      * Indexing uses skip list parameters that maintain good search
 259      * performance while using sparser-than-usual indices: The
 260      * hardwired parameters k=1, p=0.5 (see method randomLevel) mean
 261      * that about one-quarter of the nodes have indices. Of those that
 262      * do, half have one level, a quarter have two, and so on (see
 263      * Pugh's Skip List Cookbook, sec 3.4).  The expected total space
 264      * requirement for a map is slightly less than for the current
 265      * implementation of java.util.TreeMap.
 266      *
 267      * Changing the level of the index (i.e, the height of the
 268      * tree-like structure) also uses CAS. The head index has initial
 269      * level/height of one. Creation of an index with height greater
 270      * than the current level adds a level to the head index by
 271      * CAS'ing on a new top-most head. To maintain good performance
 272      * after a lot of removals, deletion methods heuristically try to
 273      * reduce the height if the topmost levels appear to be empty.
 274      * This may encounter races in which it possible (but rare) to
 275      * reduce and "lose" a level just as it is about to contain an
 276      * index (that will then never be encountered). This does no
 277      * structural harm, and in practice appears to be a better option
 278      * than allowing unrestrained growth of levels.
 279      *
 280      * The code for all this is more verbose than you'd like. Most
 281      * operations entail locating an element (or position to insert an
 282      * element). The code to do this can't be nicely factored out
 283      * because subsequent uses require a snapshot of predecessor
 284      * and/or successor and/or value fields which can't be returned
 285      * all at once, at least not without creating yet another object
 286      * to hold them -- creating such little objects is an especially
 287      * bad idea for basic internal search operations because it adds
 288      * to GC overhead.  (This is one of the few times I've wished Java
 289      * had macros.) Instead, some traversal code is interleaved within
 290      * insertion and removal operations.  The control logic to handle
 291      * all the retry conditions is sometimes twisty. Most search is
 292      * broken into 2 parts. findPredecessor() searches index nodes
 293      * only, returning a base-level predecessor of the key. findNode()
 294      * finishes out the base-level search. Even with this factoring,
 295      * there is a fair amount of near-duplication of code to handle
 296      * variants.
 297      *
 298      * For explanation of algorithms sharing at least a couple of
 299      * features with this one, see Mikhail Fomitchev's thesis
 300      * (http://www.cs.yorku.ca/~mikhail/), Keir Fraser's thesis
 301      * (http://www.cl.cam.ac.uk/users/kaf24/), and Hakan Sundell's
 302      * thesis (http://www.cs.chalmers.se/~phs/).
 303      *
 304      * Given the use of tree-like index nodes, you might wonder why
 305      * this doesn't use some kind of search tree instead, which would
 306      * support somewhat faster search operations. The reason is that
 307      * there are no known efficient lock-free insertion and deletion
 308      * algorithms for search trees. The immutability of the "down"
 309      * links of index nodes (as opposed to mutable "left" fields in
 310      * true trees) makes this tractable using only CAS operations.
 311      *
 312      * Notation guide for local variables
 313      * Node:         b, n, f    for  predecessor, node, successor
 314      * Index:        q, r, d    for index node, right, down.
 315      *               t          for another index node
 316      * Head:         h
 317      * Levels:       j
 318      * Keys:         k, key
 319      * Values:       v, value
 320      * Comparisons:  c
 321      */
 322 
 323     private static final long serialVersionUID = -8627078645895051609L;
 324 
 325     /**
 326      * Generates the initial random seed for the cheaper per-instance
 327      * random number generators used in randomLevel.
 328      */
 329     private static final Random seedGenerator = new Random();
 330 
 331     /**
 332      * Special value used to identify base-level header
 333      */
 334     private static final Object BASE_HEADER = new Object();
 335 
 336     /**
 337      * The topmost head index of the skiplist.
 338      */
 339     private transient volatile HeadIndex<K,V> head;
 340 
 341     /**
 342      * The comparator used to maintain order in this map, or null
 343      * if using natural ordering.
 344      * @serial
 345      */
 346     private final Comparator<? super K> comparator;
 347 
 348     /**
 349      * Seed for simple random number generator.  Not volatile since it
 350      * doesn't matter too much if different threads don't see updates.
 351      */
 352     private transient int randomSeed;
 353 
 354     /** Lazily initialized key set */
 355     private transient KeySet keySet;
 356     /** Lazily initialized entry set */
 357     private transient EntrySet entrySet;
 358     /** Lazily initialized values collection */
 359     private transient Values values;
 360     /** Lazily initialized descending key set */
 361     private transient ConcurrentNavigableMap<K,V> descendingMap;
 362 
 363     /**
 364      * Initializes or resets state. Needed by constructors, clone,
 365      * clear, readObject. and ConcurrentSkipListSet.clone.
 366      * (Note that comparator must be separately initialized.)
 367      */
 368     final void initialize() {
 369         keySet = null;
 370         entrySet = null;
 371         values = null;
 372         descendingMap = null;
 373         randomSeed = seedGenerator.nextInt() | 0x0100; // ensure nonzero
 374         head = new HeadIndex<K,V>(new Node<K,V>(null, BASE_HEADER, null),
 375                                   null, null, 1);
 376     }
 377 
 378     /**
 379      * compareAndSet head node
 380      */
 381     private boolean casHead(HeadIndex<K,V> cmp, HeadIndex<K,V> val) {
 382         return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
 383     }
 384 
 385     /* ---------------- Nodes -------------- */
 386 
 387     /**
 388      * Nodes hold keys and values, and are singly linked in sorted
 389      * order, possibly with some intervening marker nodes. The list is
 390      * headed by a dummy node accessible as head.node. The value field
 391      * is declared only as Object because it takes special non-V
 392      * values for marker and header nodes.
 393      */
 394     static final class Node<K,V> {
 395         final K key;
 396         volatile Object value;
 397         volatile Node<K,V> next;
 398 
 399         /**
 400          * Creates a new regular node.
 401          */
 402         Node(K key, Object value, Node<K,V> next) {
 403             this.key = key;
 404             this.value = value;
 405             this.next = next;
 406         }
 407 
 408         /**
 409          * Creates a new marker node. A marker is distinguished by
 410          * having its value field point to itself.  Marker nodes also
 411          * have null keys, a fact that is exploited in a few places,
 412          * but this doesn't distinguish markers from the base-level
 413          * header node (head.node), which also has a null key.
 414          */
 415         Node(Node<K,V> next) {
 416             this.key = null;
 417             this.value = this;
 418             this.next = next;
 419         }
 420 
 421         /**
 422          * compareAndSet value field
 423          */
 424         boolean casValue(Object cmp, Object val) {
 425             return UNSAFE.compareAndSwapObject(this, valueOffset, cmp, val);
 426         }
 427 
 428         /**
 429          * compareAndSet next field
 430          */
 431         boolean casNext(Node<K,V> cmp, Node<K,V> val) {
 432             return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
 433         }
 434 
 435         /**
 436          * Returns true if this node is a marker. This method isn't
 437          * actually called in any current code checking for markers
 438          * because callers will have already read value field and need
 439          * to use that read (not another done here) and so directly
 440          * test if value points to node.
 441          * @param n a possibly null reference to a node
 442          * @return true if this node is a marker node
 443          */
 444         boolean isMarker() {
 445             return value == this;
 446         }
 447 
 448         /**
 449          * Returns true if this node is the header of base-level list.
 450          * @return true if this node is header node
 451          */
 452         boolean isBaseHeader() {
 453             return value == BASE_HEADER;
 454         }
 455 
 456         /**
 457          * Tries to append a deletion marker to this node.
 458          * @param f the assumed current successor of this node
 459          * @return true if successful
 460          */
 461         boolean appendMarker(Node<K,V> f) {
 462             return casNext(f, new Node<K,V>(f));
 463         }
 464 
 465         /**
 466          * Helps out a deletion by appending marker or unlinking from
 467          * predecessor. This is called during traversals when value
 468          * field seen to be null.
 469          * @param b predecessor
 470          * @param f successor
 471          */
 472         void helpDelete(Node<K,V> b, Node<K,V> f) {
 473             /*
 474              * Rechecking links and then doing only one of the
 475              * help-out stages per call tends to minimize CAS
 476              * interference among helping threads.
 477              */
 478             if (f == next && this == b.next) {
 479                 if (f == null || f.value != f) // not already marked
 480                     appendMarker(f);
 481                 else
 482                     b.casNext(this, f.next);
 483             }
 484         }
 485 
 486         /**
 487          * Returns value if this node contains a valid key-value pair,
 488          * else null.
 489          * @return this node's value if it isn't a marker or header or
 490          * is deleted, else null.
 491          */
 492         V getValidValue() {
 493             Object v = value;
 494             if (v == this || v == BASE_HEADER)
 495                 return null;
 496             return (V)v;
 497         }
 498 
 499         /**
 500          * Creates and returns a new SimpleImmutableEntry holding current
 501          * mapping if this node holds a valid value, else null.
 502          * @return new entry or null
 503          */
 504         AbstractMap.SimpleImmutableEntry<K,V> createSnapshot() {
 505             V v = getValidValue();
 506             if (v == null)
 507                 return null;
 508             return new AbstractMap.SimpleImmutableEntry<K,V>(key, v);
 509         }
 510 
 511         // UNSAFE mechanics
 512 
 513         private static final sun.misc.Unsafe UNSAFE;
 514         private static final long valueOffset;
 515         private static final long nextOffset;
 516 
 517         static {
 518             try {
 519                 UNSAFE = sun.misc.Unsafe.getUnsafe();
 520                 Class k = Node.class;
 521                 valueOffset = UNSAFE.objectFieldOffset
 522                     (k.getDeclaredField("value"));
 523                 nextOffset = UNSAFE.objectFieldOffset
 524                     (k.getDeclaredField("next"));
 525             } catch (Exception e) {
 526                 throw new Error(e);
 527             }
 528         }
 529     }
 530 
 531     /* ---------------- Indexing -------------- */
 532 
 533     /**
 534      * Index nodes represent the levels of the skip list.  Note that
 535      * even though both Nodes and Indexes have forward-pointing
 536      * fields, they have different types and are handled in different
 537      * ways, that can't nicely be captured by placing field in a
 538      * shared abstract class.
 539      */
 540     static class Index<K,V> {
 541         final Node<K,V> node;
 542         final Index<K,V> down;
 543         volatile Index<K,V> right;
 544 
 545         /**
 546          * Creates index node with given values.
 547          */
 548         Index(Node<K,V> node, Index<K,V> down, Index<K,V> right) {
 549             this.node = node;
 550             this.down = down;
 551             this.right = right;
 552         }
 553 
 554         /**
 555          * compareAndSet right field
 556          */
 557         final boolean casRight(Index<K,V> cmp, Index<K,V> val) {
 558             return UNSAFE.compareAndSwapObject(this, rightOffset, cmp, val);
 559         }
 560 
 561         /**
 562          * Returns true if the node this indexes has been deleted.
 563          * @return true if indexed node is known to be deleted
 564          */
 565         final boolean indexesDeletedNode() {
 566             return node.value == null;
 567         }
 568 
 569         /**
 570          * Tries to CAS newSucc as successor.  To minimize races with
 571          * unlink that may lose this index node, if the node being
 572          * indexed is known to be deleted, it doesn't try to link in.
 573          * @param succ the expected current successor
 574          * @param newSucc the new successor
 575          * @return true if successful
 576          */
 577         final boolean link(Index<K,V> succ, Index<K,V> newSucc) {
 578             Node<K,V> n = node;
 579             newSucc.right = succ;
 580             return n.value != null && casRight(succ, newSucc);
 581         }
 582 
 583         /**
 584          * Tries to CAS right field to skip over apparent successor
 585          * succ.  Fails (forcing a retraversal by caller) if this node
 586          * is known to be deleted.
 587          * @param succ the expected current successor
 588          * @return true if successful
 589          */
 590         final boolean unlink(Index<K,V> succ) {
 591             return !indexesDeletedNode() && casRight(succ, succ.right);
 592         }
 593 
 594         // Unsafe mechanics
 595         private static final sun.misc.Unsafe UNSAFE;
 596         private static final long rightOffset;
 597         static {
 598             try {
 599                 UNSAFE = sun.misc.Unsafe.getUnsafe();
 600                 Class k = Index.class;
 601                 rightOffset = UNSAFE.objectFieldOffset
 602                     (k.getDeclaredField("right"));
 603             } catch (Exception e) {
 604                 throw new Error(e);
 605             }
 606         }
 607     }
 608 
 609     /* ---------------- Head nodes -------------- */
 610 
 611     /**
 612      * Nodes heading each level keep track of their level.
 613      */
 614     static final class HeadIndex<K,V> extends Index<K,V> {
 615         final int level;
 616         HeadIndex(Node<K,V> node, Index<K,V> down, Index<K,V> right, int level) {
 617             super(node, down, right);
 618             this.level = level;
 619         }
 620     }
 621 
 622     /* ---------------- Comparison utilities -------------- */
 623 
 624     /**
 625      * Represents a key with a comparator as a Comparable.
 626      *
 627      * Because most sorted collections seem to use natural ordering on
 628      * Comparables (Strings, Integers, etc), most internal methods are
 629      * geared to use them. This is generally faster than checking
 630      * per-comparison whether to use comparator or comparable because
 631      * it doesn't require a (Comparable) cast for each comparison.
 632      * (Optimizers can only sometimes remove such redundant checks
 633      * themselves.) When Comparators are used,
 634      * ComparableUsingComparators are created so that they act in the
 635      * same way as natural orderings. This penalizes use of
 636      * Comparators vs Comparables, which seems like the right
 637      * tradeoff.
 638      */
 639     static final class ComparableUsingComparator<K> implements Comparable<K> {
 640         final K actualKey;
 641         final Comparator<? super K> cmp;
 642         ComparableUsingComparator(K key, Comparator<? super K> cmp) {
 643             this.actualKey = key;
 644             this.cmp = cmp;
 645         }
 646         public int compareTo(K k2) {
 647             return cmp.compare(actualKey, k2);
 648         }
 649     }
 650 
 651     /**
 652      * If using comparator, return a ComparableUsingComparator, else
 653      * cast key as Comparable, which may cause ClassCastException,
 654      * which is propagated back to caller.
 655      */
 656     private Comparable<? super K> comparable(Object key)
 657             throws ClassCastException {
 658         if (key == null)
 659             throw new NullPointerException();
 660         if (comparator != null)
 661             return new ComparableUsingComparator<K>((K)key, comparator);
 662         else
 663             return (Comparable<? super K>)key;
 664     }
 665 
 666     /**
 667      * Compares using comparator or natural ordering. Used when the
 668      * ComparableUsingComparator approach doesn't apply.
 669      */
 670     int compare(K k1, K k2) throws ClassCastException {
 671         Comparator<? super K> cmp = comparator;
 672         if (cmp != null)
 673             return cmp.compare(k1, k2);
 674         else
 675             return ((Comparable<? super K>)k1).compareTo(k2);
 676     }
 677 
 678     /**
 679      * Returns true if given key greater than or equal to least and
 680      * strictly less than fence, bypassing either test if least or
 681      * fence are null. Needed mainly in submap operations.
 682      */
 683     boolean inHalfOpenRange(K key, K least, K fence) {
 684         if (key == null)
 685             throw new NullPointerException();
 686         return ((least == null || compare(key, least) >= 0) &&
 687                 (fence == null || compare(key, fence) <  0));
 688     }
 689 
 690     /**
 691      * Returns true if given key greater than or equal to least and less
 692      * or equal to fence. Needed mainly in submap operations.
 693      */
 694     boolean inOpenRange(K key, K least, K fence) {
 695         if (key == null)
 696             throw new NullPointerException();
 697         return ((least == null || compare(key, least) >= 0) &&
 698                 (fence == null || compare(key, fence) <= 0));
 699     }
 700 
 701     /* ---------------- Traversal -------------- */
 702 
 703     /**
 704      * Returns a base-level node with key strictly less than given key,
 705      * or the base-level header if there is no such node.  Also
 706      * unlinks indexes to deleted nodes found along the way.  Callers
 707      * rely on this side-effect of clearing indices to deleted nodes.
 708      * @param key the key
 709      * @return a predecessor of key
 710      */
 711     private Node<K,V> findPredecessor(Comparable<? super K> key) {
 712         if (key == null)
 713             throw new NullPointerException(); // don't postpone errors
 714         for (;;) {
 715             Index<K,V> q = head;
 716             Index<K,V> r = q.right;
 717             for (;;) {
 718                 if (r != null) {
 719                     Node<K,V> n = r.node;
 720                     K k = n.key;
 721                     if (n.value == null) {
 722                         if (!q.unlink(r))
 723                             break;           // restart
 724                         r = q.right;         // reread r
 725                         continue;
 726                     }
 727                     if (key.compareTo(k) > 0) {
 728                         q = r;
 729                         r = r.right;
 730                         continue;
 731                     }
 732                 }
 733                 Index<K,V> d = q.down;
 734                 if (d != null) {
 735                     q = d;
 736                     r = d.right;
 737                 } else
 738                     return q.node;
 739             }
 740         }
 741     }
 742 
 743     /**
 744      * Returns node holding key or null if no such, clearing out any
 745      * deleted nodes seen along the way.  Repeatedly traverses at
 746      * base-level looking for key starting at predecessor returned
 747      * from findPredecessor, processing base-level deletions as
 748      * encountered. Some callers rely on this side-effect of clearing
 749      * deleted nodes.
 750      *
 751      * Restarts occur, at traversal step centered on node n, if:
 752      *
 753      *   (1) After reading n's next field, n is no longer assumed
 754      *       predecessor b's current successor, which means that
 755      *       we don't have a consistent 3-node snapshot and so cannot
 756      *       unlink any subsequent deleted nodes encountered.
 757      *
 758      *   (2) n's value field is null, indicating n is deleted, in
 759      *       which case we help out an ongoing structural deletion
 760      *       before retrying.  Even though there are cases where such
 761      *       unlinking doesn't require restart, they aren't sorted out
 762      *       here because doing so would not usually outweigh cost of
 763      *       restarting.
 764      *
 765      *   (3) n is a marker or n's predecessor's value field is null,
 766      *       indicating (among other possibilities) that
 767      *       findPredecessor returned a deleted node. We can't unlink
 768      *       the node because we don't know its predecessor, so rely
 769      *       on another call to findPredecessor to notice and return
 770      *       some earlier predecessor, which it will do. This check is
 771      *       only strictly needed at beginning of loop, (and the
 772      *       b.value check isn't strictly needed at all) but is done
 773      *       each iteration to help avoid contention with other
 774      *       threads by callers that will fail to be able to change
 775      *       links, and so will retry anyway.
 776      *
 777      * The traversal loops in doPut, doRemove, and findNear all
 778      * include the same three kinds of checks. And specialized
 779      * versions appear in findFirst, and findLast and their
 780      * variants. They can't easily share code because each uses the
 781      * reads of fields held in locals occurring in the orders they
 782      * were performed.
 783      *
 784      * @param key the key
 785      * @return node holding key, or null if no such
 786      */
 787     private Node<K,V> findNode(Comparable<? super K> key) {
 788         for (;;) {
 789             Node<K,V> b = findPredecessor(key);
 790             Node<K,V> n = b.next;
 791             for (;;) {
 792                 if (n == null)
 793                     return null;
 794                 Node<K,V> f = n.next;
 795                 if (n != b.next)                // inconsistent read
 796                     break;
 797                 Object v = n.value;
 798                 if (v == null) {                // n is deleted
 799                     n.helpDelete(b, f);
 800                     break;
 801                 }
 802                 if (v == n || b.value == null)  // b is deleted
 803                     break;
 804                 int c = key.compareTo(n.key);
 805                 if (c == 0)
 806                     return n;
 807                 if (c < 0)
 808                     return null;
 809                 b = n;
 810                 n = f;
 811             }
 812         }
 813     }
 814 
 815     /**
 816      * Gets value for key using findNode.
 817      * @param okey the key
 818      * @return the value, or null if absent
 819      */
 820     private V doGet(Object okey) {
 821         Comparable<? super K> key = comparable(okey);
 822         /*
 823          * Loop needed here and elsewhere in case value field goes
 824          * null just as it is about to be returned, in which case we
 825          * lost a race with a deletion, so must retry.
 826          */
 827         for (;;) {
 828             Node<K,V> n = findNode(key);
 829             if (n == null)
 830                 return null;
 831             Object v = n.value;
 832             if (v != null)
 833                 return (V)v;
 834         }
 835     }
 836 
 837     /* ---------------- Insertion -------------- */
 838 
 839     /**
 840      * Main insertion method.  Adds element if not present, or
 841      * replaces value if present and onlyIfAbsent is false.
 842      * @param kkey the key
 843      * @param value  the value that must be associated with key
 844      * @param onlyIfAbsent if should not insert if already present
 845      * @return the old value, or null if newly inserted
 846      */
 847     private V doPut(K kkey, V value, boolean onlyIfAbsent) {
 848         Comparable<? super K> key = comparable(kkey);
 849         for (;;) {
 850             Node<K,V> b = findPredecessor(key);
 851             Node<K,V> n = b.next;
 852             for (;;) {
 853                 if (n != null) {
 854                     Node<K,V> f = n.next;
 855                     if (n != b.next)               // inconsistent read
 856                         break;
 857                     Object v = n.value;
 858                     if (v == null) {               // n is deleted
 859                         n.helpDelete(b, f);
 860                         break;
 861                     }
 862                     if (v == n || b.value == null) // b is deleted
 863                         break;
 864                     int c = key.compareTo(n.key);
 865                     if (c > 0) {
 866                         b = n;
 867                         n = f;
 868                         continue;
 869                     }
 870                     if (c == 0) {
 871                         if (onlyIfAbsent || n.casValue(v, value))
 872                             return (V)v;
 873                         else
 874                             break; // restart if lost race to replace value
 875                     }
 876                     // else c < 0; fall through
 877                 }
 878 
 879                 Node<K,V> z = new Node<K,V>(kkey, value, n);
 880                 if (!b.casNext(n, z))
 881                     break;         // restart if lost race to append to b
 882                 int level = randomLevel();
 883                 if (level > 0)
 884                     insertIndex(z, level);
 885                 return null;
 886             }
 887         }
 888     }
 889 
 890     /**
 891      * Returns a random level for inserting a new node.
 892      * Hardwired to k=1, p=0.5, max 31 (see above and
 893      * Pugh's "Skip List Cookbook", sec 3.4).
 894      *
 895      * This uses the simplest of the generators described in George
 896      * Marsaglia's "Xorshift RNGs" paper.  This is not a high-quality
 897      * generator but is acceptable here.
 898      */
 899     private int randomLevel() {
 900         int x = randomSeed;
 901         x ^= x << 13;
 902         x ^= x >>> 17;
 903         randomSeed = x ^= x << 5;
 904         if ((x & 0x80000001) != 0) // test highest and lowest bits
 905             return 0;
 906         int level = 1;
 907         while (((x >>>= 1) & 1) != 0) ++level;
 908         return level;
 909     }
 910 
 911     /**
 912      * Creates and adds index nodes for the given node.
 913      * @param z the node
 914      * @param level the level of the index
 915      */
 916     private void insertIndex(Node<K,V> z, int level) {
 917         HeadIndex<K,V> h = head;
 918         int max = h.level;
 919 
 920         if (level <= max) {
 921             Index<K,V> idx = null;
 922             for (int i = 1; i <= level; ++i)
 923                 idx = new Index<K,V>(z, idx, null);
 924             addIndex(idx, h, level);
 925 
 926         } else { // Add a new level
 927             /*
 928              * To reduce interference by other threads checking for
 929              * empty levels in tryReduceLevel, new levels are added
 930              * with initialized right pointers. Which in turn requires
 931              * keeping levels in an array to access them while
 932              * creating new head index nodes from the opposite
 933              * direction.
 934              */
 935             level = max + 1;
 936             Index<K,V>[] idxs = (Index<K,V>[])new Index[level+1];
 937             Index<K,V> idx = null;
 938             for (int i = 1; i <= level; ++i)
 939                 idxs[i] = idx = new Index<K,V>(z, idx, null);
 940 
 941             HeadIndex<K,V> oldh;
 942             int k;
 943             for (;;) {
 944                 oldh = head;
 945                 int oldLevel = oldh.level;
 946                 if (level <= oldLevel) { // lost race to add level
 947                     k = level;
 948                     break;
 949                 }
 950                 HeadIndex<K,V> newh = oldh;
 951                 Node<K,V> oldbase = oldh.node;
 952                 for (int j = oldLevel+1; j <= level; ++j)
 953                     newh = new HeadIndex<K,V>(oldbase, newh, idxs[j], j);
 954                 if (casHead(oldh, newh)) {
 955                     k = oldLevel;
 956                     break;
 957                 }
 958             }
 959             addIndex(idxs[k], oldh, k);
 960         }
 961     }
 962 
 963     /**
 964      * Adds given index nodes from given level down to 1.
 965      * @param idx the topmost index node being inserted
 966      * @param h the value of head to use to insert. This must be
 967      * snapshotted by callers to provide correct insertion level
 968      * @param indexLevel the level of the index
 969      */
 970     private void addIndex(Index<K,V> idx, HeadIndex<K,V> h, int indexLevel) {
 971         // Track next level to insert in case of retries
 972         int insertionLevel = indexLevel;
 973         Comparable<? super K> key = comparable(idx.node.key);
 974         if (key == null) throw new NullPointerException();
 975 
 976         // Similar to findPredecessor, but adding index nodes along
 977         // path to key.
 978         for (;;) {
 979             int j = h.level;
 980             Index<K,V> q = h;
 981             Index<K,V> r = q.right;
 982             Index<K,V> t = idx;
 983             for (;;) {
 984                 if (r != null) {
 985                     Node<K,V> n = r.node;
 986                     // compare before deletion check avoids needing recheck
 987                     int c = key.compareTo(n.key);
 988                     if (n.value == null) {
 989                         if (!q.unlink(r))
 990                             break;
 991                         r = q.right;
 992                         continue;
 993                     }
 994                     if (c > 0) {
 995                         q = r;
 996                         r = r.right;
 997                         continue;
 998                     }
 999                 }
1000 
1001                 if (j == insertionLevel) {
1002                     // Don't insert index if node already deleted
1003                     if (t.indexesDeletedNode()) {
1004                         findNode(key); // cleans up
1005                         return;
1006                     }
1007                     if (!q.link(r, t))
1008                         break; // restart
1009                     if (--insertionLevel == 0) {
1010                         // need final deletion check before return
1011                         if (t.indexesDeletedNode())
1012                             findNode(key);
1013                         return;
1014                     }
1015                 }
1016 
1017                 if (--j >= insertionLevel && j < indexLevel)
1018                     t = t.down;
1019                 q = q.down;
1020                 r = q.right;
1021             }
1022         }
1023     }
1024 
1025     /* ---------------- Deletion -------------- */
1026 
1027     /**
1028      * Main deletion method. Locates node, nulls value, appends a
1029      * deletion marker, unlinks predecessor, removes associated index
1030      * nodes, and possibly reduces head index level.
1031      *
1032      * Index nodes are cleared out simply by calling findPredecessor.
1033      * which unlinks indexes to deleted nodes found along path to key,
1034      * which will include the indexes to this node.  This is done
1035      * unconditionally. We can't check beforehand whether there are
1036      * index nodes because it might be the case that some or all
1037      * indexes hadn't been inserted yet for this node during initial
1038      * search for it, and we'd like to ensure lack of garbage
1039      * retention, so must call to be sure.
1040      *
1041      * @param okey the key
1042      * @param value if non-null, the value that must be
1043      * associated with key
1044      * @return the node, or null if not found
1045      */
1046     final V doRemove(Object okey, Object value) {
1047         Comparable<? super K> key = comparable(okey);
1048         for (;;) {
1049             Node<K,V> b = findPredecessor(key);
1050             Node<K,V> n = b.next;
1051             for (;;) {
1052                 if (n == null)
1053                     return null;
1054                 Node<K,V> f = n.next;
1055                 if (n != b.next)                    // inconsistent read
1056                     break;
1057                 Object v = n.value;
1058                 if (v == null) {                    // n is deleted
1059                     n.helpDelete(b, f);
1060                     break;
1061                 }
1062                 if (v == n || b.value == null)      // b is deleted
1063                     break;
1064                 int c = key.compareTo(n.key);
1065                 if (c < 0)
1066                     return null;
1067                 if (c > 0) {
1068                     b = n;
1069                     n = f;
1070                     continue;
1071                 }
1072                 if (value != null && !value.equals(v))
1073                     return null;
1074                 if (!n.casValue(v, null))
1075                     break;
1076                 if (!n.appendMarker(f) || !b.casNext(n, f))
1077                     findNode(key);                  // Retry via findNode
1078                 else {
1079                     findPredecessor(key);           // Clean index
1080                     if (head.right == null)
1081                         tryReduceLevel();
1082                 }
1083                 return (V)v;
1084             }
1085         }
1086     }
1087 
1088     /**
1089      * Possibly reduce head level if it has no nodes.  This method can
1090      * (rarely) make mistakes, in which case levels can disappear even
1091      * though they are about to contain index nodes. This impacts
1092      * performance, not correctness.  To minimize mistakes as well as
1093      * to reduce hysteresis, the level is reduced by one only if the
1094      * topmost three levels look empty. Also, if the removed level
1095      * looks non-empty after CAS, we try to change it back quick
1096      * before anyone notices our mistake! (This trick works pretty
1097      * well because this method will practically never make mistakes
1098      * unless current thread stalls immediately before first CAS, in
1099      * which case it is very unlikely to stall again immediately
1100      * afterwards, so will recover.)
1101      *
1102      * We put up with all this rather than just let levels grow
1103      * because otherwise, even a small map that has undergone a large
1104      * number of insertions and removals will have a lot of levels,
1105      * slowing down access more than would an occasional unwanted
1106      * reduction.
1107      */
1108     private void tryReduceLevel() {
1109         HeadIndex<K,V> h = head;
1110         HeadIndex<K,V> d;
1111         HeadIndex<K,V> e;
1112         if (h.level > 3 &&
1113             (d = (HeadIndex<K,V>)h.down) != null &&
1114             (e = (HeadIndex<K,V>)d.down) != null &&
1115             e.right == null &&
1116             d.right == null &&
1117             h.right == null &&
1118             casHead(h, d) && // try to set
1119             h.right != null) // recheck
1120             casHead(d, h);   // try to backout
1121     }
1122 
1123     /* ---------------- Finding and removing first element -------------- */
1124 
1125     /**
1126      * Specialized variant of findNode to get first valid node.
1127      * @return first node or null if empty
1128      */
1129     Node<K,V> findFirst() {
1130         for (;;) {
1131             Node<K,V> b = head.node;
1132             Node<K,V> n = b.next;
1133             if (n == null)
1134                 return null;
1135             if (n.value != null)
1136                 return n;
1137             n.helpDelete(b, n.next);
1138         }
1139     }
1140 
1141     /**
1142      * Removes first entry; returns its snapshot.
1143      * @return null if empty, else snapshot of first entry
1144      */
1145     Map.Entry<K,V> doRemoveFirstEntry() {
1146         for (;;) {
1147             Node<K,V> b = head.node;
1148             Node<K,V> n = b.next;
1149             if (n == null)
1150                 return null;
1151             Node<K,V> f = n.next;
1152             if (n != b.next)
1153                 continue;
1154             Object v = n.value;
1155             if (v == null) {
1156                 n.helpDelete(b, f);
1157                 continue;
1158             }
1159             if (!n.casValue(v, null))
1160                 continue;
1161             if (!n.appendMarker(f) || !b.casNext(n, f))
1162                 findFirst(); // retry
1163             clearIndexToFirst();
1164             return new AbstractMap.SimpleImmutableEntry<K,V>(n.key, (V)v);
1165         }
1166     }
1167 
1168     /**
1169      * Clears out index nodes associated with deleted first entry.
1170      */
1171     private void clearIndexToFirst() {
1172         for (;;) {
1173             Index<K,V> q = head;
1174             for (;;) {
1175                 Index<K,V> r = q.right;
1176                 if (r != null && r.indexesDeletedNode() && !q.unlink(r))
1177                     break;
1178                 if ((q = q.down) == null) {
1179                     if (head.right == null)
1180                         tryReduceLevel();
1181                     return;
1182                 }
1183             }
1184         }
1185     }
1186 
1187 
1188     /* ---------------- Finding and removing last element -------------- */
1189 
1190     /**
1191      * Specialized version of find to get last valid node.
1192      * @return last node or null if empty
1193      */
1194     Node<K,V> findLast() {
1195         /*
1196          * findPredecessor can't be used to traverse index level
1197          * because this doesn't use comparisons.  So traversals of
1198          * both levels are folded together.
1199          */
1200         Index<K,V> q = head;
1201         for (;;) {
1202             Index<K,V> d, r;
1203             if ((r = q.right) != null) {
1204                 if (r.indexesDeletedNode()) {
1205                     q.unlink(r);
1206                     q = head; // restart
1207                 }
1208                 else
1209                     q = r;
1210             } else if ((d = q.down) != null) {
1211                 q = d;
1212             } else {
1213                 Node<K,V> b = q.node;
1214                 Node<K,V> n = b.next;
1215                 for (;;) {
1216                     if (n == null)
1217                         return b.isBaseHeader() ? null : b;
1218                     Node<K,V> f = n.next;            // inconsistent read
1219                     if (n != b.next)
1220                         break;
1221                     Object v = n.value;
1222                     if (v == null) {                 // n is deleted
1223                         n.helpDelete(b, f);
1224                         break;
1225                     }
1226                     if (v == n || b.value == null)   // b is deleted
1227                         break;
1228                     b = n;
1229                     n = f;
1230                 }
1231                 q = head; // restart
1232             }
1233         }
1234     }
1235 
1236     /**
1237      * Specialized variant of findPredecessor to get predecessor of last
1238      * valid node.  Needed when removing the last entry.  It is possible
1239      * that all successors of returned node will have been deleted upon
1240      * return, in which case this method can be retried.
1241      * @return likely predecessor of last node
1242      */
1243     private Node<K,V> findPredecessorOfLast() {
1244         for (;;) {
1245             Index<K,V> q = head;
1246             for (;;) {
1247                 Index<K,V> d, r;
1248                 if ((r = q.right) != null) {
1249                     if (r.indexesDeletedNode()) {
1250                         q.unlink(r);
1251                         break;    // must restart
1252                     }
1253                     // proceed as far across as possible without overshooting
1254                     if (r.node.next != null) {
1255                         q = r;
1256                         continue;
1257                     }
1258                 }
1259                 if ((d = q.down) != null)
1260                     q = d;
1261                 else
1262                     return q.node;
1263             }
1264         }
1265     }
1266 
1267     /**
1268      * Removes last entry; returns its snapshot.
1269      * Specialized variant of doRemove.
1270      * @return null if empty, else snapshot of last entry
1271      */
1272     Map.Entry<K,V> doRemoveLastEntry() {
1273         for (;;) {
1274             Node<K,V> b = findPredecessorOfLast();
1275             Node<K,V> n = b.next;
1276             if (n == null) {
1277                 if (b.isBaseHeader())               // empty
1278                     return null;
1279                 else
1280                     continue; // all b's successors are deleted; retry
1281             }
1282             for (;;) {
1283                 Node<K,V> f = n.next;
1284                 if (n != b.next)                    // inconsistent read
1285                     break;
1286                 Object v = n.value;
1287                 if (v == null) {                    // n is deleted
1288                     n.helpDelete(b, f);
1289                     break;
1290                 }
1291                 if (v == n || b.value == null)      // b is deleted
1292                     break;
1293                 if (f != null) {
1294                     b = n;
1295                     n = f;
1296                     continue;
1297                 }
1298                 if (!n.casValue(v, null))
1299                     break;
1300                 K key = n.key;
1301                 Comparable<? super K> ck = comparable(key);
1302                 if (!n.appendMarker(f) || !b.casNext(n, f))
1303                     findNode(ck);                  // Retry via findNode
1304                 else {
1305                     findPredecessor(ck);           // Clean index
1306                     if (head.right == null)
1307                         tryReduceLevel();
1308                 }
1309                 return new AbstractMap.SimpleImmutableEntry<K,V>(key, (V)v);
1310             }
1311         }
1312     }
1313 
1314     /* ---------------- Relational operations -------------- */
1315 
1316     // Control values OR'ed as arguments to findNear
1317 
1318     private static final int EQ = 1;
1319     private static final int LT = 2;
1320     private static final int GT = 0; // Actually checked as !LT
1321 
1322     /**
1323      * Utility for ceiling, floor, lower, higher methods.
1324      * @param kkey the key
1325      * @param rel the relation -- OR'ed combination of EQ, LT, GT
1326      * @return nearest node fitting relation, or null if no such
1327      */
1328     Node<K,V> findNear(K kkey, int rel) {
1329         Comparable<? super K> key = comparable(kkey);
1330         for (;;) {
1331             Node<K,V> b = findPredecessor(key);
1332             Node<K,V> n = b.next;
1333             for (;;) {
1334                 if (n == null)
1335                     return ((rel & LT) == 0 || b.isBaseHeader()) ? null : b;
1336                 Node<K,V> f = n.next;
1337                 if (n != b.next)                  // inconsistent read
1338                     break;
1339                 Object v = n.value;
1340                 if (v == null) {                  // n is deleted
1341                     n.helpDelete(b, f);
1342                     break;
1343                 }
1344                 if (v == n || b.value == null)    // b is deleted
1345                     break;
1346                 int c = key.compareTo(n.key);
1347                 if ((c == 0 && (rel & EQ) != 0) ||
1348                     (c <  0 && (rel & LT) == 0))
1349                     return n;
1350                 if ( c <= 0 && (rel & LT) != 0)
1351                     return b.isBaseHeader() ? null : b;
1352                 b = n;
1353                 n = f;
1354             }
1355         }
1356     }
1357 
1358     /**
1359      * Returns SimpleImmutableEntry for results of findNear.
1360      * @param key the key
1361      * @param rel the relation -- OR'ed combination of EQ, LT, GT
1362      * @return Entry fitting relation, or null if no such
1363      */
1364     AbstractMap.SimpleImmutableEntry<K,V> getNear(K key, int rel) {
1365         for (;;) {
1366             Node<K,V> n = findNear(key, rel);
1367             if (n == null)
1368                 return null;
1369             AbstractMap.SimpleImmutableEntry<K,V> e = n.createSnapshot();
1370             if (e != null)
1371                 return e;
1372         }
1373     }
1374 
1375 
1376     /* ---------------- Constructors -------------- */
1377 
1378     /**
1379      * Constructs a new, empty map, sorted according to the
1380      * {@linkplain Comparable natural ordering} of the keys.
1381      */
1382     public ConcurrentSkipListMap() {
1383         this.comparator = null;
1384         initialize();
1385     }
1386 
1387     /**
1388      * Constructs a new, empty map, sorted according to the specified
1389      * comparator.
1390      *
1391      * @param comparator the comparator that will be used to order this map.
1392      *        If <tt>null</tt>, the {@linkplain Comparable natural
1393      *        ordering} of the keys will be used.
1394      */
1395     public ConcurrentSkipListMap(Comparator<? super K> comparator) {
1396         this.comparator = comparator;
1397         initialize();
1398     }
1399 
1400     /**
1401      * Constructs a new map containing the same mappings as the given map,
1402      * sorted according to the {@linkplain Comparable natural ordering} of
1403      * the keys.
1404      *
1405      * @param  m the map whose mappings are to be placed in this map
1406      * @throws ClassCastException if the keys in <tt>m</tt> are not
1407      *         {@link Comparable}, or are not mutually comparable
1408      * @throws NullPointerException if the specified map or any of its keys
1409      *         or values are null
1410      */
1411     public ConcurrentSkipListMap(Map<? extends K, ? extends V> m) {
1412         this.comparator = null;
1413         initialize();
1414         putAll(m);
1415     }
1416 
1417     /**
1418      * Constructs a new map containing the same mappings and using the
1419      * same ordering as the specified sorted map.
1420      *
1421      * @param m the sorted map whose mappings are to be placed in this
1422      *        map, and whose comparator is to be used to sort this map
1423      * @throws NullPointerException if the specified sorted map or any of
1424      *         its keys or values are null
1425      */
1426     public ConcurrentSkipListMap(SortedMap<K, ? extends V> m) {
1427         this.comparator = m.comparator();
1428         initialize();
1429         buildFromSorted(m);
1430     }
1431 
1432     /**
1433      * Returns a shallow copy of this <tt>ConcurrentSkipListMap</tt>
1434      * instance. (The keys and values themselves are not cloned.)
1435      *
1436      * @return a shallow copy of this map
1437      */
1438     public ConcurrentSkipListMap<K,V> clone() {
1439         ConcurrentSkipListMap<K,V> clone = null;
1440         try {
1441             clone = (ConcurrentSkipListMap<K,V>) super.clone();
1442         } catch (CloneNotSupportedException e) {
1443             throw new InternalError();
1444         }
1445 
1446         clone.initialize();
1447         clone.buildFromSorted(this);
1448         return clone;
1449     }
1450 
1451     /**
1452      * Streamlined bulk insertion to initialize from elements of
1453      * given sorted map.  Call only from constructor or clone
1454      * method.
1455      */
1456     private void buildFromSorted(SortedMap<K, ? extends V> map) {
1457         if (map == null)
1458             throw new NullPointerException();
1459 
1460         HeadIndex<K,V> h = head;
1461         Node<K,V> basepred = h.node;
1462 
1463         // Track the current rightmost node at each level. Uses an
1464         // ArrayList to avoid committing to initial or maximum level.
1465         ArrayList<Index<K,V>> preds = new ArrayList<Index<K,V>>();
1466 
1467         // initialize
1468         for (int i = 0; i <= h.level; ++i)
1469             preds.add(null);
1470         Index<K,V> q = h;
1471         for (int i = h.level; i > 0; --i) {
1472             preds.set(i, q);
1473             q = q.down;
1474         }
1475 
1476         Iterator<? extends Map.Entry<? extends K, ? extends V>> it =
1477             map.entrySet().iterator();
1478         while (it.hasNext()) {
1479             Map.Entry<? extends K, ? extends V> e = it.next();
1480             int j = randomLevel();
1481             if (j > h.level) j = h.level + 1;
1482             K k = e.getKey();
1483             V v = e.getValue();
1484             if (k == null || v == null)
1485                 throw new NullPointerException();
1486             Node<K,V> z = new Node<K,V>(k, v, null);
1487             basepred.next = z;
1488             basepred = z;
1489             if (j > 0) {
1490                 Index<K,V> idx = null;
1491                 for (int i = 1; i <= j; ++i) {
1492                     idx = new Index<K,V>(z, idx, null);
1493                     if (i > h.level)
1494                         h = new HeadIndex<K,V>(h.node, h, idx, i);
1495 
1496                     if (i < preds.size()) {
1497                         preds.get(i).right = idx;
1498                         preds.set(i, idx);
1499                     } else
1500                         preds.add(idx);
1501                 }
1502             }
1503         }
1504         head = h;
1505     }
1506 
1507     /* ---------------- Serialization -------------- */
1508 
1509     /**
1510      * Save the state of this map to a stream.
1511      *
1512      * @serialData The key (Object) and value (Object) for each
1513      * key-value mapping represented by the map, followed by
1514      * <tt>null</tt>. The key-value mappings are emitted in key-order
1515      * (as determined by the Comparator, or by the keys' natural
1516      * ordering if no Comparator).
1517      */
1518     private void writeObject(java.io.ObjectOutputStream s)
1519         throws java.io.IOException {
1520         // Write out the Comparator and any hidden stuff
1521         s.defaultWriteObject();
1522 
1523         // Write out keys and values (alternating)
1524         for (Node<K,V> n = findFirst(); n != null; n = n.next) {
1525             V v = n.getValidValue();
1526             if (v != null) {
1527                 s.writeObject(n.key);
1528                 s.writeObject(v);
1529             }
1530         }
1531         s.writeObject(null);
1532     }
1533 
1534     /**
1535      * Reconstitute the map from a stream.
1536      */
1537     private void readObject(final java.io.ObjectInputStream s)
1538         throws java.io.IOException, ClassNotFoundException {
1539         // Read in the Comparator and any hidden stuff
1540         s.defaultReadObject();
1541         // Reset transients
1542         initialize();
1543 
1544         /*
1545          * This is nearly identical to buildFromSorted, but is
1546          * distinct because readObject calls can't be nicely adapted
1547          * as the kind of iterator needed by buildFromSorted. (They
1548          * can be, but doing so requires type cheats and/or creation
1549          * of adaptor classes.) It is simpler to just adapt the code.
1550          */
1551 
1552         HeadIndex<K,V> h = head;
1553         Node<K,V> basepred = h.node;
1554         ArrayList<Index<K,V>> preds = new ArrayList<Index<K,V>>();
1555         for (int i = 0; i <= h.level; ++i)
1556             preds.add(null);
1557         Index<K,V> q = h;
1558         for (int i = h.level; i > 0; --i) {
1559             preds.set(i, q);
1560             q = q.down;
1561         }
1562 
1563         for (;;) {
1564             Object k = s.readObject();
1565             if (k == null)
1566                 break;
1567             Object v = s.readObject();
1568             if (v == null)
1569                 throw new NullPointerException();
1570             K key = (K) k;
1571             V val = (V) v;
1572             int j = randomLevel();
1573             if (j > h.level) j = h.level + 1;
1574             Node<K,V> z = new Node<K,V>(key, val, null);
1575             basepred.next = z;
1576             basepred = z;
1577             if (j > 0) {
1578                 Index<K,V> idx = null;
1579                 for (int i = 1; i <= j; ++i) {
1580                     idx = new Index<K,V>(z, idx, null);
1581                     if (i > h.level)
1582                         h = new HeadIndex<K,V>(h.node, h, idx, i);
1583 
1584                     if (i < preds.size()) {
1585                         preds.get(i).right = idx;
1586                         preds.set(i, idx);
1587                     } else
1588                         preds.add(idx);
1589                 }
1590             }
1591         }
1592         head = h;
1593     }
1594 
1595     /* ------ Map API methods ------ */
1596 
1597     /**
1598      * Returns <tt>true</tt> if this map contains a mapping for the specified
1599      * key.
1600      *
1601      * @param key key whose presence in this map is to be tested
1602      * @return <tt>true</tt> if this map contains a mapping for the specified key
1603      * @throws ClassCastException if the specified key cannot be compared
1604      *         with the keys currently in the map
1605      * @throws NullPointerException if the specified key is null
1606      */
1607     public boolean containsKey(Object key) {
1608         return doGet(key) != null;
1609     }
1610 
1611     /**
1612      * Returns the value to which the specified key is mapped,
1613      * or {@code null} if this map contains no mapping for the key.
1614      *
1615      * <p>More formally, if this map contains a mapping from a key
1616      * {@code k} to a value {@code v} such that {@code key} compares
1617      * equal to {@code k} according to the map's ordering, then this
1618      * method returns {@code v}; otherwise it returns {@code null}.
1619      * (There can be at most one such mapping.)
1620      *
1621      * @throws ClassCastException if the specified key cannot be compared
1622      *         with the keys currently in the map
1623      * @throws NullPointerException if the specified key is null
1624      */
1625     public V get(Object key) {
1626         return doGet(key);
1627     }
1628 
1629     /**
1630      * Associates the specified value with the specified key in this map.
1631      * If the map previously contained a mapping for the key, the old
1632      * value is replaced.
1633      *
1634      * @param key key with which the specified value is to be associated
1635      * @param value value to be associated with the specified key
1636      * @return the previous value associated with the specified key, or
1637      *         <tt>null</tt> if there was no mapping for the key
1638      * @throws ClassCastException if the specified key cannot be compared
1639      *         with the keys currently in the map
1640      * @throws NullPointerException if the specified key or value is null
1641      */
1642     public V put(K key, V value) {
1643         if (value == null)
1644             throw new NullPointerException();
1645         return doPut(key, value, false);
1646     }
1647 
1648     /**
1649      * Removes the mapping for the specified key from this map if present.
1650      *
1651      * @param  key key for which mapping should be removed
1652      * @return the previous value associated with the specified key, or
1653      *         <tt>null</tt> if there was no mapping for the key
1654      * @throws ClassCastException if the specified key cannot be compared
1655      *         with the keys currently in the map
1656      * @throws NullPointerException if the specified key is null
1657      */
1658     public V remove(Object key) {
1659         return doRemove(key, null);
1660     }
1661 
1662     /**
1663      * Returns <tt>true</tt> if this map maps one or more keys to the
1664      * specified value.  This operation requires time linear in the
1665      * map size. Additionally, it is possible for the map to change
1666      * during execution of this method, in which case the returned
1667      * result may be inaccurate.
1668      *
1669      * @param value value whose presence in this map is to be tested
1670      * @return <tt>true</tt> if a mapping to <tt>value</tt> exists;
1671      *         <tt>false</tt> otherwise
1672      * @throws NullPointerException if the specified value is null
1673      */
1674     public boolean containsValue(Object value) {
1675         if (value == null)
1676             throw new NullPointerException();
1677         for (Node<K,V> n = findFirst(); n != null; n = n.next) {
1678             V v = n.getValidValue();
1679             if (v != null && value.equals(v))
1680                 return true;
1681         }
1682         return false;
1683     }
1684 
1685     /**
1686      * Returns the number of key-value mappings in this map.  If this map
1687      * contains more than <tt>Integer.MAX_VALUE</tt> elements, it
1688      * returns <tt>Integer.MAX_VALUE</tt>.
1689      *
1690      * <p>Beware that, unlike in most collections, this method is
1691      * <em>NOT</em> a constant-time operation. Because of the
1692      * asynchronous nature of these maps, determining the current
1693      * number of elements requires traversing them all to count them.
1694      * Additionally, it is possible for the size to change during
1695      * execution of this method, in which case the returned result
1696      * will be inaccurate. Thus, this method is typically not very
1697      * useful in concurrent applications.
1698      *
1699      * @return the number of elements in this map
1700      */
1701     public int size() {
1702         long count = 0;
1703         for (Node<K,V> n = findFirst(); n != null; n = n.next) {
1704             if (n.getValidValue() != null)
1705                 ++count;
1706         }
1707         return (count >= Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) count;
1708     }
1709 
1710     /**
1711      * Returns <tt>true</tt> if this map contains no key-value mappings.
1712      * @return <tt>true</tt> if this map contains no key-value mappings
1713      */
1714     public boolean isEmpty() {
1715         return findFirst() == null;
1716     }
1717 
1718     /**
1719      * Removes all of the mappings from this map.
1720      */
1721     public void clear() {
1722         initialize();
1723     }
1724 
1725     /* ---------------- View methods -------------- */
1726 
1727     /*
1728      * Note: Lazy initialization works for views because view classes
1729      * are stateless/immutable so it doesn't matter wrt correctness if
1730      * more than one is created (which will only rarely happen).  Even
1731      * so, the following idiom conservatively ensures that the method
1732      * returns the one it created if it does so, not one created by
1733      * another racing thread.
1734      */
1735 
1736     /**
1737      * Returns a {@link NavigableSet} view of the keys contained in this map.
1738      * The set's iterator returns the keys in ascending order.
1739      * The set is backed by the map, so changes to the map are
1740      * reflected in the set, and vice-versa.  The set supports element
1741      * removal, which removes the corresponding mapping from the map,
1742      * via the {@code Iterator.remove}, {@code Set.remove},
1743      * {@code removeAll}, {@code retainAll}, and {@code clear}
1744      * operations.  It does not support the {@code add} or {@code addAll}
1745      * operations.
1746      *
1747      * <p>The view's {@code iterator} is a "weakly consistent" iterator
1748      * that will never throw {@link ConcurrentModificationException},
1749      * and guarantees to traverse elements as they existed upon
1750      * construction of the iterator, and may (but is not guaranteed to)
1751      * reflect any modifications subsequent to construction.
1752      *
1753      * <p>This method is equivalent to method {@code navigableKeySet}.
1754      *
1755      * @return a navigable set view of the keys in this map
1756      */
1757     public NavigableSet<K> keySet() {
1758         KeySet ks = keySet;
1759         return (ks != null) ? ks : (keySet = new KeySet(this));
1760     }
1761 
1762     public NavigableSet<K> navigableKeySet() {
1763         KeySet ks = keySet;
1764         return (ks != null) ? ks : (keySet = new KeySet(this));
1765     }
1766 
1767     /**
1768      * Returns a {@link Collection} view of the values contained in this map.
1769      * The collection's iterator returns the values in ascending order
1770      * of the corresponding keys.
1771      * The collection is backed by the map, so changes to the map are
1772      * reflected in the collection, and vice-versa.  The collection
1773      * supports element removal, which removes the corresponding
1774      * mapping from the map, via the <tt>Iterator.remove</tt>,
1775      * <tt>Collection.remove</tt>, <tt>removeAll</tt>,
1776      * <tt>retainAll</tt> and <tt>clear</tt> operations.  It does not
1777      * support the <tt>add</tt> or <tt>addAll</tt> operations.
1778      *
1779      * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
1780      * that will never throw {@link ConcurrentModificationException},
1781      * and guarantees to traverse elements as they existed upon
1782      * construction of the iterator, and may (but is not guaranteed to)
1783      * reflect any modifications subsequent to construction.
1784      */
1785     public Collection<V> values() {
1786         Values vs = values;
1787         return (vs != null) ? vs : (values = new Values(this));
1788     }
1789 
1790     /**
1791      * Returns a {@link Set} view of the mappings contained in this map.
1792      * The set's iterator returns the entries in ascending key order.
1793      * The set is backed by the map, so changes to the map are
1794      * reflected in the set, and vice-versa.  The set supports element
1795      * removal, which removes the corresponding mapping from the map,
1796      * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
1797      * <tt>removeAll</tt>, <tt>retainAll</tt> and <tt>clear</tt>
1798      * operations.  It does not support the <tt>add</tt> or
1799      * <tt>addAll</tt> operations.
1800      *
1801      * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
1802      * that will never throw {@link ConcurrentModificationException},
1803      * and guarantees to traverse elements as they existed upon
1804      * construction of the iterator, and may (but is not guaranteed to)
1805      * reflect any modifications subsequent to construction.
1806      *
1807      * <p>The <tt>Map.Entry</tt> elements returned by
1808      * <tt>iterator.next()</tt> do <em>not</em> support the
1809      * <tt>setValue</tt> operation.
1810      *
1811      * @return a set view of the mappings contained in this map,
1812      *         sorted in ascending key order
1813      */
1814     public Set<Map.Entry<K,V>> entrySet() {
1815         EntrySet es = entrySet;
1816         return (es != null) ? es : (entrySet = new EntrySet(this));
1817     }
1818 
1819     public ConcurrentNavigableMap<K,V> descendingMap() {
1820         ConcurrentNavigableMap<K,V> dm = descendingMap;
1821         return (dm != null) ? dm : (descendingMap = new SubMap<K,V>
1822                                     (this, null, false, null, false, true));
1823     }
1824 
1825     public NavigableSet<K> descendingKeySet() {
1826         return descendingMap().navigableKeySet();
1827     }
1828 
1829     /* ---------------- AbstractMap Overrides -------------- */
1830 
1831     /**
1832      * Compares the specified object with this map for equality.
1833      * Returns <tt>true</tt> if the given object is also a map and the
1834      * two maps represent the same mappings.  More formally, two maps
1835      * <tt>m1</tt> and <tt>m2</tt> represent the same mappings if
1836      * <tt>m1.entrySet().equals(m2.entrySet())</tt>.  This
1837      * operation may return misleading results if either map is
1838      * concurrently modified during execution of this method.
1839      *
1840      * @param o object to be compared for equality with this map
1841      * @return <tt>true</tt> if the specified object is equal to this map
1842      */
1843     public boolean equals(Object o) {
1844         if (o == this)
1845             return true;
1846         if (!(o instanceof Map))
1847             return false;
1848         Map<?,?> m = (Map<?,?>) o;
1849         try {
1850             for (Map.Entry<K,V> e : this.entrySet())
1851                 if (! e.getValue().equals(m.get(e.getKey())))
1852                     return false;
1853             for (Map.Entry<?,?> e : m.entrySet()) {
1854                 Object k = e.getKey();
1855                 Object v = e.getValue();
1856                 if (k == null || v == null || !v.equals(get(k)))
1857                     return false;
1858             }
1859             return true;
1860         } catch (ClassCastException unused) {
1861             return false;
1862         } catch (NullPointerException unused) {
1863             return false;
1864         }
1865     }
1866 
1867     /* ------ ConcurrentMap API methods ------ */
1868 
1869     /**
1870      * {@inheritDoc}
1871      *
1872      * @return the previous value associated with the specified key,
1873      *         or <tt>null</tt> if there was no mapping for the key
1874      * @throws ClassCastException if the specified key cannot be compared
1875      *         with the keys currently in the map
1876      * @throws NullPointerException if the specified key or value is null
1877      */
1878     public V putIfAbsent(K key, V value) {
1879         if (value == null)
1880             throw new NullPointerException();
1881         return doPut(key, value, true);
1882     }
1883 
1884     /**
1885      * {@inheritDoc}
1886      *
1887      * @throws ClassCastException if the specified key cannot be compared
1888      *         with the keys currently in the map
1889      * @throws NullPointerException if the specified key is null
1890      */
1891     public boolean remove(Object key, Object value) {
1892         if (key == null)
1893             throw new NullPointerException();
1894         if (value == null)
1895             return false;
1896         return doRemove(key, value) != null;
1897     }
1898 
1899     /**
1900      * {@inheritDoc}
1901      *
1902      * @throws ClassCastException if the specified key cannot be compared
1903      *         with the keys currently in the map
1904      * @throws NullPointerException if any of the arguments are null
1905      */
1906     public boolean replace(K key, V oldValue, V newValue) {
1907         if (oldValue == null || newValue == null)
1908             throw new NullPointerException();
1909         Comparable<? super K> k = comparable(key);
1910         for (;;) {
1911             Node<K,V> n = findNode(k);
1912             if (n == null)
1913                 return false;
1914             Object v = n.value;
1915             if (v != null) {
1916                 if (!oldValue.equals(v))
1917                     return false;
1918                 if (n.casValue(v, newValue))
1919                     return true;
1920             }
1921         }
1922     }
1923 
1924     /**
1925      * {@inheritDoc}
1926      *
1927      * @return the previous value associated with the specified key,
1928      *         or <tt>null</tt> if there was no mapping for the key
1929      * @throws ClassCastException if the specified key cannot be compared
1930      *         with the keys currently in the map
1931      * @throws NullPointerException if the specified key or value is null
1932      */
1933     public V replace(K key, V value) {
1934         if (value == null)
1935             throw new NullPointerException();
1936         Comparable<? super K> k = comparable(key);
1937         for (;;) {
1938             Node<K,V> n = findNode(k);
1939             if (n == null)
1940                 return null;
1941             Object v = n.value;
1942             if (v != null && n.casValue(v, value))
1943                 return (V)v;
1944         }
1945     }
1946 
1947     /* ------ SortedMap API methods ------ */
1948 
1949     public Comparator<? super K> comparator() {
1950         return comparator;
1951     }
1952 
1953     /**
1954      * @throws NoSuchElementException {@inheritDoc}
1955      */
1956     public K firstKey() {
1957         Node<K,V> n = findFirst();
1958         if (n == null)
1959             throw new NoSuchElementException();
1960         return n.key;
1961     }
1962 
1963     /**
1964      * @throws NoSuchElementException {@inheritDoc}
1965      */
1966     public K lastKey() {
1967         Node<K,V> n = findLast();
1968         if (n == null)
1969             throw new NoSuchElementException();
1970         return n.key;
1971     }
1972 
1973     /**
1974      * @throws ClassCastException {@inheritDoc}
1975      * @throws NullPointerException if {@code fromKey} or {@code toKey} is null
1976      * @throws IllegalArgumentException {@inheritDoc}
1977      */
1978     public ConcurrentNavigableMap<K,V> subMap(K fromKey,
1979                                               boolean fromInclusive,
1980                                               K toKey,
1981                                               boolean toInclusive) {
1982         if (fromKey == null || toKey == null)
1983             throw new NullPointerException();
1984         return new SubMap<K,V>
1985             (this, fromKey, fromInclusive, toKey, toInclusive, false);
1986     }
1987 
1988     /**
1989      * @throws ClassCastException {@inheritDoc}
1990      * @throws NullPointerException if {@code toKey} is null
1991      * @throws IllegalArgumentException {@inheritDoc}
1992      */
1993     public ConcurrentNavigableMap<K,V> headMap(K toKey,
1994                                                boolean inclusive) {
1995         if (toKey == null)
1996             throw new NullPointerException();
1997         return new SubMap<K,V>
1998             (this, null, false, toKey, inclusive, false);
1999     }
2000 
2001     /**
2002      * @throws ClassCastException {@inheritDoc}
2003      * @throws NullPointerException if {@code fromKey} is null
2004      * @throws IllegalArgumentException {@inheritDoc}
2005      */
2006     public ConcurrentNavigableMap<K,V> tailMap(K fromKey,
2007                                                boolean inclusive) {
2008         if (fromKey == null)
2009             throw new NullPointerException();
2010         return new SubMap<K,V>
2011             (this, fromKey, inclusive, null, false, false);
2012     }
2013 
2014     /**
2015      * @throws ClassCastException {@inheritDoc}
2016      * @throws NullPointerException if {@code fromKey} or {@code toKey} is null
2017      * @throws IllegalArgumentException {@inheritDoc}
2018      */
2019     public ConcurrentNavigableMap<K,V> subMap(K fromKey, K toKey) {
2020         return subMap(fromKey, true, toKey, false);
2021     }
2022 
2023     /**
2024      * @throws ClassCastException {@inheritDoc}
2025      * @throws NullPointerException if {@code toKey} is null
2026      * @throws IllegalArgumentException {@inheritDoc}
2027      */
2028     public ConcurrentNavigableMap<K,V> headMap(K toKey) {
2029         return headMap(toKey, false);
2030     }
2031 
2032     /**
2033      * @throws ClassCastException {@inheritDoc}
2034      * @throws NullPointerException if {@code fromKey} is null
2035      * @throws IllegalArgumentException {@inheritDoc}
2036      */
2037     public ConcurrentNavigableMap<K,V> tailMap(K fromKey) {
2038         return tailMap(fromKey, true);
2039     }
2040 
2041     /* ---------------- Relational operations -------------- */
2042 
2043     /**
2044      * Returns a key-value mapping associated with the greatest key
2045      * strictly less than the given key, or <tt>null</tt> if there is
2046      * no such key. The returned entry does <em>not</em> support the
2047      * <tt>Entry.setValue</tt> method.
2048      *
2049      * @throws ClassCastException {@inheritDoc}
2050      * @throws NullPointerException if the specified key is null
2051      */
2052     public Map.Entry<K,V> lowerEntry(K key) {
2053         return getNear(key, LT);
2054     }
2055 
2056     /**
2057      * @throws ClassCastException {@inheritDoc}
2058      * @throws NullPointerException if the specified key is null
2059      */
2060     public K lowerKey(K key) {
2061         Node<K,V> n = findNear(key, LT);
2062         return (n == null) ? null : n.key;
2063     }
2064 
2065     /**
2066      * Returns a key-value mapping associated with the greatest key
2067      * less than or equal to the given key, or <tt>null</tt> if there
2068      * is no such key. The returned entry does <em>not</em> support
2069      * the <tt>Entry.setValue</tt> method.
2070      *
2071      * @param key the key
2072      * @throws ClassCastException {@inheritDoc}
2073      * @throws NullPointerException if the specified key is null
2074      */
2075     public Map.Entry<K,V> floorEntry(K key) {
2076         return getNear(key, LT|EQ);
2077     }
2078 
2079     /**
2080      * @param key the key
2081      * @throws ClassCastException {@inheritDoc}
2082      * @throws NullPointerException if the specified key is null
2083      */
2084     public K floorKey(K key) {
2085         Node<K,V> n = findNear(key, LT|EQ);
2086         return (n == null) ? null : n.key;
2087     }
2088 
2089     /**
2090      * Returns a key-value mapping associated with the least key
2091      * greater than or equal to the given key, or <tt>null</tt> if
2092      * there is no such entry. The returned entry does <em>not</em>
2093      * support the <tt>Entry.setValue</tt> method.
2094      *
2095      * @throws ClassCastException {@inheritDoc}
2096      * @throws NullPointerException if the specified key is null
2097      */
2098     public Map.Entry<K,V> ceilingEntry(K key) {
2099         return getNear(key, GT|EQ);
2100     }
2101 
2102     /**
2103      * @throws ClassCastException {@inheritDoc}
2104      * @throws NullPointerException if the specified key is null
2105      */
2106     public K ceilingKey(K key) {
2107         Node<K,V> n = findNear(key, GT|EQ);
2108         return (n == null) ? null : n.key;
2109     }
2110 
2111     /**
2112      * Returns a key-value mapping associated with the least key
2113      * strictly greater than the given key, or <tt>null</tt> if there
2114      * is no such key. The returned entry does <em>not</em> support
2115      * the <tt>Entry.setValue</tt> method.
2116      *
2117      * @param key the key
2118      * @throws ClassCastException {@inheritDoc}
2119      * @throws NullPointerException if the specified key is null
2120      */
2121     public Map.Entry<K,V> higherEntry(K key) {
2122         return getNear(key, GT);
2123     }
2124 
2125     /**
2126      * @param key the key
2127      * @throws ClassCastException {@inheritDoc}
2128      * @throws NullPointerException if the specified key is null
2129      */
2130     public K higherKey(K key) {
2131         Node<K,V> n = findNear(key, GT);
2132         return (n == null) ? null : n.key;
2133     }
2134 
2135     /**
2136      * Returns a key-value mapping associated with the least
2137      * key in this map, or <tt>null</tt> if the map is empty.
2138      * The returned entry does <em>not</em> support
2139      * the <tt>Entry.setValue</tt> method.
2140      */
2141     public Map.Entry<K,V> firstEntry() {
2142         for (;;) {
2143             Node<K,V> n = findFirst();
2144             if (n == null)
2145                 return null;
2146             AbstractMap.SimpleImmutableEntry<K,V> e = n.createSnapshot();
2147             if (e != null)
2148                 return e;
2149         }
2150     }
2151 
2152     /**
2153      * Returns a key-value mapping associated with the greatest
2154      * key in this map, or <tt>null</tt> if the map is empty.
2155      * The returned entry does <em>not</em> support
2156      * the <tt>Entry.setValue</tt> method.
2157      */
2158     public Map.Entry<K,V> lastEntry() {
2159         for (;;) {
2160             Node<K,V> n = findLast();
2161             if (n == null)
2162                 return null;
2163             AbstractMap.SimpleImmutableEntry<K,V> e = n.createSnapshot();
2164             if (e != null)
2165                 return e;
2166         }
2167     }
2168 
2169     /**
2170      * Removes and returns a key-value mapping associated with
2171      * the least key in this map, or <tt>null</tt> if the map is empty.
2172      * The returned entry does <em>not</em> support
2173      * the <tt>Entry.setValue</tt> method.
2174      */
2175     public Map.Entry<K,V> pollFirstEntry() {
2176         return doRemoveFirstEntry();
2177     }
2178 
2179     /**
2180      * Removes and returns a key-value mapping associated with
2181      * the greatest key in this map, or <tt>null</tt> if the map is empty.
2182      * The returned entry does <em>not</em> support
2183      * the <tt>Entry.setValue</tt> method.
2184      */
2185     public Map.Entry<K,V> pollLastEntry() {
2186         return doRemoveLastEntry();
2187     }
2188 
2189 
2190     /* ---------------- Iterators -------------- */
2191 
2192     /**
2193      * Base of iterator classes:
2194      */
2195     abstract class Iter<T> implements Iterator<T> {
2196         /** the last node returned by next() */
2197         Node<K,V> lastReturned;
2198         /** the next node to return from next(); */
2199         Node<K,V> next;
2200         /** Cache of next value field to maintain weak consistency */
2201         V nextValue;
2202 
2203         /** Initializes ascending iterator for entire range. */
2204         Iter() {
2205             for (;;) {
2206                 next = findFirst();
2207                 if (next == null)
2208                     break;
2209                 Object x = next.value;
2210                 if (x != null && x != next) {
2211                     nextValue = (V) x;
2212                     break;
2213                 }
2214             }
2215         }
2216 
2217         public final boolean hasNext() {
2218             return next != null;
2219         }
2220 
2221         /** Advances next to higher entry. */
2222         final void advance() {
2223             if (next == null)
2224                 throw new NoSuchElementException();
2225             lastReturned = next;
2226             for (;;) {
2227                 next = next.next;
2228                 if (next == null)
2229                     break;
2230                 Object x = next.value;
2231                 if (x != null && x != next) {
2232                     nextValue = (V) x;
2233                     break;
2234                 }
2235             }
2236         }
2237 
2238         public void remove() {
2239             Node<K,V> l = lastReturned;
2240             if (l == null)
2241                 throw new IllegalStateException();
2242             // It would not be worth all of the overhead to directly
2243             // unlink from here. Using remove is fast enough.
2244             ConcurrentSkipListMap.this.remove(l.key);
2245             lastReturned = null;
2246         }
2247 
2248     }
2249 
2250     final class ValueIterator extends Iter<V> {
2251         public V next() {
2252             V v = nextValue;
2253             advance();
2254             return v;
2255         }
2256     }
2257 
2258     final class KeyIterator extends Iter<K> {
2259         public K next() {
2260             Node<K,V> n = next;
2261             advance();
2262             return n.key;
2263         }
2264     }
2265 
2266     final class EntryIterator extends Iter<Map.Entry<K,V>> {
2267         public Map.Entry<K,V> next() {
2268             Node<K,V> n = next;
2269             V v = nextValue;
2270             advance();
2271             return new AbstractMap.SimpleImmutableEntry<K,V>(n.key, v);
2272         }
2273     }
2274 
2275     // Factory methods for iterators needed by ConcurrentSkipListSet etc
2276 
2277     Iterator<K> keyIterator() {
2278         return new KeyIterator();
2279     }
2280 
2281     Iterator<V> valueIterator() {
2282         return new ValueIterator();
2283     }
2284 
2285     Iterator<Map.Entry<K,V>> entryIterator() {
2286         return new EntryIterator();
2287     }
2288 
2289     /* ---------------- View Classes -------------- */
2290 
2291     /*
2292      * View classes are static, delegating to a ConcurrentNavigableMap
2293      * to allow use by SubMaps, which outweighs the ugliness of
2294      * needing type-tests for Iterator methods.
2295      */
2296 
2297     static final <E> List<E> toList(Collection<E> c) {
2298         // Using size() here would be a pessimization.
2299         List<E> list = new ArrayList<E>();
2300         for (E e : c)
2301             list.add(e);
2302         return list;
2303     }
2304 
2305     static final class KeySet<E>
2306             extends AbstractSet<E> implements NavigableSet<E> {
2307         private final ConcurrentNavigableMap<E,Object> m;
2308         KeySet(ConcurrentNavigableMap<E,Object> map) { m = map; }
2309         public int size() { return m.size(); }
2310         public boolean isEmpty() { return m.isEmpty(); }
2311         public boolean contains(Object o) { return m.containsKey(o); }
2312         public boolean remove(Object o) { return m.remove(o) != null; }
2313         public void clear() { m.clear(); }
2314         public E lower(E e) { return m.lowerKey(e); }
2315         public E floor(E e) { return m.floorKey(e); }
2316         public E ceiling(E e) { return m.ceilingKey(e); }
2317         public E higher(E e) { return m.higherKey(e); }
2318         public Comparator<? super E> comparator() { return m.comparator(); }
2319         public E first() { return m.firstKey(); }
2320         public E last() { return m.lastKey(); }
2321         public E pollFirst() {
2322             Map.Entry<E,Object> e = m.pollFirstEntry();
2323             return (e == null) ? null : e.getKey();
2324         }
2325         public E pollLast() {
2326             Map.Entry<E,Object> e = m.pollLastEntry();
2327             return (e == null) ? null : e.getKey();
2328         }
2329         public Iterator<E> iterator() {
2330             if (m instanceof ConcurrentSkipListMap)
2331                 return ((ConcurrentSkipListMap<E,Object>)m).keyIterator();
2332             else
2333                 return ((ConcurrentSkipListMap.SubMap<E,Object>)m).keyIterator();
2334         }
2335         public boolean equals(Object o) {
2336             if (o == this)
2337                 return true;
2338             if (!(o instanceof Set))
2339                 return false;
2340             Collection<?> c = (Collection<?>) o;
2341             try {
2342                 return containsAll(c) && c.containsAll(this);
2343             } catch (ClassCastException unused)   {
2344                 return false;
2345             } catch (NullPointerException unused) {
2346                 return false;
2347             }
2348         }
2349         public Object[] toArray()     { return toList(this).toArray();  }
2350         public <T> T[] toArray(T[] a) { return toList(this).toArray(a); }
2351         public Iterator<E> descendingIterator() {
2352             return descendingSet().iterator();
2353         }
2354         public NavigableSet<E> subSet(E fromElement,
2355                                       boolean fromInclusive,
2356                                       E toElement,
2357                                       boolean toInclusive) {
2358             return new KeySet<E>(m.subMap(fromElement, fromInclusive,
2359                                           toElement,   toInclusive));
2360         }
2361         public NavigableSet<E> headSet(E toElement, boolean inclusive) {
2362             return new KeySet<E>(m.headMap(toElement, inclusive));
2363         }
2364         public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
2365             return new KeySet<E>(m.tailMap(fromElement, inclusive));
2366         }
2367         public NavigableSet<E> subSet(E fromElement, E toElement) {
2368             return subSet(fromElement, true, toElement, false);
2369         }
2370         public NavigableSet<E> headSet(E toElement) {
2371             return headSet(toElement, false);
2372         }
2373         public NavigableSet<E> tailSet(E fromElement) {
2374             return tailSet(fromElement, true);
2375         }
2376         public NavigableSet<E> descendingSet() {
2377             return new KeySet(m.descendingMap());
2378         }
2379     }
2380 
2381     static final class Values<E> extends AbstractCollection<E> {
2382         private final ConcurrentNavigableMap<Object, E> m;
2383         Values(ConcurrentNavigableMap<Object, E> map) {
2384             m = map;
2385         }
2386         public Iterator<E> iterator() {
2387             if (m instanceof ConcurrentSkipListMap)
2388                 return ((ConcurrentSkipListMap<Object,E>)m).valueIterator();
2389             else
2390                 return ((SubMap<Object,E>)m).valueIterator();
2391         }
2392         public boolean isEmpty() {
2393             return m.isEmpty();
2394         }
2395         public int size() {
2396             return m.size();
2397         }
2398         public boolean contains(Object o) {
2399             return m.containsValue(o);
2400         }
2401         public void clear() {
2402             m.clear();
2403         }
2404         public Object[] toArray()     { return toList(this).toArray();  }
2405         public <T> T[] toArray(T[] a) { return toList(this).toArray(a); }
2406     }
2407 
2408     static final class EntrySet<K1,V1> extends AbstractSet<Map.Entry<K1,V1>> {
2409         private final ConcurrentNavigableMap<K1, V1> m;
2410         EntrySet(ConcurrentNavigableMap<K1, V1> map) {
2411             m = map;
2412         }
2413 
2414         public Iterator<Map.Entry<K1,V1>> iterator() {
2415             if (m instanceof ConcurrentSkipListMap)
2416                 return ((ConcurrentSkipListMap<K1,V1>)m).entryIterator();
2417             else
2418                 return ((SubMap<K1,V1>)m).entryIterator();
2419         }
2420 
2421         public boolean contains(Object o) {
2422             if (!(o instanceof Map.Entry))
2423                 return false;
2424             Map.Entry<K1,V1> e = (Map.Entry<K1,V1>)o;
2425             V1 v = m.get(e.getKey());
2426             return v != null && v.equals(e.getValue());
2427         }
2428         public boolean remove(Object o) {
2429             if (!(o instanceof Map.Entry))
2430                 return false;
2431             Map.Entry<K1,V1> e = (Map.Entry<K1,V1>)o;
2432             return m.remove(e.getKey(),
2433                             e.getValue());
2434         }
2435         public boolean isEmpty() {
2436             return m.isEmpty();
2437         }
2438         public int size() {
2439             return m.size();
2440         }
2441         public void clear() {
2442             m.clear();
2443         }
2444         public boolean equals(Object o) {
2445             if (o == this)
2446                 return true;
2447             if (!(o instanceof Set))
2448                 return false;
2449             Collection<?> c = (Collection<?>) o;
2450             try {
2451                 return containsAll(c) && c.containsAll(this);
2452             } catch (ClassCastException unused)   {
2453                 return false;
2454             } catch (NullPointerException unused) {
2455                 return false;
2456             }
2457         }
2458         public Object[] toArray()     { return toList(this).toArray();  }
2459         public <T> T[] toArray(T[] a) { return toList(this).toArray(a); }
2460     }
2461 
2462     /**
2463      * Submaps returned by {@link ConcurrentSkipListMap} submap operations
2464      * represent a subrange of mappings of their underlying
2465      * maps. Instances of this class support all methods of their
2466      * underlying maps, differing in that mappings outside their range are
2467      * ignored, and attempts to add mappings outside their ranges result
2468      * in {@link IllegalArgumentException}.  Instances of this class are
2469      * constructed only using the <tt>subMap</tt>, <tt>headMap</tt>, and
2470      * <tt>tailMap</tt> methods of their underlying maps.
2471      *
2472      * @serial include
2473      */
2474     static final class SubMap<K,V> extends AbstractMap<K,V>
2475         implements ConcurrentNavigableMap<K,V>, Cloneable,
2476                    java.io.Serializable {
2477         private static final long serialVersionUID = -7647078645895051609L;
2478 
2479         /** Underlying map */
2480         private final ConcurrentSkipListMap<K,V> m;
2481         /** lower bound key, or null if from start */
2482         private final K lo;
2483         /** upper bound key, or null if to end */
2484         private final K hi;
2485         /** inclusion flag for lo */
2486         private final boolean loInclusive;
2487         /** inclusion flag for hi */
2488         private final boolean hiInclusive;
2489         /** direction */
2490         private final boolean isDescending;
2491 
2492         // Lazily initialized view holders
2493         private transient KeySet<K> keySetView;
2494         private transient Set<Map.Entry<K,V>> entrySetView;
2495         private transient Collection<V> valuesView;
2496 
2497         /**
2498          * Creates a new submap, initializing all fields
2499          */
2500         SubMap(ConcurrentSkipListMap<K,V> map,
2501                K fromKey, boolean fromInclusive,
2502                K toKey, boolean toInclusive,
2503                boolean isDescending) {
2504             if (fromKey != null && toKey != null &&
2505                 map.compare(fromKey, toKey) > 0)
2506                 throw new IllegalArgumentException("inconsistent range");
2507             this.m = map;
2508             this.lo = fromKey;
2509             this.hi = toKey;
2510             this.loInclusive = fromInclusive;
2511             this.hiInclusive = toInclusive;
2512             this.isDescending = isDescending;
2513         }
2514 
2515         /* ----------------  Utilities -------------- */
2516 
2517         private boolean tooLow(K key) {
2518             if (lo != null) {
2519                 int c = m.compare(key, lo);
2520                 if (c < 0 || (c == 0 && !loInclusive))
2521                     return true;
2522             }
2523             return false;
2524         }
2525 
2526         private boolean tooHigh(K key) {
2527             if (hi != null) {
2528                 int c = m.compare(key, hi);
2529                 if (c > 0 || (c == 0 && !hiInclusive))
2530                     return true;
2531             }
2532             return false;
2533         }
2534 
2535         private boolean inBounds(K key) {
2536             return !tooLow(key) && !tooHigh(key);
2537         }
2538 
2539         private void checkKeyBounds(K key) throws IllegalArgumentException {
2540             if (key == null)
2541                 throw new NullPointerException();
2542             if (!inBounds(key))
2543                 throw new IllegalArgumentException("key out of range");
2544         }
2545 
2546         /**
2547          * Returns true if node key is less than upper bound of range
2548          */
2549         private boolean isBeforeEnd(ConcurrentSkipListMap.Node<K,V> n) {
2550             if (n == null)
2551                 return false;
2552             if (hi == null)
2553                 return true;
2554             K k = n.key;
2555             if (k == null) // pass by markers and headers
2556                 return true;
2557             int c = m.compare(k, hi);
2558             if (c > 0 || (c == 0 && !hiInclusive))
2559                 return false;
2560             return true;
2561         }
2562 
2563         /**
2564          * Returns lowest node. This node might not be in range, so
2565          * most usages need to check bounds
2566          */
2567         private ConcurrentSkipListMap.Node<K,V> loNode() {
2568             if (lo == null)
2569                 return m.findFirst();
2570             else if (loInclusive)
2571                 return m.findNear(lo, m.GT|m.EQ);
2572             else
2573                 return m.findNear(lo, m.GT);
2574         }
2575 
2576         /**
2577          * Returns highest node. This node might not be in range, so
2578          * most usages need to check bounds
2579          */
2580         private ConcurrentSkipListMap.Node<K,V> hiNode() {
2581             if (hi == null)
2582                 return m.findLast();
2583             else if (hiInclusive)
2584                 return m.findNear(hi, m.LT|m.EQ);
2585             else
2586                 return m.findNear(hi, m.LT);
2587         }
2588 
2589         /**
2590          * Returns lowest absolute key (ignoring directonality)
2591          */
2592         private K lowestKey() {
2593             ConcurrentSkipListMap.Node<K,V> n = loNode();
2594             if (isBeforeEnd(n))
2595                 return n.key;
2596             else
2597                 throw new NoSuchElementException();
2598         }
2599 
2600         /**
2601          * Returns highest absolute key (ignoring directonality)
2602          */
2603         private K highestKey() {
2604             ConcurrentSkipListMap.Node<K,V> n = hiNode();
2605             if (n != null) {
2606                 K last = n.key;
2607                 if (inBounds(last))
2608                     return last;
2609             }
2610             throw new NoSuchElementException();
2611         }
2612 
2613         private Map.Entry<K,V> lowestEntry() {
2614             for (;;) {
2615                 ConcurrentSkipListMap.Node<K,V> n = loNode();
2616                 if (!isBeforeEnd(n))
2617                     return null;
2618                 Map.Entry<K,V> e = n.createSnapshot();
2619                 if (e != null)
2620                     return e;
2621             }
2622         }
2623 
2624         private Map.Entry<K,V> highestEntry() {
2625             for (;;) {
2626                 ConcurrentSkipListMap.Node<K,V> n = hiNode();
2627                 if (n == null || !inBounds(n.key))
2628                     return null;
2629                 Map.Entry<K,V> e = n.createSnapshot();
2630                 if (e != null)
2631                     return e;
2632             }
2633         }
2634 
2635         private Map.Entry<K,V> removeLowest() {
2636             for (;;) {
2637                 Node<K,V> n = loNode();
2638                 if (n == null)
2639                     return null;
2640                 K k = n.key;
2641                 if (!inBounds(k))
2642                     return null;
2643                 V v = m.doRemove(k, null);
2644                 if (v != null)
2645                     return new AbstractMap.SimpleImmutableEntry<K,V>(k, v);
2646             }
2647         }
2648 
2649         private Map.Entry<K,V> removeHighest() {
2650             for (;;) {
2651                 Node<K,V> n = hiNode();
2652                 if (n == null)
2653                     return null;
2654                 K k = n.key;
2655                 if (!inBounds(k))
2656                     return null;
2657                 V v = m.doRemove(k, null);
2658                 if (v != null)
2659                     return new AbstractMap.SimpleImmutableEntry<K,V>(k, v);
2660             }
2661         }
2662 
2663         /**
2664          * Submap version of ConcurrentSkipListMap.getNearEntry
2665          */
2666         private Map.Entry<K,V> getNearEntry(K key, int rel) {
2667             if (isDescending) { // adjust relation for direction
2668                 if ((rel & m.LT) == 0)
2669                     rel |= m.LT;
2670                 else
2671                     rel &= ~m.LT;
2672             }
2673             if (tooLow(key))
2674                 return ((rel & m.LT) != 0) ? null : lowestEntry();
2675             if (tooHigh(key))
2676                 return ((rel & m.LT) != 0) ? highestEntry() : null;
2677             for (;;) {
2678                 Node<K,V> n = m.findNear(key, rel);
2679                 if (n == null || !inBounds(n.key))
2680                     return null;
2681                 K k = n.key;
2682                 V v = n.getValidValue();
2683                 if (v != null)
2684                     return new AbstractMap.SimpleImmutableEntry<K,V>(k, v);
2685             }
2686         }
2687 
2688         // Almost the same as getNearEntry, except for keys
2689         private K getNearKey(K key, int rel) {
2690             if (isDescending) { // adjust relation for direction
2691                 if ((rel & m.LT) == 0)
2692                     rel |= m.LT;
2693                 else
2694                     rel &= ~m.LT;
2695             }
2696             if (tooLow(key)) {
2697                 if ((rel & m.LT) == 0) {
2698                     ConcurrentSkipListMap.Node<K,V> n = loNode();
2699                     if (isBeforeEnd(n))
2700                         return n.key;
2701                 }
2702                 return null;
2703             }
2704             if (tooHigh(key)) {
2705                 if ((rel & m.LT) != 0) {
2706                     ConcurrentSkipListMap.Node<K,V> n = hiNode();
2707                     if (n != null) {
2708                         K last = n.key;
2709                         if (inBounds(last))
2710                             return last;
2711                     }
2712                 }
2713                 return null;
2714             }
2715             for (;;) {
2716                 Node<K,V> n = m.findNear(key, rel);
2717                 if (n == null || !inBounds(n.key))
2718                     return null;
2719                 K k = n.key;
2720                 V v = n.getValidValue();
2721                 if (v != null)
2722                     return k;
2723             }
2724         }
2725 
2726         /* ----------------  Map API methods -------------- */
2727 
2728         public boolean containsKey(Object key) {
2729             if (key == null) throw new NullPointerException();
2730             K k = (K)key;
2731             return inBounds(k) && m.containsKey(k);
2732         }
2733 
2734         public V get(Object key) {
2735             if (key == null) throw new NullPointerException();
2736             K k = (K)key;
2737             return ((!inBounds(k)) ? null : m.get(k));
2738         }
2739 
2740         public V put(K key, V value) {
2741             checkKeyBounds(key);
2742             return m.put(key, value);
2743         }
2744 
2745         public V remove(Object key) {
2746             K k = (K)key;
2747             return (!inBounds(k)) ? null : m.remove(k);
2748         }
2749 
2750         public int size() {
2751             long count = 0;
2752             for (ConcurrentSkipListMap.Node<K,V> n = loNode();
2753                  isBeforeEnd(n);
2754                  n = n.next) {
2755                 if (n.getValidValue() != null)
2756                     ++count;
2757             }
2758             return count >= Integer.MAX_VALUE ? Integer.MAX_VALUE : (int)count;
2759         }
2760 
2761         public boolean isEmpty() {
2762             return !isBeforeEnd(loNode());
2763         }
2764 
2765         public boolean containsValue(Object value) {
2766             if (value == null)
2767                 throw new NullPointerException();
2768             for (ConcurrentSkipListMap.Node<K,V> n = loNode();
2769                  isBeforeEnd(n);
2770                  n = n.next) {
2771                 V v = n.getValidValue();
2772                 if (v != null && value.equals(v))
2773                     return true;
2774             }
2775             return false;
2776         }
2777 
2778         public void clear() {
2779             for (ConcurrentSkipListMap.Node<K,V> n = loNode();
2780                  isBeforeEnd(n);
2781                  n = n.next) {
2782                 if (n.getValidValue() != null)
2783                     m.remove(n.key);
2784             }
2785         }
2786 
2787         /* ----------------  ConcurrentMap API methods -------------- */
2788 
2789         public V putIfAbsent(K key, V value) {
2790             checkKeyBounds(key);
2791             return m.putIfAbsent(key, value);
2792         }
2793 
2794         public boolean remove(Object key, Object value) {
2795             K k = (K)key;
2796             return inBounds(k) && m.remove(k, value);
2797         }
2798 
2799         public boolean replace(K key, V oldValue, V newValue) {
2800             checkKeyBounds(key);
2801             return m.replace(key, oldValue, newValue);
2802         }
2803 
2804         public V replace(K key, V value) {
2805             checkKeyBounds(key);
2806             return m.replace(key, value);
2807         }
2808 
2809         /* ----------------  SortedMap API methods -------------- */
2810 
2811         public Comparator<? super K> comparator() {
2812             Comparator<? super K> cmp = m.comparator();
2813             if (isDescending)
2814                 return Collections.reverseOrder(cmp);
2815             else
2816                 return cmp;
2817         }
2818 
2819         /**
2820          * Utility to create submaps, where given bounds override
2821          * unbounded(null) ones and/or are checked against bounded ones.
2822          */
2823         private SubMap<K,V> newSubMap(K fromKey,
2824                                       boolean fromInclusive,
2825                                       K toKey,
2826                                       boolean toInclusive) {
2827             if (isDescending) { // flip senses
2828                 K tk = fromKey;
2829                 fromKey = toKey;
2830                 toKey = tk;
2831                 boolean ti = fromInclusive;
2832                 fromInclusive = toInclusive;
2833                 toInclusive = ti;
2834             }
2835             if (lo != null) {
2836                 if (fromKey == null) {
2837                     fromKey = lo;
2838                     fromInclusive = loInclusive;
2839                 }
2840                 else {
2841                     int c = m.compare(fromKey, lo);
2842                     if (c < 0 || (c == 0 && !loInclusive && fromInclusive))
2843                         throw new IllegalArgumentException("key out of range");
2844                 }
2845             }
2846             if (hi != null) {
2847                 if (toKey == null) {
2848                     toKey = hi;
2849                     toInclusive = hiInclusive;
2850                 }
2851                 else {
2852                     int c = m.compare(toKey, hi);
2853                     if (c > 0 || (c == 0 && !hiInclusive && toInclusive))
2854                         throw new IllegalArgumentException("key out of range");
2855                 }
2856             }
2857             return new SubMap<K,V>(m, fromKey, fromInclusive,
2858                                    toKey, toInclusive, isDescending);
2859         }
2860 
2861         public SubMap<K,V> subMap(K fromKey,
2862                                   boolean fromInclusive,
2863                                   K toKey,
2864                                   boolean toInclusive) {
2865             if (fromKey == null || toKey == null)
2866                 throw new NullPointerException();
2867             return newSubMap(fromKey, fromInclusive, toKey, toInclusive);
2868         }
2869 
2870         public SubMap<K,V> headMap(K toKey,
2871                                    boolean inclusive) {
2872             if (toKey == null)
2873                 throw new NullPointerException();
2874             return newSubMap(null, false, toKey, inclusive);
2875         }
2876 
2877         public SubMap<K,V> tailMap(K fromKey,
2878                                    boolean inclusive) {
2879             if (fromKey == null)
2880                 throw new NullPointerException();
2881             return newSubMap(fromKey, inclusive, null, false);
2882         }
2883 
2884         public SubMap<K,V> subMap(K fromKey, K toKey) {
2885             return subMap(fromKey, true, toKey, false);
2886         }
2887 
2888         public SubMap<K,V> headMap(K toKey) {
2889             return headMap(toKey, false);
2890         }
2891 
2892         public SubMap<K,V> tailMap(K fromKey) {
2893             return tailMap(fromKey, true);
2894         }
2895 
2896         public SubMap<K,V> descendingMap() {
2897             return new SubMap<K,V>(m, lo, loInclusive,
2898                                    hi, hiInclusive, !isDescending);
2899         }
2900 
2901         /* ----------------  Relational methods -------------- */
2902 
2903         public Map.Entry<K,V> ceilingEntry(K key) {
2904             return getNearEntry(key, (m.GT|m.EQ));
2905         }
2906 
2907         public K ceilingKey(K key) {
2908             return getNearKey(key, (m.GT|m.EQ));
2909         }
2910 
2911         public Map.Entry<K,V> lowerEntry(K key) {
2912             return getNearEntry(key, (m.LT));
2913         }
2914 
2915         public K lowerKey(K key) {
2916             return getNearKey(key, (m.LT));
2917         }
2918 
2919         public Map.Entry<K,V> floorEntry(K key) {
2920             return getNearEntry(key, (m.LT|m.EQ));
2921         }
2922 
2923         public K floorKey(K key) {
2924             return getNearKey(key, (m.LT|m.EQ));
2925         }
2926 
2927         public Map.Entry<K,V> higherEntry(K key) {
2928             return getNearEntry(key, (m.GT));
2929         }
2930 
2931         public K higherKey(K key) {
2932             return getNearKey(key, (m.GT));
2933         }
2934 
2935         public K firstKey() {
2936             return isDescending ? highestKey() : lowestKey();
2937         }
2938 
2939         public K lastKey() {
2940             return isDescending ? lowestKey() : highestKey();
2941         }
2942 
2943         public Map.Entry<K,V> firstEntry() {
2944             return isDescending ? highestEntry() : lowestEntry();
2945         }
2946 
2947         public Map.Entry<K,V> lastEntry() {
2948             return isDescending ? lowestEntry() : highestEntry();
2949         }
2950 
2951         public Map.Entry<K,V> pollFirstEntry() {
2952             return isDescending ? removeHighest() : removeLowest();
2953         }
2954 
2955         public Map.Entry<K,V> pollLastEntry() {
2956             return isDescending ? removeLowest() : removeHighest();
2957         }
2958 
2959         /* ---------------- Submap Views -------------- */
2960 
2961         public NavigableSet<K> keySet() {
2962             KeySet<K> ks = keySetView;
2963             return (ks != null) ? ks : (keySetView = new KeySet(this));
2964         }
2965 
2966         public NavigableSet<K> navigableKeySet() {
2967             KeySet<K> ks = keySetView;
2968             return (ks != null) ? ks : (keySetView = new KeySet(this));
2969         }
2970 
2971         public Collection<V> values() {
2972             Collection<V> vs = valuesView;
2973             return (vs != null) ? vs : (valuesView = new Values(this));
2974         }
2975 
2976         public Set<Map.Entry<K,V>> entrySet() {
2977             Set<Map.Entry<K,V>> es = entrySetView;
2978             return (es != null) ? es : (entrySetView = new EntrySet(this));
2979         }
2980 
2981         public NavigableSet<K> descendingKeySet() {
2982             return descendingMap().navigableKeySet();
2983         }
2984 
2985         Iterator<K> keyIterator() {
2986             return new SubMapKeyIterator();
2987         }
2988 
2989         Iterator<V> valueIterator() {
2990             return new SubMapValueIterator();
2991         }
2992 
2993         Iterator<Map.Entry<K,V>> entryIterator() {
2994             return new SubMapEntryIterator();
2995         }
2996 
2997         /**
2998          * Variant of main Iter class to traverse through submaps.
2999          */
3000         abstract class SubMapIter<T> implements Iterator<T> {
3001             /** the last node returned by next() */
3002             Node<K,V> lastReturned;
3003             /** the next node to return from next(); */
3004             Node<K,V> next;
3005             /** Cache of next value field to maintain weak consistency */
3006             V nextValue;
3007 
3008             SubMapIter() {
3009                 for (;;) {
3010                     next = isDescending ? hiNode() : loNode();
3011                     if (next == null)
3012                         break;
3013                     Object x = next.value;
3014                     if (x != null && x != next) {
3015                         if (! inBounds(next.key))
3016                             next = null;
3017                         else
3018                             nextValue = (V) x;
3019                         break;
3020                     }
3021                 }
3022             }
3023 
3024             public final boolean hasNext() {
3025                 return next != null;
3026             }
3027 
3028             final void advance() {
3029                 if (next == null)
3030                     throw new NoSuchElementException();
3031                 lastReturned = next;
3032                 if (isDescending)
3033                     descend();
3034                 else
3035                     ascend();
3036             }
3037 
3038             private void ascend() {
3039                 for (;;) {
3040                     next = next.next;
3041                     if (next == null)
3042                         break;
3043                     Object x = next.value;
3044                     if (x != null && x != next) {
3045                         if (tooHigh(next.key))
3046                             next = null;
3047                         else
3048                             nextValue = (V) x;
3049                         break;
3050                     }
3051                 }
3052             }
3053 
3054             private void descend() {
3055                 for (;;) {
3056                     next = m.findNear(lastReturned.key, LT);
3057                     if (next == null)
3058                         break;
3059                     Object x = next.value;
3060                     if (x != null && x != next) {
3061                         if (tooLow(next.key))
3062                             next = null;
3063                         else
3064                             nextValue = (V) x;
3065                         break;
3066                     }
3067                 }
3068             }
3069 
3070             public void remove() {
3071                 Node<K,V> l = lastReturned;
3072                 if (l == null)
3073                     throw new IllegalStateException();
3074                 m.remove(l.key);
3075                 lastReturned = null;
3076             }
3077 
3078         }
3079 
3080         final class SubMapValueIterator extends SubMapIter<V> {
3081             public V next() {
3082                 V v = nextValue;
3083                 advance();
3084                 return v;
3085             }
3086         }
3087 
3088         final class SubMapKeyIterator extends SubMapIter<K> {
3089             public K next() {
3090                 Node<K,V> n = next;
3091                 advance();
3092                 return n.key;
3093             }
3094         }
3095 
3096         final class SubMapEntryIterator extends SubMapIter<Map.Entry<K,V>> {
3097             public Map.Entry<K,V> next() {
3098                 Node<K,V> n = next;
3099                 V v = nextValue;
3100                 advance();
3101                 return new AbstractMap.SimpleImmutableEntry<K,V>(n.key, v);
3102             }
3103         }
3104     }
3105 
3106     // Unsafe mechanics
3107     private static final sun.misc.Unsafe UNSAFE;
3108     private static final long headOffset;
3109     static {
3110         try {
3111             UNSAFE = sun.misc.Unsafe.getUnsafe();
3112             Class k = ConcurrentSkipListMap.class;
3113             headOffset = UNSAFE.objectFieldOffset
3114                 (k.getDeclaredField("head"));
3115         } catch (Exception e) {
3116             throw new Error(e);
3117         }
3118     }
3119 }
View Code

 

下面从ConcurrentSkipListMap的添加,删除,获取这3个方面对它进行分析。

1. 添加

下面以put(K key, V value)为例,对ConcurrentSkipListMap的添加方法进行说明。

public V put(K key, V value) {
    if (value == null)
        throw new NullPointerException();
    return doPut(key, value, false);
}

实际上,put()是通过doPut()将key-value键值对添加到ConcurrentSkipListMap中的。

doPut()的源码如下:

private V doPut(K kkey, V value, boolean onlyIfAbsent) {
    Comparable<? super K> key = comparable(kkey);
    for (;;) {
        // 找到key的前继节点
        Node<K,V> b = findPredecessor(key);
        // 设置n为“key的前继节点的后继节点”,即n应该是“插入节点”的“后继节点”
        Node<K,V> n = b.next;
        for (;;) {
            if (n != null) {
                Node<K,V> f = n.next;
                // 如果两次获得的b.next不是相同的Node,就跳转到”外层for循环“,重新获得b和n后再遍历。
                if (n != b.next)
                    break;
                // v是“n的值”
                Object v = n.value;
                // 当n的值为null(意味着其它线程删除了n);此时删除b的下一个节点,然后跳转到”外层for循环“,重新获得b和n后再遍历。
                if (v == null) {               // n is deleted
                    n.helpDelete(b, f);
                    break;
                }
                // 如果其它线程删除了b;则跳转到”外层for循环“,重新获得b和n后再遍历。
                if (v == n || b.value == null) // b is deleted
                    break;
                // 比较key和n.key
                int c = key.compareTo(n.key);
                if (c > 0) {
                    b = n;
                    n = f;
                    continue;
                }
                if (c == 0) {
                    if (onlyIfAbsent || n.casValue(v, value))
                        return (V)v;
                    else
                        break; // restart if lost race to replace value
                }
                // else c < 0; fall through
            }

            // 新建节点(对应是“要插入的键值对”)
            Node<K,V> z = new Node<K,V>(kkey, value, n);
            // 设置“b的后继节点”为z
            if (!b.casNext(n, z))
                break;         // 多线程情况下,break才可能发生(其它线程对b进行了操作)
            // 随机获取一个level
            // 然后在“第1层”到“第level层”的链表中都插入新建节点
            int level = randomLevel();
            if (level > 0)
                insertIndex(z, level);
            return null;
        }
    }
}

说明:doPut() 的作用就是将键值对添加到“跳表”中。
要想搞清doPut(),首先要弄清楚它的主干部分 —— 我们先单纯的只考虑“单线程的情况下,将key-value添加到跳表中”,即忽略“多线程相关的内容”。它的流程如下:
第1步:找到“插入位置”。
即,找到“key的前继节点(b)”和“key的后继节点(n)”;key是要插入节点的键。
第2步:新建并插入节点。
即,新建节点z(key对应的节点),并将新节点z插入到“跳表”中(设置“b的后继节点为z”,“z的后继节点为n”)。
第3步:更新跳表。
即,随机获取一个level,然后在“跳表”的第1层~第level层之间,每一层都插入节点z;在第level层之上就不再插入节点了。若level数值大于“跳表的层次”,则新建一层。
主干部分“对应的精简后的doPut()的代码”如下(仅供参考):

private V doPut(K kkey, V value, boolean onlyIfAbsent) {
    Comparable<? super K> key = comparable(kkey);
    for (;;) {
        // 找到key的前继节点
        Node<K,V> b = findPredecessor(key);
        // 设置n为key的后继节点
        Node<K,V> n = b.next;
        for (;;) {
            
            // 新建节点(对应是“要被插入的键值对”)
            Node<K,V> z = new Node<K,V>(kkey, value, n);
            // 设置“b的后继节点”为z
            b.casNext(n, z);

            // 随机获取一个level
            // 然后在“第1层”到“第level层”的链表中都插入新建节点
            int level = randomLevel();
            if (level > 0)
                insertIndex(z, level);
            return null;
        }
    }
}

理清主干之后,剩余的工作就相对简单了。主要是上面几步的对应算法的具体实现,以及多线程相关情况的处理!

 

2. 删除

下面以remove(Object key)为例,对ConcurrentSkipListMap的删除方法进行说明。

public V remove(Object key) {
    return doRemove(key, null);
}

实际上,remove()是通过doRemove()将ConcurrentSkipListMap中的key对应的键值对删除的。

doRemove()的源码如下:

 

final V doRemove(Object okey, Object value) {
    Comparable<? super K> key = comparable(okey);
    for (;;) {
        // 找到“key的前继节点”
        Node<K,V> b = findPredecessor(key);
        // 设置n为“b的后继节点”(即若key存在于“跳表中”,n就是key对应的节点)
        Node<K,V> n = b.next;
        for (;;) {
            if (n == null)
                return null;
            // f是“当前节点n的后继节点”
            Node<K,V> f = n.next;
            // 如果两次读取到的“b的后继节点”不同(其它线程操作了该跳表),则返回到“外层for循环”重新遍历。
            if (n != b.next)                    // inconsistent read
                break;
            // 如果“当前节点n的值”变为null(其它线程操作了该跳表),则返回到“外层for循环”重新遍历。
            Object v = n.value;
            if (v == null) {                    // n is deleted
                n.helpDelete(b, f);
                break;
            }
            // 如果“前继节点b”被删除(其它线程操作了该跳表),则返回到“外层for循环”重新遍历。
            if (v == n || b.value == null)      // b is deleted
                break;
            int c = key.compareTo(n.key);
            if (c < 0)
                return null;
            if (c > 0) {
                b = n;
                n = f;
                continue;
            }

            // 以下是c=0的情况
            if (value != null && !value.equals(v))
                return null;
            // 设置“当前节点n”的值为null
            if (!n.casValue(v, null))
                break;
            // 设置“b的后继节点”为f
            if (!n.appendMarker(f) || !b.casNext(n, f))
                findNode(key);                  // Retry via findNode
            else {
                // 清除“跳表”中每一层的key节点
                findPredecessor(key);           // Clean index
                // 如果“表头的右索引为空”,则将“跳表的层次”-1。
                if (head.right == null)
                    tryReduceLevel();
            }
            return (V)v;
        }
    }
}

说明:doRemove()的作用是删除跳表中的节点。
和doPut()一样,我们重点看doRemove()的主干部分,了解主干部分之后,其余部分就非常容易理解了。下面是“单线程的情况下,删除跳表中键值对的步骤”:
第1步:找到“被删除节点的位置”。
即,找到“key的前继节点(b)”,“key所对应的节点(n)”,“n的后继节点f”;key是要删除节点的键。
第2步:删除节点。
即,将“key所对应的节点n”从跳表中移除 -- 将“b的后继节点”设为“f”!
第3步:更新跳表。
即,遍历跳表,删除每一层的“key节点”(如果存在的话)。如果删除“key节点”之后,跳表的层次需要-1;则执行相应的操作!
主干部分“对应的精简后的doRemove()的代码”如下(仅供参考):

 

final V doRemove(Object okey, Object value) {
    Comparable<? super K> key = comparable(okey);
    for (;;) {
        // 找到“key的前继节点”
        Node<K,V> b = findPredecessor(key);
        // 设置n为“b的后继节点”(即若key存在于“跳表中”,n就是key对应的节点)
        Node<K,V> n = b.next;
        for (;;) {
            // f是“当前节点n的后继节点”
            Node<K,V> f = n.next;

            // 设置“当前节点n”的值为null
            n.casValue(v, null);

            // 设置“b的后继节点”为f
            b.casNext(n, f);
            // 清除“跳表”中每一层的key节点
            findPredecessor(key);
            // 如果“表头的右索引为空”,则将“跳表的层次”-1。
            if (head.right == null)
                tryReduceLevel();
            return (V)v;
        }
    }
}

 

3. 获取

下面以get(Object key)为例,对ConcurrentSkipListMap的获取方法进行说明。

public V get(Object key) {
    return doGet(key);
}

doGet的源码如下:

private V doGet(Object okey) {
    Comparable<? super K> key = comparable(okey);
    for (;;) {
        // 找到“key对应的节点”
        Node<K,V> n = findNode(key);
        if (n == null)
            return null;
        Object v = n.value;
        if (v != null)
            return (V)v;
    }
}

说明:doGet()是通过findNode()找到并返回节点的。

private Node<K,V> findNode(Comparable<? super K> key) {
    for (;;) {
        // 找到key的前继节点
        Node<K,V> b = findPredecessor(key);
        // 设置n为“b的后继节点”(即若key存在于“跳表中”,n就是key对应的节点)
        Node<K,V> n = b.next;
        for (;;) {
            // 如果“n为null”,则跳转中不存在key对应的节点,直接返回null。
            if (n == null)
                return null;
            Node<K,V> f = n.next;
            // 如果两次读取到的“b的后继节点”不同(其它线程操作了该跳表),则返回到“外层for循环”重新遍历。
            if (n != b.next)                // inconsistent read
                break;
            Object v = n.value;
            // 如果“当前节点n的值”变为null(其它线程操作了该跳表),则返回到“外层for循环”重新遍历。
            if (v == null) {                // n is deleted
                n.helpDelete(b, f);
                break;
            }
            if (v == n || b.value == null)  // b is deleted
                break;
            // 若n是当前节点,则返回n。
            int c = key.compareTo(n.key);
            if (c == 0)
                return n;
            // 若“节点n的key”小于“key”,则说明跳表中不存在key对应的节点,返回null
            if (c < 0)
                return null;
            // 若“节点n的key”大于“key”,则更新b和n,继续查找。
            b = n;
            n = f;
        }
    }
}

说明:findNode(key)的作用是在返回跳表中key对应的节点;存在则返回节点,不存在则返回null。
先弄清函数的主干部分,即抛开“多线程相关内容”,单纯的考虑单线程情况下,从跳表获取节点的算法。
第1步:找到“被删除节点的位置”。
根据findPredecessor()定位key所在的层次以及找到key的前继节点(b),然后找到b的后继节点n。
第2步:根据“key的前继节点(b)”和“key的前继节点的后继节点(n)”来定位“key对应的节点”。
具体是通过比较“n的键值”和“key”的大小。如果相等,则n就是所要查找的键。

 

ConcurrentSkipListMap示例

import java.util.*;
import java.util.concurrent.*;

/*
 *   ConcurrentSkipListMap是“线程安全”的哈希表,而TreeMap是非线程安全的。
 *
 *   下面是“多个线程同时操作并且遍历map”的示例
 *   (01) 当map是ConcurrentSkipListMap对象时,程序能正常运行。
 *   (02) 当map是TreeMap对象时,程序会产生ConcurrentModificationException异常。
 *
 * @author skywang
 */
public class ConcurrentSkipListMapDemo1 {

    // TODO: map是TreeMap对象时,程序会出错。
    //private static Map<String, String> map = new TreeMap<String, String>();
    private static Map<String, String> map = new ConcurrentSkipListMap<String, String>();
    public static void main(String[] args) {
    
        // 同时启动两个线程对map进行操作!
        new MyThread("a").start();
        new MyThread("b").start();
    }

    private static void printAll() {
        String key, value;
        Iterator iter = map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry entry = (Map.Entry)iter.next();
            key = (String)entry.getKey();
            value = (String)entry.getValue();
            System.out.print("("+key+", "+value+"), ");
        }
        System.out.println();
    }

    private static class MyThread extends Thread {
        MyThread(String name) {
            super(name);
        }
        @Override
        public void run() {
                int i = 0;
            while (i++ < 6) {
                // “线程名” + "序号"
                String val = Thread.currentThread().getName()+i;
                map.put(val, "0");
                // 通过“Iterator”遍历map。
                printAll();
            }
        }
    }
}

(某一次)运行结果

 

(a1, 0), (a1, 0), (b1, 0), (b1, 0),

(a1, 0), (b1, 0), (b2, 0), 
(a1, 0), (a1, 0), (a2, 0), (a2, 0), (b1, 0), (b1, 0), (b2, 0), (b2, 0), (b3, 0), 
(b3, 0), (a1, 0), 
(a2, 0), (a3, 0), (a1, 0), (b1, 0), (a2, 0), (b2, 0), (a3, 0), (b3, 0), (b1, 0), (b4, 0), 
(b2, 0), (a1, 0), (b3, 0), (a2, 0), (b4, 0), 
(a3, 0), (a1, 0), (a4, 0), (a2, 0), (b1, 0), (a3, 0), (b2, 0), (a4, 0), (b3, 0), (b1, 0), (b4, 0), (b2, 0), (b5, 0), 
(b3, 0), (a1, 0), (b4, 0), (a2, 0), (b5, 0), 
(a3, 0), (a1, 0), (a4, 0), (a2, 0), (a5, 0), (a3, 0), (b1, 0), (a4, 0), (b2, 0), (a5, 0), (b3, 0), (b1, 0), (b4, 0), (b2, 0), (b5, 0), (b3, 0), (b6, 0), 
(b4, 0), (a1, 0), (b5, 0), (a2, 0), (b6, 0), 
(a3, 0), (a4, 0), (a5, 0), (a6, 0), (b1, 0), (b2, 0), (b3, 0), (b4, 0), (b5, 0), (b6, 0), 

结果说明
示例程序中,启动两个线程(线程a和线程b)分别对ConcurrentSkipListMap进行操作。以线程a而言,它会先获取“线程名”+“序号”,然后将该字符串作为key,将“0”作为value,插入到ConcurrentSkipListMap中;接着,遍历并输出ConcurrentSkipListMap中的全部元素。 线程b的操作和线程a一样,只不过线程b的名字和线程a的名字不同。
当map是ConcurrentSkipListMap对象时,程序能正常运行。如果将map改为TreeMap时,程序会产生ConcurrentModificationException异常。

 


更多内容

1. Java多线程系列--“JUC集合”01之 框架

2. Java多线程系列目录(共xx篇)

 

posted on 2014-01-30 13:44 如果天空不死 阅读(...) 评论(...) 编辑 收藏