ConcurrentSkipListMap
ConcurrentSkipListMap与TreeMap对应，相当于线程安全的TreeMap，key有序，TreeMap基于红黑树，ConcurrentSkipListMap基于跳表。
无锁链表的问题
用跳表而不用红黑树是因为目前计算机领域还未找到一种高效的、作用在树上的、无锁的、增加和删除节点的办法。（Doug Lea原话）
一般的无锁队列、栈，都是只在队头、队尾进行CAS操作，通常不会有问题。如果在链表的中间进行插入或删除操作，按照通常的CAS做法，就会出现问题。
操作1：在节点10后面插入节点20。如下图所示，首先把节点20的next指针指向节点30，然后对节点10的next指针执行CAS操作，使其指向节点20。
操作2：删除节点10。如下图所示，只需把头节点的next指针，进行CAS操作到节点30。
但是，如果两个线程同时操作， 一个删除节点10，一个要在节点10后面插入节点20。并且这两个操作都各自是CAS的，此时就会出现问题。删除节点10，可能会同时把新插入的节点20也删除掉。
在删除节点10的时候，实际受到操作的是节点10的前驱，也就是头节点。节点10本身没有任何变化。所以往节点10后插入节点20的线程，并不知道节点10发生了什么（可能被删除）。
解决办法
第一步，把节点10的next指针，标记成删除，即软删除；
第二步，找机会，物理删除。
做标记之后，当线程再往节点10后面插入节点20的时候，便可以先进行判断，节点10是否已经被删除，从而避免在一个删除的节点10后面插入节点20。这个解决方法有一个关键点： “把节点10的next指针指向节点20（插入操作）”和“判断节点10本身是否已经删除（判断操作）”，必须是原子的，必须在1个CAS操作里面完成！
实现
Mark节点
记录标记节点10已经被删除，需要标记它的next字段。可以新造一个Marker节点，使节点10的next指针指向该Marker节点。这样，当向节点10的后面插入节点20的时候，就可以在插入的同时判断节点10的next指针是否执行了一个Marker节点，这两个操作可以在一个CAS操作里面完成。
跳表
结构
由于跳表由多层链表叠起来构成，所以解决了无锁链表的插入或删除问题，也就解决了跳表的一个关键问题。
跳表底层的节点按照从小到大的顺序排列。
ConcurrentSkipListMap中跳表的部分结构源码如下
//底层Node节点，所有的数据节点都在此链表上
static final class Node<K,V> {
final K key;
volatile Object value;
//后继节点
volatile Node<K, V> next;
Node(K key, Object value, Node<K,V> next) {
this.key = key;
this.value = value;
this.next = next;
}
//删除清理逻辑，b，f分别是此节点的前驱，后继
void helpDelete(Node<K,V> b, Node<K,V> f) {
if (f == next && this == b.next) {
if (f == null || f.value != f) // 如果f是null或者没被标记，此节点后继设为marker节点
casNext(f, new Node<K,V>(f));
else //否则让b的后继为f
b.casNext(this, f.next);
}
}
}
//上层的索引节点
static class Index<K,V> {
//不存储数据，指向Node
final Node<K, V> node;
//每一个索引都有一个指针指向下一层对应的节点
final Index<K, V> down;
//索引的后继节点
volatile Index<K, V> right;
Index(Node<K,V> node, Index<K,V> down, Index<K,V> right) {
this.node = node;
this.down = down;
this.right = right;
}
//CAS操作，本节点的后继节点由cmp替换为val
final boolean casRight(Index<K,V> cmp, Index<K,V> val) {
return UNSAFE.compareAndSwapObject(this, rightOffset, cmp, val);
}
final boolean unlink(Index<K,V> succ) {
return node.value != null && casRight(succ, succ.right);
}
}
//index的头节点
static final class HeadIndex<K,V> extends Index<K,V> {
//第几层
final int level;
HeadIndex(Node<K,V> node, Index<K,V> down, Index<K,V> right, int level) {
super(node, down, right);
this.level = level;
}
}
//跳查表的最顶层节点，只需记住这一个节点
private transient volatile HeadIndex<K,V> head;查找前驱节点
//找到节点的前驱
private Node<K,V> findPredecessor(Object key, Comparator<? super K> cmp) {
if (key == null)
throw new NullPointerException();
for (;;) {
//head为最顶层HeadIndex节点
for (Index<K,V> q = head, r = q.right, d;;) {
if (r != null) {
//取当前索引指向的数据节点
Node<K,V> n = r.node;
K k = n.key;
//如果r指向的数据节点的值为null
if (n.value == null) {
if (!q.unlink(r)) // CAS移除索引节点r，如果失败则重新循环
break;
r = q.right;// CAS成功则重新读取r
continue;
}
//比较大小，如果给定的key比当前索引指向的数据节点的key大，q和r都往后移动一位
if (cpr(cmp, key, k) > 0) {
q = r;
r = r.right;
continue;
}
}
//如果q是第一层索引，返回q指向的数据节点
if ((d = q.down) == null)
return q.node;
//向下移动一层
q = d;
r = d.right;
}
}
}
static final int cpr(Comparator c, Object x, Object y) {
return (c != null) ? c.compare(x, y) : ((Comparable)x).compareTo(y);
}
get方法
public V get(Object key) {
return doGet(key);
}
private V doGet(Object key) {
if (key == null)
throw new NullPointerException();
Comparator<? super K> cmp = comparator;
outer: for (;;) {
//先找到前驱结点
for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
Object v; int c;
if (n == null)
break outer;
Node<K,V> f = n.next;
if (n != b.next) // 不一致读，重新循环
break;
if ((v = n.value) == null) { // 如果n的值为null，相当于被删除，执行协助删除方法
n.helpDelete(b, f);
break;
}
if (b.value == null || v == n) // 如果b被删除了，重新循环
break;
if ((c = cpr(cmp, key, n.key)) == 0) { //找到了，返回
@SuppressWarnings("unchecked") V vv = (V)v;
return vv;
}
if (c < 0) //没找到，跳出循环返回null
break outer;
//b和n后移一位，继续查找
b = n;
n = f;
}
}
return null;
}put方法
public V put(K key, V value) {
if (value == null)
throw new NullPointerException();
return doPut(key, value, false);
}
private V doPut(K key, V value, boolean onlyIfAbsent) {
Node<K,V> z; // 要添加的节点
if (key == null)
throw new NullPointerException();
Comparator<? super K> cmp = comparator;
outer: for (;;) {
// 首先找到小于key的前驱结点b，n作为key的后继节点
for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
if (n != null) {
Object v; int c;
Node<K,V> f = n.next;
if (n != b.next) // 不一致读则重新外层循环
break;
if ((v = n.value) == null) { // 如果n被删除了，执行协助删除方法
n.helpDelete(b, f);
break;
}
if (b.value == null || v == n) // 如果b被删除了，则重新开始外层循环
break;
if ((c = cpr(cmp, key, n.key)) > 0) {//待插入的key大于n节点的key，则把b和n向后移动一位
b = n;
n = f;
continue;
}
if (c == 0) {//如果key对应的节点存在，直接CAS操作修改value
if (onlyIfAbsent || n.casValue(v, value)) {
@SuppressWarnings("unchecked") V vv = (V)v;
return vv;
}
break; // 如果CAS失败则重新外层循环
}
// else c < 0; 给定key小于n的key则插入失败
}
z = new Node<K,V>(key, value, n);
if (!b.casNext(n, z))// 将b的后继由n换成z，如果CAS失败则重新外层循环
break;
//成功插入后结束外层死循环
break outer;
}
}
//成功插入不存在的node会走到这里,判断是否需要给新插入的节点增加索引
int rnd = ThreadLocalRandom.nextSecondarySeed();
if ((rnd & 0x80000001) == 0) {
int level = 1, max;
while (((rnd >>>= 1) & 1) != 0)
++level;
Index<K,V> idx = null;
HeadIndex<K,V> h = head;
if (level <= (max = h.level)) {
for (int i = 1; i <= level; ++i)
idx = new Index<K,V>(z, idx, null);
}
else {
level = max + 1;
@SuppressWarnings("unchecked") Index<K,V>[] idxs =
(Index<K,V>[])new Index<?,?>[level+1];
for (int i = 1; i <= level; ++i)
idxs[i] = idx = new Index<K,V>(z, idx, null);
for (;;) {
h = head;
int oldLevel = h.level;
if (level <= oldLevel)
break;
HeadIndex<K,V> newh = h;
Node<K,V> oldbase = h.node;
for (int j = oldLevel+1; j <= level; ++j)
newh = new HeadIndex<K,V>(oldbase, newh, idxs[j], j);
if (casHead(h, newh)) {
h = newh;
idx = idxs[level = oldLevel];
break;
}
}
}
splice: for (int insertionLevel = level;;) {
int j = h.level;
for (Index<K,V> q = h, r = q.right, t = idx;;) {
if (q == null || t == null)
break splice;
if (r != null) {
Node<K,V> n = r.node;
int c = cpr(cmp, key, n.key);
if (n.value == null) {
if (!q.unlink(r))
break;
r = q.right;
continue;
}
if (c > 0) {
q = r;
r = r.right;
continue;
}
}
if (j == insertionLevel) {
if (!q.link(r, t))
break; // restart
if (t.node.value == null) {
findNode(key);
break splice;
}
if (--insertionLevel == 0)
break splice;
}
if (--j >= insertionLevel && j < level)
t = t.down;
q = q.down;
r = q.right;
}
}
}
return null;
}remove方法
public V remove(Object key) {
return doRemove(key, null);
}
final V doRemove(Object key, Object value) {
if (key == null)
throw new NullPointerException();
Comparator<? super K> cmp = comparator;
outer: for (;;) {
// 首先找到小于key的前驱结点b
for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
Object v; int c;
if (n == null)
break outer;
// 待删除节点的后继节点
Node<K,V> f = n.next;
if (n != b.next) // 不一致读重新循环
break;
if ((v = n.value) == null) { // 如果n被删除了，执行协助删除方法
n.helpDelete(b, f);
break;
}
if (b.value == null || v == n) // 如果b被删除了，则重新循环
break;
if ((c = cpr(cmp, key, n.key)) < 0) //如果 key比n的key小，说明没找到key，则跳出死循环返回null
break outer;
if (c > 0) { //如果key比n的key大，b和n都向后移动一位
b = n;
n = f;
continue;
}
if (value != null && !value.equals(v)) //如果key匹配了，但是值没有匹配，则也视为未找到，跳出循环返回null
break outer;
if (!n.casValue(v, null)) //删除的元素为n，先将值置为null，然后执行相关删除逻辑
break;
if (!n.appendMarker(f) || !b.casNext(n, f))//在n的后面加上Marker节点
findNode(key);
else {
findPredecessor(key, cmp); // 清除索引，如果head索引的后继为null，则降低索引层数
if (head.right == null)
tryReduceLevel();
}
//返回删除的元素
@SuppressWarnings("unchecked") V vv = (V)v;
return vv;
}
}
return null;
}ConcurrentSkipListSet
内部实际上引用了ConcurrentSkipListMap，map的key存储Set元素的值，value无意义，几乎所有方法都委托给ConcurrentSkipListMap执行。
