1
import hashlib
2
import base62
3

4
class URLShortener:
5
    def __init__(self, cache, db):
6
        self.cache = cache
7
        self.db = db
8

9
    def shorten(self, long_url: str) -> str:
10
        # 计算哈希并编码
11
        hash_value = hashlib.md5(long_url.encode()).hexdigest()[:8]
12
        short_code = base62.encode(int(hash_value, 16))
13

14
        # 存储映射关系
15
        self.cache.set(short_code, long_url, ex=86400)
16
        self.db.save(short_code, long_url)
17

18
        return f"https://s.url/{short_code}"
19

20
    def expand(self, short_code: str) -> str:
21
        # 先查缓存
22
        long_url = self.cache.get(short_code)
23
        if long_url:
24
            return long_url
25

26
        # 再查数据库
27
        long_url = self.db.find(short_code)
28
        if long_url:
29
            self.cache.set(short_code, long_url, ex=86400)
30

31
        return long_url

1
发布流程：
2
用户发布 → API服务 → 消息队列 → 消费者 → 写入存储
3

4
拉取流程：
5
用户请求 → API服务 → 缓存查询 → 数据库查询 → 聚合排序 → 返回

1
public class DelayQueue {
2
    private final RedisTemplate<String, Object> redis;
3
    private final String QUEUE_KEY = "delay:queue";
4

5
    // 添加延迟任务
6
    public void offer(String taskId, long delayMs) {
7
        long executeTime = System.currentTimeMillis() + delayMs;
8
        redis.opsForZSet().add(QUEUE_KEY, taskId, executeTime);
9
    }
10

11
    // 消费到期任务
12
    public void consume() {
13
        while (true) {
14
            long now = System.currentTimeMillis();
15
            // 查询到期任务
16
            Set<Object> tasks = redis.opsForZSet()
17
                .rangeByScore(QUEUE_KEY, 0, now, 0, 100);
18

19
            if (tasks == null || tasks.isEmpty()) {
20
                Thread.sleep(100);
21
                continue;
22
            }
23

24
            for (Object task : tasks) {
25
                // CAS 删除，保证只被消费一次
26
                Long removed = redis.opsForZSet()
27
                    .remove(QUEUE_KEY, task);
28
                if (removed > 0) {
29
                    executeTask(task);
30
                }
31
            }
32
        }
33
    }
34
}

1
时间轮结构：
2
[0] → [1] → [2] → ... → [N-1] → [0]（循环）
3
  ↓      ↓      ↓           ↓
4
任务链表 任务链表 任务链表    任务链表
5

6
每个槽位：存储该时刻执行的任务
7
指针移动：每秒移动一格，执行当前槽位的任务

1
第一层：CDN 静态资源 + 动态请求过滤
2
第二层：网关限流（令牌桶/漏桶）
3
第三层：应用层限流（Sentinel）
4
第四层：Redis 原子操作限流

1
// Redis Lua 脚本保证原子性
2
String luaScript = """
3
    local stock = redis.call('GET', KEYS[1])
4
    if tonumber(stock) <= 0 then
5
        return 0
6
    end
7
    redis.call('DECR', KEYS[1])
8
    return 1
9
    """;
10

11
// 执行库存扣减
12
Long result = redis.execute(luaScript, Arrays.asList("stock:sku_001"));
13
if (result == 1) {
14
    // 扣减成功，发送消息异步创建订单
15
    mq.send("order.create", orderInfo);
16
}

1
读优化：
2
- 静态资源 CDN 加速
3
- 商品详情页静态化
4
- Redis 缓存热点数据
5

6
写优化：
7
- 消息队列异步削峰
8
- 批量写入数据库
9
- 分库分表

1
64位结构：
2
0 - 41位时间戳 - 10位机器ID - 12位序列号
3

4
| 1位符号位 | 41位时间戳 | 10位机器ID | 12位序列号 |
5
|----------|-----------|-----------|-----------|
6
|   0      | 毫秒级时间 |  数据中心+机器 |  毫秒内序列 |
7

8
- 时间戳：41位可使用 69 年
9
- 机器ID：支持 1024 台机器
10
- 序列号：每毫秒可生成 4096 个 ID
11
- 理论 QPS：400万+/秒

1
public class SnowflakeIdGenerator {
2
    private final long epoch = 1288834974657L; // 起始时间戳
3
    private final long workerIdBits = 10L;     // 机器ID位数
4
    private final long sequenceBits = 12L;     // 序列号位数
5

6
    private final long maxWorkerId = ~(-1L << workerIdBits);  // 1023
7
    private final long sequenceMask = ~(-1L << sequenceBits); // 4095
8

9
    private long workerId;
10
    private long sequence = 0L;
11
    private long lastTimestamp = -1L;
12

13
    public synchronized long nextId() {
14
        long timestamp = System.currentTimeMillis();
15

16
        // 时钟回拨处理
17
        if (timestamp < lastTimestamp) {
18
            throw new RuntimeException("时钟回拨");
19
        }
20

21
        if (timestamp == lastTimestamp) {
22
            sequence = (sequence + 1) & sequenceMask;
23
            if (sequence == 0) {
24
                timestamp = tilNextMillis(lastTimestamp);
25
            }
26
        } else {
27
            sequence = 0L;
28
        }
29

30
        lastTimestamp = timestamp;
31

32
        return ((timestamp - epoch) << (workerIdBits + sequenceBits))
33
             | (workerId << sequenceBits)
34
             | sequence;
35
    }
36
}

1
每次从数据库取一个号段：
2
[1000, 2000] → 应用内存分配 → 分配完毕再取下一号段
3

4
优点：
5
- 减少 DB 访问次数
6
- 高性能（QPS 可达 10 万+）
7

8
缺点：
9
- ID 不连续（重启可能丢失）
10
- 依赖 DB

1
传统哈希：hash(key) % N
2

3
问题：当节点数 N 变化时，几乎所有 key 的映射都会改变
4
扩容：N=4 → N=5，约 80% 的 key 需要迁移

1
问题：节点少时，数据分布可能不均匀
2
解决：每个物理节点对应多个虚拟节点
3

4
实现：
5
Node A → Node A#1, Node A#2, ..., Node A#150
6
Node B → Node B#1, Node B#2, ..., Node B#150
7

8
虚拟节点映射到哈希环上，使数据分布更均匀

1
public class ConsistentHash {
2
    private final TreeMap<Long, String> ring = new TreeMap<>();
3
    private final int virtualNodes = 150;
4

5
    // 添加节点
6
    public void addNode(String node) {
7
        for (int i = 0; i < virtualNodes; i++) {
8
            String virtualNode = node + "#" + i;
9
            long hash = hash(virtualNode);
10
            ring.put(hash, node);
11
        }
12
    }
13

14
    // 获取 key 对应的节点
15
    public String getNode(String key) {
16
        if (ring.isEmpty()) {
17
            return null;
18
        }
19
        long hash = hash(key);
20
        // 顺时针查找第一个大于等于 hash 的节点
21
        Map.Entry<Long, String> entry = ring.ceilingEntry(hash);
22
        if (entry == null) {
23
            entry = ring.firstEntry(); // 环形，回到起点
24
        }
25
        return entry.getValue();
26
    }
27

28
    private long hash(String key) {
29
        return CRC16.crc16(key.getBytes()) & 0xFFFFFFFFL;
30
    }
31
}