系统架构 · 时间顺序与因果

场景 1 · 凌晨 NTP 阶跃, 唯一键炸出 Duplicate entry — 雪花 ID 回拨兜底

chrony 阶跃回拨几百毫秒, 发号器立刻产出重复 ID, 订单表唯一键报 Duplicate entry。发号器必须内置回拨兜底。

func (s *Snowflake) Next() (int64, error) {
    now := time.Now().UnixMilli() // Go 1.17+
    if now < s.lastTS {           // 检测到回拨
        drift := time.Duration(s.lastTS-now) * time.Millisecond
        if drift <= 2*time.Second {
            time.Sleep(drift + time.Millisecond) // 关键: 小回拨等钟追平再发
            now = time.Now().UnixMilli()
        } else {
            alertClockBackwards(drift)          // 大回拨: 拒绝发号 + 告警
            return 0, fmt.Errorf("clock backwards %v, refuse to issue", drift)
        }
    }
    if now == s.lastTS {
        s.seq = (s.seq + 1) & 0xFFF  // 同毫秒内序列号递增 (12bit)
        if s.seq == 0 {               // 4096 用尽: 自旋等下一毫秒
            for time.Now().UnixMilli() <= s.lastTS { time.Sleep(100 * time.Microsecond) }
        }
    } else {
        s.seq = 0
    }
    s.lastTS = now
    return (now-epoch)<<22 | s.machine<<12 | s.seq, nil
}

兜底上线后, 阶跃回拨从"资损事故"降级为一条拒绝发号的告警。

场景 2 · 300 台机器一个月漂出 1.8 秒, 定时任务双跑 — chrony 配置

内网机器没配 NTP, 晶振自由漂移, cron 和业务窗口全部失准。指向机房自建源 + 明确 makestep 策略一次配平。

# /etc/chrony.conf — 内网客户端: 指向机房自建源
server ntp1.corp.internal iburst minpoll 4 maxpoll 10
server ntp2.corp.internal iburst
driftfile /var/lib/chrony/drift
makestep 1 3  # 关键: 前 3 次采样偏移 >1s 才阶跃, 之后只 slew 不回拨
rtcsync       # 系统钟写回硬件钟, 重启后不裸奔
# 验证: chronyc tracking 看 "System time" 偏移; chronyc sources -v 看源状态

场景 3 · 订单事件流跨 3 个服务, 排查像看抽帧错位的视频 — Lamport 排序

日志聚合按 @timestamp 排, 跨机事件顺序颠倒。给每个服务嵌 Lamport 计数, 事件带 (lc, nodeID), 聚合端按逻辑序排。

type Node struct {
    id string
    lc uint64
}
func (n *Node) Emit(event string) Envelope { // 本地事件/发送
    n.lc++
    return Envelope{LC: n.lc, Node: n.id, Event: event}
}
func (n *Node) Recv(e Envelope) {            // 收到外部事件
    if e.LC > n.lc { n.lc = e.LC }
    n.lc++  // 关键: max + 1, 因果被固化进序号
}
// 聚合端排序: 先比 LC, 相同用 Node 打破平局
// sort.Slice(envs, func(i, j int) bool {
//     if envs[i].LC != envs[j].LC { return envs[i].LC < envs[j].LC }
//     return envs[i].Node < envs[j].Node })

场景 4 · App 和 Web 同时改购物车, 偶发整字段被旧值覆盖 — Vector Clock 冲突检测

LWW 按墙钟裁决新旧, 两端机器钟有偏差时"新值"会输。Dynamo 风格: 向量钟识别并发写, 并发就保留双版本显式合并。

type VClock map[string]uint64

func merge(a, b VClock) VClock { // 写入时合并双方向量
    m := VClock{}
    for k, v := range a { m[k] = v }
    for k, v := range b {
        if v > m[k] { m[k] = v }
    }
    return m
}
// happens(a, b): a 每个分量 >= b 且至少一个 > → a 支配 b, 可覆盖
// 互不支配 → 并发: 不能覆盖, 保留 siblings 交上层合并
// 关键: 把"悄悄丢更新"变成"显式冲突", 合并策略业务自己定

场景 5 · 压测报告出现"平均耗时 -120ms" — Go/Java 单调钟计时

监控图出现负耗时: 计时用了墙钟差值, NTP 阶跃回拨 120ms。统一改成单调钟计时, 一劳永逸。

// 错法: start.UnixNano() 差值 — 回拨时得负数
// 对法: time.Now() 在 Go 里同时携带 monotonic 读数
start := time.Now()
doWork()
elapsed := time.Since(start) // 关键: 内部只用单调读数, 回拨免疫
log.Info("cost", "ms", elapsed.Milliseconds())
// → 永远 >= 0; NTP 阶跃/闰秒都不影响

// Java 同理: System.nanoTime() 单调, currentTimeMillis() 会跳
// long s = System.nanoTime(); ... (System.nanoTime() - s) / 1_000_000;

场景 6 · 分库分表后要"按时间粗排"的全局 ID — HLC 混合时钟落地

中心 TSO 每次取号多一跳, 各机墙钟又不可信。HLC: 墙钟部分保可读与粗排, 逻辑部分保因果单调。

type HLC struct{ Wall, Log int64 } // max64: 多值取大, 实现为普通 if 比较

func (h *HLC) Emit(nowMs int64) HLC { // 本地事件
    if nowMs > h.Wall {
        return HLC{nowMs, 0}       // 物理钟推进, 逻辑归零
    }
    return HLC{h.Wall, h.Log + 1}  // 同毫秒并发事件, 逻辑位递增
}
func (h *HLC) Recv(m HLC, nowMs int64) HLC {
    w := max64(h.Wall, m.Wall, nowMs)
    switch {
    case w == h.Wall && w == m.Wall: return HLC{w, max64(h.Log, m.Log) + 1}
    case w == h.Wall:                return HLC{w, h.Log + 1}
    case w == m.Wall:                return HLC{w, m.Log + 1}
    default:                         return HLC{w, 0}
    }
}
// 关键: 墙钟回拨时 nowMs 变小, w 不缩水 — HLC 仍单调

场景 7 · 海外用户看到"订单是昨天下的" — UTC 存储 + 本地时区展示

库里存的是部署机本地时区的字符串, 海外节点写入偏 8 小时。规范: 存 UTC, 展示时转用户时区, 谁展示谁转换。

// 写: 一律 UTC 落库 (DATETIME 或 BIGINT epoch ms 均可)
_, err := db.Exec("INSERT INTO orders(id, created_at) VALUES(?, ?)",
    id, time.Now().UTC().Format("2006-01-02 15:04:05"))

// 读: 库里拿到 UTC, 按用户 profile 的时区渲染
loc, _ := time.LoadLocation("Asia/Shanghai")
t, _ := time.ParseInLocation("2006-01-02 15:04:05", utcStr, time.UTC)
fmt.Println(t.In(loc).Format("2006-01-02 15:04:05 MST"))
// → 2026-09-26 14:30:00 CST  (UTC 06:30 + 8h)
// 关键: 库里没有任何本地时区数据, 谁展示谁转换

场景 8 · 手动拨表 2 小时, 支付对账卡死 — NTP 阶跃 vs 渐变选择

业务运行中的机器, 阶跃校正就是"时间原子弹": 定时器被跳过或重放, 雪花 ID 直接重复。运行期只允许 slew 渐变。

# /etc/chrony.conf — 已承载业务的机器: 防运行期阶跃
makestep 1 3      # 只允许开机前 3 次采样阶跃; 运行期一律 slew 渐变
maxslewrate 1000  # 渐变上限 1000ppm: 每秒最多纠 ~1ms, 不惊动业务
rtcsync
# 新装机器偏移 2 小时? 先停业务手动粗校, 再起 chrony 收尾
# 关键: makestep 的阶跃对"运行中的定时器/雪花 ID"是原子弹, 业务期禁用

场景 9 · 风控要求同一用户操作严格有序 — 乱序事件的窗口重排

Kafka 分区内有序, 跨分区/跨源无序; 风控引擎要按因果序处理。事件打 HLC 标 + watermark 窗口缓冲重排。

const windowMs = 500 // 重排窗口: 给乱序留 500ms 裕量

type Reorderer struct {
    buf map[string][]Event // 按 userID 缓冲
}

func (r *Reorderer) Push(e Event) { r.buf[e.User] = append(r.buf[e.User], e) }

func (r *Reorderer) Drain(nowMs int64) []Event { // 定时调用
    cut := nowMs - windowMs // watermark 前的事件不再等
    var out []Event
    for u, evs := range r.buf {
        sort.Slice(evs, func(i, j int) bool { // 用户内按 HLC 全序
            if evs[i].Wall != evs[j].Wall { return evs[i].Wall < evs[j].Wall }
            return evs[i].Log < evs[j].Log
        })
        k := 0
        for k < len(evs) && evs[k].Wall <= cut {
            out = append(out, evs[k]); k++
        }
        r.buf[u] = evs[k:] // 没到 watermark 的留下轮
    }
    return out
}

场景 10 · 批处理总在 NTP 校时那天"假死" — 用单调钟实现超时

自研调度器用墙钟判 deadline, 每次校时阶跃就少跑/多跑一轮。切到单调钟, 与墙钟彻底解耦。

// 错法: deadline 用 UnixNano 存下再比 — 墙钟阶跃直接欺骗判断
deadline := time.Now().Add(3 * time.Second) // time.Time 内含单调读数
for batch := range jobs {
    process(batch)
    if time.Now().After(deadline) { // 关键: After 优先比较单调读数
        return ErrDeadline          // 校时阶跃不再影响判断
    }
}
// 或直接用标准库: ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
// → 内部 timer 同样走单调钟, 语义与墙钟彻底解耦