第三十三夜 · 跳表
数据该流起来了
第32夜我们把四份报文认全了。注册报文把报告能力报给数据中心,订购报文把订单下回来,上报报文按节奏交数,撤销报文把订单撤掉;受理台那段嵌套六层的判定代码,也从外到内剖了一遍。报文的事,说到这里可以说完整了。
但报文只是纸面上的单子。单子认完了,数还没流起来。这一夜该回答一个更靠里的问题。上报报文里那些按时间排列的读数,在被发出去之前,存在哪?
第30夜拆过事件那一侧的机器。报告这一侧的机器还封着口。它内部有一座工坊,工坊里每一条被订购的报告项,都配了一本这样的结构。
java
// 每份订购一座工坊;每条报告项一本跳表:键是时间戳(毫秒),值是那一拍的读数
ConcurrentSkipListMap<Long, BufferValue> buffer = new ConcurrentSkipListMap<>();
这行声明出自报告编排器。名字很长,先只看一个问题。这台机器存读数,为什么用 ConcurrentSkipListMap,而不是 Java 工程里无处不在的 HashMap?
把这个大问题拆成三个小问题,挂在这一夜的门上。
第一问。采样任务按采样粒度走,比如十五分钟读一条;上报任务按上报周期走,比如一小时才来取一次。读数是时间点上的事实,错过了那一拍,事后补不出来,电压不会为你倒回十分钟。那么在两次上报之间,读数放哪?没有谁把它们接住,上报任务到点就是两手空空。
第二问。就算找到了容器来放,取数的那一刻,采样任务可能正在往里写新的一条。一写一读撞在同一份结构上,会出什么事?
第三问。退一步说,就算要一个并发安全的容器,HashMap 换成 ConcurrentHashMap 不就行了,它天天在工程里用,为什么这里偏偏是 ConcurrentSkipListMap?
一句我听不懂的话
这就很坑了,对于我们初学者来说。在学校教书,如果不是参加ACM竞赛,谁会了解工业级Hash Map的内部结构?也不会想到用跳表。场景这样的:第一,教学没有这个场景;第二,书上也不教。比如我刚进公司时,老说这里用跳表,我都不知道为什么。甚至有没有可能说,连跳表都没听过,查了半天也不知道怎么用,这就是很大的断层。
这段话是我今天写这一夜的动机。断层不止一处。教学里没有真实场景,课桌上练的是红黑树旋转几步;教科书也没有多少条目可查,通行的主流教材里,红黑树整章伺候,跳表常常整本不提,《算法导论》各版均无此结构,第33夜后文还会回到这条公案;就算搜到了 ConcurrentSkipListMap 的官方文档,文档只回答怎么调用,不回答什么场景该用它。三层叠起来,一个初学者站在一台真实机器面前,面对的就是考古现场,手里没有铲子。
还有一个补充要放在这里。当年前辈口中那句「这里用跳表」,说的那个「这里」,就是报文上报的缓冲区。这句话背后是三个需求。采样任务往里写,要并发安全;读数带时间戳,要按时间有序;上报任务取数,一取就是一整段。三个需求,恰好对上跳表的三样本领。怎么个对法,这一夜剩下的部分都在回答它。
最笨的存法,一站一站数
把需求放一边,先看最朴素的存法。
一条链表,节点一个拉一个,每个节点只认识自己的下一站。按时间把读数挂上去,链自然是按时间有序的。要找第 165 分钟那条读数,只能从链头出发,一站一站往前数,数十一跳才到。链有一万条,最坏就要数一万跳,行话记作 O(n),意思是步数和数据条数成正比。
这里插进这一夜唯一一组比喻。找站这件事,像坐一趟慢车。从北京到上海,沿途每一站都停,一站一站数过去。链表就是那趟慢车,底层的每一站都必须停靠,谁也跳不过去。
慢车的问题不在慢,在它已经是最短的那条路了。链表的结构决定了,任何查找都必须从头走到位,一站不能省。
有人会问,数组不是可以二分查找吗,对半折着找,O(\\log n)。对,但数组往中间插一条,后面全部要整体搬一格。缓冲这个场景两头都要。插入频繁,每十五分钟一条;查找取段,每小时一整窗。数组快查慢插,链表快插慢查,都只满足一半。于是问题变成,能不能让一条按序的结构,既保持插入只改指针的轻巧,又把查找降到对数级。
手工索引,和它的死门
办法不神秘,就是给慢车加几层快车。
底层保持原链,一站不落。往上,每隔一站把节点提一个上去,挂成第二条链,这条链只有一半的站。再往上提一层,只剩四分之一的站。找第 165 分钟,先在最上层走,几大步就逼近目标,走不动了往下降一层,再用中步走,最后落到底层用小步收尾。层数是 O(\\log n),每层走常数步,总步数也是 O(\\log n)。一万条数据,几十步就到。
这张蓝图漂亮得像教科书。问题也正出在像教科书。这种每隔一站提一个的完美索引,是要维护的。
新节点要插进正中间。底层好办,改两处指针就接上了。可上面几层乱了,原来提上去的那些节点,间隔全变了味,要继续维持「每隔一个提一个」,就得把上层半条链拆了重排。插一条数据,施工全线。删除同理,删掉一个被提上去的节点,上层还得补位。数据的插入删除一频繁,全线的重排就一频繁,省下的查找时间全赔进维护里。
铁路的线路是铁路局精心规划出来的,哪趟快车停哪些站,图纸上定死的。请记住这个细节,它是这一夜最重要的一处失真,因为跳表恰好不是这样。这是后话。
面对「完美索引维护不起」,前面其实摆着两条路。
第一条路,认真维护。让结构在每次插入删除之后立刻自我修理,始终保持严格平衡,这就是平衡树的思路。AVL 树靠高度差检查,红黑树靠颜色规则,插入最多旋转两次,删除最多旋转三次还要沿途调整颜色。严格平衡的报酬是查找最坏情形也有保证,代价是每次修改都付施工费,红黑树删除的修理逻辑在教科书里占了满满几十页。第一条路是课本的主路。
第二条路,不维护,指望结构自己平衡起来。怎么个平衡法,就是下一节。
掷硬币开工
跳表对「每隔一站提一个」的改法只有一句话。不规划了,掷硬币。
新节点进网,从第 1 层起。掷一枚硬币,正面,升到第 2 层,再掷;反面,停。也就是说,一个节点的层数,一半的概率停在 1 层,四分之一到 2 层,八分之一到 3 层,如此翻倍递减。用数学写,期望层数是
\\sum_{k=1}\^{\\infty} k \\cdot \\left(\\frac{1}{2}\\right)\^k = \\frac{1}{1-\\tfrac12} = 2
平均每个节点两层。往上数,第 k 层的节点数期望是 \\dfrac{n}{2\^{k-1}},恰好复刻了那张完美索引的逐层减半,只不过没有人去规划它,每一层的密度是亿万个硬币掷出来的统计结果。
查找呢,还是快车换乘慢车,逐层降落。Pugh 在 1990 年的论文里证明了更强的一件事。单个节点的层数可能很差,但查找路径的长度是期望 O(\\log n),而且超过常数倍 \\log n 的概率随数据量增大指数级衰减。翻译成人话,不是平均不错偶尔很差,是高概率都不差。个体随从,整体自律。每个节点各掷各的硬币,谁也不听谁的号令,整张表的层分布却自动趋向均匀。
现在可以兑现那处失真声明了。快车慢车的线路,不是铁路局规划的,是每个新站自己掷硬币掷出来的。掷出来的线路,期望上竟比精心规划的更好。精心规划要付出全线施工的代价,掷硬币只付出一次,出生时掷完,终身不返工。两种哲学在这里分了岔。平衡树按次收费,每次修改还债施工;跳表一次性收费,用概率上的极小坏运气,换掉全部维护工程。
这组对照还藏着一把尺的分岔,值得单独说。课本的标准尺,量的是最坏情形可证明。红黑树无论你怎么恶意插入,查找都不坏于 O(\\log n),跳表理论上可以全员掷出 1 层,退化成一条链,最坏无界,按这把尺,跳表不及格。工业的标准尺,量的是期望表现、实现长短、并发友好程度。跳表没有旋转、实现短、插入只动局部,按这把尺,跳表是状元。不是谁对谁错,是两把尺量不同的标准。顺带一提,这本书的第5卷书名就叫《电力会掷色子吗》,讨论的是电网里的随机性;其实在软件世界里,算法自己早就掷上了色子,而且是二分之一的硬币。
增删查,和永不中断
结构讲完,回到这台机器要处理的正事。跳表的三样本领,逐一对上报文上报的三个需求。
先看查找与取时间段报文。上报任务要的是过去一小时整窗的读数。跳表的底层天然是一条按时间排好的链,取一段就是从窗口起点走到终点,沿途全是现成的顺序,不用像树那样上蹿下跳地遍历。范围查询是链的看家本领,这是第三个需求选跳表的直接缘由。
再看插入。采样任务每十五分钟写入一条。跳表的插入三步走。先从最高层降落找到每层的前驱,掷硬币定层数,逐层接指针。每一层只改两条连线,前驱的下一站改指新节点,新节点的下一站接上原来的后继。谁也不旋转,谁也不重排,其余节点一概不惊动。这个只动局部的脾气,是后文一切并发安全的基石。
然后是并发本身。第一问的第二小问还没答。取数的那一刻,写入同时发生,会出什么事?
如果容器是普通结构,答案是会坏。遍历进行到一半,写入把指针改了,遍历的进程只做了一半,轻则漏数据重则直接崩,Java 的普通集合在遍历中遇修改,会干脆地抛出并发修改异常。ConcurrentSkipListMap 把这件事从崩溃降级成了两句话。写入侧,指针的切换靠一条叫 CAS 的原子指令兜底;读取侧,遍历器是弱一致的。
CAS,全名 Compare-And-Swap,比较再换。它的民间直觉是看一眼再换。改之前看一眼那个位置的旧值,还是不是我刚才看到的那个;是,就换成我的;不是,说明有人抢先动过了,重来一遍。这里要做一处失真声明。看一眼再换在人话里是三步,在硬件里是一条原子指令,三步之间谁也插不进来。它防的是写入之间的互相踩踏;机制层面的细节,比如换值前旧值被人改回去又改走怎么办,留到下一夜拆。
弱一致遍历,说的是读取侧的让步。遍历开始之后,别人新写入的条目,可能看见,可能看不见,不保证;但永远不崩,永远不中断。放进场景里,上报任务取窗口遍历时,采样任务刚好写入一条,这条可能落进这一窗,也可能落到下一窗。会不会错数?窗口是历史时段,窗口边缘一条之差,游标按窗口边界向前推进,下一个窗口自然接上,业务容忍这一点微差。用最强的一致性去保护一个不需要那么强的场景,才是浪费。
把这三层收拢成一句判词。并发安全的容器保证的从来不是时序一致,是永不中断。
这一夜讲的结构,可以画出来看了。下图用演示件补测 187 之后的真实整表绘制。六层,二十一个节点。同一个键在多层复现,就是同一个节点带出的多层指针,浅虚线把它们上下对齐;第 1 层每站都停,第 6 层只剩 30 和 240 两站,掷硬币掷出来的逐层减半,就是图中这副样貌。

三根顶梁柱
跳表这名字,课桌旁听不到,机房里却天天在运转。这段公案分三幕。
第一幕,1990 年,Pugh 发表论文,标题就叫《跳表,平衡树的概率性替代》。文中宣称跳表 seem likely to supplant balanced trees,似乎很可能取代平衡树。
第二幕,课本没接。《算法导论》通行各版,红黑树整章,跳表无一处正文;Sedgewick 的《算法》第 4 版收了红黑树,没收跳表;中文教学与考研大纲线基本不涉及。少数派也有,Weiss 的《数据结构与算法分析》Java 版在高级数据结构一章里正式收录了跳表,这算课本阵营里难得的一票。论文吹过的牛,课本没接。
第三幕,工业重仓。三个全球部署量最大的系统,底层全是跳表。Redis 的有序集合,分数排序、范围取段,排行榜前一百名一查即得,元素多起来之后底层就是跳表;LevelDB 与 RocksDB 这两个存储引擎,写入先进内存表(memtable),攒满再刷成磁盘文件,那段内存表就是跳表,要的就是按序插入快和按序遍历顺;Java 标准库里唯一的一个并发有序映射,就是 ConcurrentSkipListMap。课本没教的,工业天天用。
为什么三家都选它,四条理由其实这一夜已经各讲过一遍。范围查询天生顺,底层是链;实现短,没有旋转没有重平衡;并发友好,插入只动局部指针,配上 CAS 天然适合不加锁;概率平衡,出生掷一次,终身不施工。
发明者值得认识一下。William Pugh,1960 年生,马里兰大学荣休教授。1990 年造出跳表,后来又与人合作造了 FindBugs,一款扫描 Java 代码找潜在缺陷的静态分析工具,在工程师群体里人手一份。发明结构的人,后来做了找错的工具,两件事放在一个人身上,倒也自洽。
有一处归属要分清。前两家用的是跳表这个结构本身,各自用自己的语言实现;Java 的 ConcurrentSkipListMap 只是这个结构在 Java 标准库里的一份实现。结构是原理,类是岗位。
回到那台机器
现在把第33夜开头的那本缓冲,按真实工程的用法讲完。
每份订购一到,工坊开工,为每条报告项新建一本跳表,键是时间戳的毫秒数,值是那一拍的读数。读数有两种可能形态,一种是浮点数值,一种是以状态对象存在的整段读数,装在同一个叫 BufferValue 的容器类型里。
采样任务每拍写入,调用的就是 put。开工时还有一处细节,每个报告项先预写两条,保证上报任务的第一窗不空。上报任务到点,调用的就是 subMap,按窗口起点和终点整段取出,然后逐条把读数变成上报报文里的一条 interval。第32夜解剖的上报报文,那段 intervals 里每一条的编号、时长、时间戳、读数,源头就是这缓冲区里的每条原料,取出来现场组装,随组装随发车。
java
// 采样任务每拍写入:时间戳作键,读数作值
buffer.put(timeMs, value);
// 上报任务到点:按窗口整段取出,逐条变成报文里的 interval
for (Entry<Long, BufferValue> entry : buffer.subMap(startMs, endMs).entrySet()) {
reportBuilder.addInterval(entry.getValue().toInterval(...));
}
// 窗口游标向前推,只进不退
nextReportStart.put(rid, endMs);
(片段为行文清晰改写,结构与真实工程一致。)
还剩两处细节,都值得看一眼。其一,游标向前推进前有个兜底,游标查不到就从 firstKey 起步,也就是全表最早的那个时间戳。其二,取窗之后没有任何删除动作,缓冲只进不出,从不清理,跑得越久占得越多,订单撤销时整座工坊连表带任务一起交给垃圾回收。这是真实工程里一处公然的粗糙处理,功能无碍,体面难看,留在这里当标本。
三个需求的答案至此齐了。写入要并发安全,弱一致的遍历加只动局部的插入接住了;读数要有序,键就是时间戳;取数要整段,subMap 一段到手。至于第32夜埋下的那处伏笔,组装 interval 时置信度与精度两个参数被写死成 1,协议留了诚实空位而机器写死了答案,那一幕留给下一夜。
【对照卡】跳表(Skip List)。概率性的多层有序链表,插入、查找、删除的期望代价都是 O(\\log n),层数由出生时掷硬币决定,终身不返工。
【对照卡】CAS(Compare-And-Swap,比较再换)。修改前核对旧值,未被他人动过才写入,硬件原子指令;本夜只取直觉,机制留待下一夜。
【对照卡】subMap。按键的范围取出一段视图。编排器用它整窗取数。
【对照卡】firstKey。当前最小键。游标丢失时的兜底起点。
它到底解决什么问题
这一节回答一句话。ConcurrentSkipListMap 到底为解决什么问题而生。
一句话。当多条线程要同时读写同一份按序组织的数据,并且要按范围整段取出时,就用它。它给出的答案是四个词,有序,原子,不中断,免锁。有序,键始终排列整齐;原子,单次操作有明确的完成点,他人要么看到之前,要么看到之后;不中断,遍历永不给出拆到一半的结构;免锁,这一切不靠任何人排队。要么看到之后;不中断,遍历永不给出半截结构;免锁,这一切不靠任何人排队。
开场挂门上的三问,逐条作答。
| 门上的问题 | 答案的位置 | 一句话回答 |
|---|---|---|
| 读数放哪,为什么必须有个缓冲 | 第一节 | 读数是时间点上的事实,采样与上报节拍不同,中途必须有人攒着 |
| 一写一读同时发生,怎么不打架 | 增删查一节 | 弱一致遍历加只动局部的插入,永不中断,窗口边缘微差业务可容 |
| 为什么不是天天见的 HashMap | 掷硬币开工与三根顶梁柱 | 取窗要求按时间有序,哈希表天生无序,顺序正是跳表的看家本领 |
本夜演示件
随书源码里的 SkipListDemo.java 是一张玩具跳表,与编排器同构。键是采样时刻的第几分钟,值是那一拍的读数。它把三件事全部打印出来,每个节点入网时掷硬币掷出的层数,整张表逐层剩哪些站,以及一次查找的完整降落路径。
掷硬币是真实的随机,每次运行生成的结构都不同。请至少跑三次,对比三次的整表,你会发现逐层减半的趋势每一次都在,具体哪些站被提上去每一次都不同。这个现象就是跳表全部哲学的一张缩略照。
下面是本次运行的完整输出。
text
== 采样入库:每 15 分钟一条,共 20 条 ==
入网:键= 0 分钟,掷硬币掷出 1 层
入网:键= 15 分钟,掷硬币掷出 1 层
入网:键= 30 分钟,掷硬币掷出 6 层
入网:键= 45 分钟,掷硬币掷出 1 层
入网:键= 60 分钟,掷硬币掷出 1 层
入网:键= 75 分钟,掷硬币掷出 1 层
入网:键= 90 分钟,掷硬币掷出 1 层
入网:键=105 分钟,掷硬币掷出 3 层
入网:键=120 分钟,掷硬币掷出 1 层
入网:键=135 分钟,掷硬币掷出 2 层
入网:键=150 分钟,掷硬币掷出 1 层
入网:键=165 分钟,掷硬币掷出 1 层
入网:键=180 分钟,掷硬币掷出 1 层
入网:键=195 分钟,掷硬币掷出 1 层
入网:键=210 分钟,掷硬币掷出 2 层
入网:键=225 分钟,掷硬币掷出 3 层
入网:键=240 分钟,掷硬币掷出 6 层
入网:键=255 分钟,掷硬币掷出 2 层
入网:键=270 分钟,掷硬币掷出 1 层
入网:键=285 分钟,掷硬币掷出 2 层
---------- 当前整表 ----------
第 6 层( 2 节点):head -> 30 -> 240 -> null
第 5 层( 2 节点):head -> 30 -> 240 -> null
第 4 层( 2 节点):head -> 30 -> 240 -> null
第 3 层( 4 节点):head -> 30 -> 105 -> 225 -> 240 -> null
第 2 层( 8 节点):head -> 30 -> 105 -> 135 -> 210 -> 225 -> 240 -> 255 -> 285 -> null
第 1 层(20 节点):head -> 0 -> 15 -> 30 -> 45 -> 60 -> 75 -> 90 -> 105 -> 120 -> 135 -> 150 -> 165 -> 180 -> 195 -> 210 -> 225 -> 240 -> 255 -> 270 -> 285 -> null
查找键=165:
第 6 层:head -> 30(30 < 165,快车继续开)
第 6 层:30 的下一站已越过 165,降层
第 5 层:30 的下一站已越过 165,降层
第 4 层:30 的下一站已越过 165,降层
第 3 层:30 -> 105(105 < 165,快车继续开)
第 3 层:105 的下一站已越过 165,降层
第 2 层:105 -> 135(135 < 165,快车继续开)
第 2 层:135 的下一站已越过 165,降层
第 1 层:135 -> 150(150 < 165,快车继续开)
第 1 层:命中 165,值 = 317.6,共 5 步
== 补测一条第 187 分钟的读数 ==
入网:键=187 分钟,掷硬币掷出 4 层
---------- 当前整表 ----------
第 6 层( 2 节点):head -> 30 -> 240 -> null
第 5 层( 2 节点):head -> 30 -> 240 -> null
第 4 层( 3 节点):head -> 30 -> 187 -> 240 -> null
第 3 层( 5 节点):head -> 30 -> 105 -> 187 -> 225 -> 240 -> null
第 2 层( 9 节点):head -> 30 -> 105 -> 135 -> 187 -> 210 -> 225 -> 240 -> 255 -> 285 -> null
第 1 层(21 节点):head -> 0 -> 15 -> 30 -> 45 -> 60 -> 75 -> 90 -> 105 -> 120 -> 135 -> 150 -> 165 -> 180 -> 187 -> 195 -> 210 -> 225 -> 240 -> 255 -> 270 -> 285 -> null
几处值得盯着看。二十个节点掷出三十六层,平均一点八层,贴着期望值 2。整表从二十条逐层减到八条、四条、两条,教科书里那张逐层减半的图,是掷硬币掷出来的统计结果,不是谁画的。查找第 165 分钟只走五步,同一条数据在普通链表里要从头数十一跳。最后看补测。第 187 分钟这条读数掷出 4 层,接入时只改了自己那一层到第四层的八条指针,其余二十个节点一个都没挪,表却完整地接好了。这一张输出,就是这一夜全部理论的实跑。
演示件全文如下,与随书源码同名文件一致。
java
// 第三十三夜演示件:SkipListDemo.java
// 一张玩具跳表:掷硬币升层、逐层降落查找、整表打印,全部肉眼可见。
// 场景与编排器同构:键是采样时刻(第几分钟),值是那一拍的读数。
// 每次运行,掷硬币的结果都不同,生成的结构也不同:这正是跳表的魂,跑三次对比着看。
//
// 运行:java -Dstdout.encoding=UTF-8 SkipListDemo.java
import java.util.Random;
public class SkipListDemo {
// 最高层数封顶。真实工程里这个上限通常取 32,玩具表 6 层足够看清。
static final int MAX_LEVEL = 6;
// 概率源:跳表唯一的"施工机器"就是这枚骰子。
static final Random RNG = new Random();
// 节点:一个键、一个值、一排指针。
// next[l] 是本节点在第 l 层的下一站;层数在出生时由掷硬币决定,终身不变。
static class Node {
final long key; // 采样时刻(分钟)
final double value; // 该时刻的读数
final Node[] next; // next[0] 是慢车(底层全停),next[l] 越高站越少
final int level; // 本节点的层数,出生掷出,永不返工
Node(long key, double value, int level) {
this.key = key;
this.value = value;
this.level = level;
this.next = new Node[level];
}
}
// 哨兵头节点:不存任何数据,只是所有层共同的出发点。
static final Node HEAD = new Node(-1, 0, MAX_LEVEL);
// 当前实际最高层。只增不减(玩具简化:不实现删除,也就不必降层)。
static int curMax = 1;
// 掷硬币定层数:从 1 层起,每次掷出正面(概率 1/2)就再升一层,直到反面或封顶。
// 期望层数是 2:一半的节点停在第 1 层,四分之一升到第 2 层,八分之一到第 3 层......
static int randomLevel() {
int lv = 1;
while (RNG.nextDouble() < 0.5 && lv < MAX_LEVEL) {
lv++;
}
return lv;
}
// 插入:三步走。先从最高层降落找每层的前驱,再掷硬币定层数,最后逐层接指针。
static void insert(long key, double value) {
int lv = randomLevel();
// 第一步:从最高层出发找"每层上,最后一个比 key 小的节点"。
// update[l] 记下每层的前驱,等会儿新节点就插在 update[l] 和它原后继之间。
Node[] update = new Node[MAX_LEVEL];
Node cur = HEAD;
for (int l = curMax - 1; l >= 0; l--) {
while (cur.next[l] != null && cur.next[l].key < key) {
cur = cur.next[l];
}
update[l] = cur;
}
// 第二步:若掷出的层数超过现有最高层,新开的层前驱就是头节点。
if (lv > curMax) {
for (int l = curMax; l < lv; l++) {
update[l] = HEAD;
}
curMax = lv;
}
// 第三步:逐层接指针。每一层只改两条连线。前驱的下一站改指新节点,新节点的下一站接原后继。
// 注意这三步谁也不旋转、不重排、不惊动别的节点:并发好脾气就是从这里来的。
Node node = new Node(key, value, lv);
for (int l = 0; l < lv; l++) {
node.next[l] = update[l].next[l];
update[l].next[l] = node;
}
System.out.printf("入网:键=%3d 分钟,掷硬币掷出 %d 层%n", key, lv);
}
// 打印一个节点的显示名:哨兵头显示为 head,其余显示键值。
static String name(Node n) {
return n == HEAD ? "head" : String.valueOf(n.key);
}
// 查找:从最高层出发,能走则走(快车),走不动就降一层(换乘慢车),直到 0 层。
// 沿途把每一步打印出来,降落路径肉眼可见。
static void search(long key) {
System.out.printf("查找键=%d:%n", key);
Node cur = HEAD;
for (int l = curMax - 1; l >= 0; l--) {
while (cur.next[l] != null && cur.next[l].key < key) {
System.out.printf(" 第 %d 层:%s -> %d(%d < %d,快车继续开)%n",
l + 1, name(cur), cur.next[l].key, cur.next[l].key, key);
cur = cur.next[l];
}
if (cur.next[l] != null && cur.next[l].key == key) {
System.out.printf(" 第 %d 层:命中 %d,值 = %.1f,共 %d 步%n",
l + 1, key, cur.next[l].value, totalSteps(key));
return;
}
System.out.printf(" 第 %d 层:%s 的下一站已越过 %d,降层%n", l + 1, name(cur), key);
}
System.out.println(" 走到底层尽头,查无此键");
}
// 统计本次查找总步数(各层走的站数之和),用于与层数对照。
static int totalSteps(long key) {
int steps = 0;
Node cur = HEAD;
for (int l = curMax - 1; l >= 0; l--) {
while (cur.next[l] != null && cur.next[l].key < key) {
cur = cur.next[l];
steps++;
}
if (cur.next[l] != null && cur.next[l].key == key) {
return steps + 1;
}
}
return steps;
}
// 打印整张表:从最高层往下,每层一行,该层只剩哪些站一目了然。
static void print() {
System.out.println("---------- 当前整表 ----------");
for (int l = curMax - 1; l >= 0; l--) {
StringBuilder sb = new StringBuilder();
int count = 0;
Node cur = HEAD.next[l];
while (cur != null) {
sb.append(cur.key).append(" -> ");
cur = cur.next[l];
count++;
}
System.out.printf("第 %d 层(%2d 节点):head -> %snull%n", l + 1, count, sb);
}
System.out.println();
}
public static void main(String[] args) {
// 一、模拟采样入库:从第 0 分钟起,每 15 分钟一条,共 20 条,读数 300 上下浮动。
// 每条入库时掷一次硬币:这 20 次掷硬币,决定了整张表的层级分布。
System.out.println("== 采样入库:每 15 分钟一条,共 20 条 ==");
for (int i = 0; i < 20; i++) {
insert(i * 15, 300 + RNG.nextInt(400) / 10.0);
}
print();
// 二、查找:取第 165 分钟的读数。看它换乘几次、几步命中,
// 再与链表从头数的 11 跳(165 是第 12 个节点)对比。
search(165);
System.out.println();
// 三、补测:运维回头补一条第 187 分钟的读数。
// 观察它掷出几层、接了几条指针。谁也没被挪动,表却接好了。
System.out.println("== 补测一条第 187 分钟的读数 ==");
insert(187, 335.0);
print();
}
}
本夜习题
第一题。掷硬币定层数,从 1 层起,每次以二分之一的概率再升一层。求一个节点层数的期望值。再答一问。二十个节点的表里,出现一个 6 层节点,按期望应当有几个 6 层节点?这个实测中的 6 层节点,算不算运气好到反常?
第二题。对着演示件补测后的整表,手推查找键 195 的完整路径。从最高层出发,依次经过哪些层、哪些站,降了几次层,共走几步命中?再答一问。第 187 分钟那个节点,在这条查找路径里扮演了什么角色?
第三题。选型题。单机上要做一个实时排行榜。多条线程同时更新分数,随时取前一百名,还要按分数段筛选。该用什么结构?为什么不是 ConcurrentHashMap,也不是加锁的 TreeMap?加分问。两个人分数相同,键撞上了怎么办?
收束
这一夜的答案可以还给当年那句听不懂的话了。这里用跳表,是一句完整的选型结论。一份按时间排好的数据,多个线程同时写入、按窗口整段取出、全程不加锁,跳表用掷硬币把平衡的维护费降到了零,用弱一致把并发安全做到了永不中断。断层不是山,是课本与工业各管一段留下的缝,这一夜,缝合上一条。下一夜,把这座工坊里的两口钟摘下来,看看报告这一侧凭什么敢零锁五条线程同跑,而事件那一侧,为什么只敢半把锁。
本书目录导航 上一篇:算法一千零一夜 · 第三十二夜 · 元数据报告 下一篇:算法一千零一夜 · 第三十四夜 · 采样与上报的旋律 起点:卷首语·算法童话
版权声明:本文为作者原创,受著作权法保护。未经授权禁止转载、搬运、摘编、改编及任何形式的二次创作;个人学习引用请注明作者与原文出处。转载授权请联系作者(CSDN 私信)。侵权必究。