跳表为什么Redis用

折腾了好几天终于搞定了，核心其实不难，但有几个坑容易踩。把要点列出来，省得大家再走弯路。

先搞清楚原理

跳表的底层原理涉及资源竞争。用代码演示比画图更直观：

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}
        self.order = []

    def get(self, key: str):
        if key in self.cache:
            self.order.remove(key)
            self.order.append(key)
            return self.cache[key]
        return -1

    def put(self, key: str, value):
        if key in self.cache:
            self.order.remove(key)
        elif len(self.cache) >= self.capacity:
            oldest = self.order.pop(0)
            del self.cache[oldest]
        self.cache[key] = value
        self.order.append(key)

cache = LRUCache(3)
pages = [1, 2, 3, 1, 4, 1, 5, 3]
hits, misses = 0, 0
for page in pages:
    if cache.get(page) != -1:
        hits += 1
    else:
        misses += 1
        cache.put(page, f'data_{page}')
print(f'命中率: {hits/(hits+misses)*100:.1f}%')

实际怎么用

写代码的时候，跳表有几个常见写法。推荐用下面这种方式，代码更清晰，也更容易维护：

def quicksort(arr: list) -> list:
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

import time, random
data = [random.randint(0, 10000) for _ in range(10000)]
start = time.time()
sorted_data = quicksort(data)
elapsed = time.time() - start
print(f'排序10000个元素耗时: {elapsed*1000:.2f}ms')
print(f'验证排序: {sorted_data == sorted(data)}')

进阶一点的用法

跳表在复杂场景下的用法和简单场景差别挺大。主要是分层抽象设计这块需要额外处理，代码如下：

容易踩的坑

说几个容易踩的坑。第一个是资源竞争的问题，很多人在这上面栽过跟头。第二个是版本兼容性，不同版本行为可能不一样。第三个是边界情况，空值和异常输入要处理好。

写在最后

总结一下，跳表的关键在于分层抽象设计。掌握了这个，其他用法都是在这个基础上扩展。建议多写几个小demo练手，光看不动手容易忘。