看一下跳跃表的示意图，途中蓝色的为头节点，头节点指向的是普通索引节点
通过上图可以看到跳跃表的基本结构，下面分析一下普通索引节点和头节点的源码，可以发现头节点和普通索引节点的区别就是头节点有level的概念，而普通索引节点没有
static class Index<K,V> {
//索引持有的数据节点
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更新右侧索引
final boolean casRight(Index<K,V> cmp, Index<K,V> val) {
return UNSAFE.compareAndSwapObject(this, rightOffset, cmp, val);
}
//判断当前节点是否是删除节点
final boolean indexesDeletedNode() {
return node.value == null;
}
//将newSucc节点插入到当前节点与succ节点之间
final boolean link(Index<K,V> succ, Index<K,V> newSucc) {
Node<K,V> n = node;
//新索引节点的右侧索引指向succ
newSucc.right = succ;
//如果当前节点不是删除节点，则cas更新右侧索引指向newSucc
return n.value != null && casRight(succ, newSucc);
}
//删除succ
final boolean unlink(Index<K,V> succ) {
return node.value != null && casRight(succ, succ.right);
}
private static final sun.misc.Unsafe UNSAFE;
private static final long rightOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> k = Index.class;
rightOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("right"));
} catch (Exception e) {
throw new Error(e);
}
}
}
//头节点，只有头节点才有层级概念
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;
}
}
public V put(K key, V value) {
//如果value为null则抛出空指针异常
if (value == null)
throw new NullPointerException();
//添加数据
return doPut(key, value, false);
}
private V doPut(K key, V value, boolean onlyIfAbsent) {
//声明一个需要添加到节点
Node<K,V> z;
//如果key为null则抛出一个NPE
if (key == null)
throw new NullPointerException();
Comparator<? super K> cmp = comparator;
outer: for (;;) {
//对当前key找到前驱
for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
//如果b的后继不为null
if (n != null) {
Object v; int c;
//n的后继节点
Node<K,V> f = n.next;
//再次判断n是不是b的后继，如果不是则跳出循环（一致性读）
if (n != b.next)
break;
//如果n节点已经被删除则跳出循环
if ((v = n.value) == null) {
n.helpDelete(b, f);
break;
}
//如果b节点被删除则跳出循环
if (b.value == null || v == n)
break;
//如果key大于n节点的key则继续向后找
if ((c = cpr(cmp, key, n.key)) > 0) {
b = n;
n = f;
continue;
}
//如果找到了key相等的节点
if (c == 0) {
if (onlyIfAbsent || n.casValue(v, value)) {
@SuppressWarnings("unchecked") V vv = (V)v;
return vv;
}
break; //CAS竞争失败则继续
}
// else c < 0; fall through
}
//如果后继节点为null则可以直接添加
z = new Node<K,V>(key, value, n);
//CAS设置失败则跳出内层循环，继续执行
if (!b.casNext(n, z))
break;
//CAS成功则跳出外层循环
break outer;
}
}
int rnd = ThreadLocalRandom.nextSecondarySeed();
//与10000000000000000000000000000001按位与的结果为0，表示最高位和最低位不为1
if ((rnd & 0x80000001) == 0) {
int level = 1, max;
//随机数从左到右连续有几个1，则level自增几次
while (((rnd >>>= 1) & 1) != 0)
++level;
Index<K,V> idx = null;
HeadIndex<K,V> h = head;
//如果level小于等于head节点的层级，则逐层创建索引且down之前idx
if (level <= (max = h.level)) {
for (int i = 1; i <= level; ++i)
idx = new Index<K,V>(z, idx, null);
}
else { //如果level大于head的层级
//将level设置为max+1,即head的层级+1
level = max + 1;
//创建新的索引数组
Index<K,V>[] idxs =
(Index<K,V>[])new Index<?,?>[level+1];
//对索引数组进行赋值，0不使用，并将down指向前一个节点
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) //如果当前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);
//cas赋值头节点
if (casHead(h, newh)) {
//将最新头节点赋值给h
h = newh;
//idx为之前的头节点
idx = idxs[level = oldLevel];
break;
}
}
}
// 找到插入点，并插入数据
splice: for (int insertionLevel = level;;) {
//level为之前头节点的层级，j为新头节点的层级
int j = h.level;
for (Index<K,V> q = h, r = q.right, t = idx;;) {
//如果新头节点，或者老头节点为null则跳出外层循环
if (q == null || t == null)
break splice;
//r为新头节点的右节点，如果不为null
if (r != null) {
//r索引持有的节点
Node<K,V> n = r.node;
//当前key和r索引持有的key进行比较
int c = cpr(cmp, key, n.key);
//如果n的值为null，则删除该节点，如果删除失败则重新循环
if (n.value == null) {
if (!q.unlink(r))
break;
r = q.right;
continue;
}
//如果key>n.key 则继续向后查找
if (c > 0) {
q = r;
r = r.right;
continue;
}
}
// 表示r为null，即找到该层的最后
//如果是需要插入的层级
if (j == insertionLevel) {
//将t插入到q,r之间失败则重新开始
if (!q.link(r, t))
break;
//插入成功，如果t的值为null，则需要删除
if (t.node.value == null) {
findNode(key);
break splice;
}
//如果到最低层则跳出外层循环
if (--insertionLevel == 0)
break splice;
}
//如果 --j 大于等于insertLevel则继续处理下一层
if (--j >= insertionLevel && j < level)
t = t.down;
q = q.down;
r = q.right;
}
}
}
return null;
}
private Node<K,V> findPredecessor(Object key, Comparator<? super K> cmp) {
//如果key为null则抛出NPE
if (key == null)
throw new NullPointerException(); // don't postpone errors
for (;;) {
// q初始化为头索引节点，r为索引节点右侧索引节点
for (Index<K,V> q = head, r = q.right, d;;) {
//如果r不为nul
if (r != null) {
//r索引节点持有的数据节点
Node<K,V> n = r.node;
//该数据节点的key
K k = n.key;
//如果n的值为nul则表示该索引节点需要删除
if (n.value == null) {
//删除索引节点，删除失败则重新开始
if (!q.unlink(r))
break;
//删除成功后r为q的新右侧索引节点
r = q.right;
continue;
}
//r节点不是删除节点则比较key大小，r索引持有的key小于新插入的key则继续向右移
if (cpr(cmp, key, k) > 0) {
q = r;
r = r.right;
continue;
}
}
//表示r为null或者r节点持有的数据key大于新插入数据的key
//如果q下一层为null则直接返回q持有的数据节点
if ((d = q.down) == null)
return q.node;
//如果q.down不为null，则向下一层查找
q = d;
r = d.right;
}
}
}
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 (;;) {
//b根据key找到的前驱节点
for (Node<K,V> b = findPredecessor(key, cmp), n = b.next;;) {
Object v; int c;
//如果b的后继为null则跳出外层循环返回null
if (n == null)
break outer;
//f为n的后继节点
Node<K,V> f = n.next;
//如果n不是b的后继则跳出循环重新开始
if (n != b.next)
break;
//如果n节点是需要删除节点则删除重新开始
if ((v = n.value) == null) {
n.helpDelete(b, f);
break;
}
//如果b节点是删除节点重新开始
if (b.value == null || v == n)
break;
//和n节点的key对比，如果相等则返回值
if ((c = cpr(cmp, key, n.key)) == 0) {
@SuppressWarnings("unchecked") V vv = (V)v;
return vv;
}
//如果小于n节点的key则返回null( 因为key>p.key)
if (c < 0)
break outer;
//否则继续向后查询
b = n;
n = f;
}
}
return null;
}