返回文章列表

用 Rust 从零搭一个协同编辑服务:CRDT 管收敛,日志管顺序

805 字·6 分钟阅读
Rust从零造轮子分布式协作

讲 CRDT 的那篇回答了一个很漂亮的问题:怎么设计数据结构,让合并结果和顺序无关。

但那篇只回答了"数据怎么合并"。一个协同编辑服务还要回答另外四个问题:

  1. 新加入的人怎么拿到"当前状态"(没法把一年的操作全重放一遍)
  2. 操作日志无限增长怎么办
  3. 谁来决定"持久化的顺序"——如果顺序无关,那日志里凭什么有顺序?
  4. 一个一万人的文档,怎么分片和扩展

这四个问题的答案都不在 CRDT 里。 这篇就是讲它们。

第一步:先选状态型还是操作型——这道分岔决定后面所有设计

CRDT 有两大流派,它们的服务端设计完全不同:

状态型(CvRDT) 操作型(CmRDT)
传输内容 整个状态(或状态差量) 单个操作
合并方式 求并集(join),天然幂等 应用操作,要求不丢不重、因果有序
传输量 大(状态大小) 小(操作大小)
依赖的传输层 最终一致即可(甚至可以靠 gossipsub) 必须有一个可靠广播层
典型场景 计数器、集合、配置 文本编辑、图形编辑

协同编辑几乎必然选操作型,原因有两个:

原因一:状态太大。 一篇十万字的文档,状态型就意味着每有一个人改动一个字,就要把十万字的状态传给别人——虽然可以做差量,但差量本身的计算又是一套复杂机制。

原因二:操作日志有独立价值。 有了操作流,你免费获得:审计(谁改了哪一段)、回放(把文档恢复到某个时刻)、离线编辑(客户端攒一堆操作,联网后一起发)。

但操作型有一个必须自己承担的义务:可靠广播。

操作型 CRDT 的前提:
  ✓ 不丢  —— 每个操作都要送达所有副本
  ✓ 不重  —— 或者让应用操作是幂等的
  ✓ 因果有序 —— 先"插入字符"再"删除它",顺序不能反

这正是"日志"的用武之地。 换句话说:操作型 CRDT 把"合并的复杂度"换成了"传输层的复杂度",而传输层恰好是可以用日志 + 序号解决的问题。

没有一个 CRDT 是"不需要基础设施"的。 状态型把复杂度放在"状态大小和合并频率"上,操作型放在"可靠投递"上。选择哪一种,取决于你更擅长解决哪个问题——而服务端的日志和序号,恰好是工程上最成熟的那一块。

第二步:架构全景——服务端不是状态的权威

这是理解整个系统最重要的一张图:

客户端 A                  服务端                        客户端 B
────────                  ──────                        ────────
本地 CRDT                 ① 收到 op
   │ ② 立即本地应用          │
   │    (不等确认)         ↓
   └─── op ───────────→ ③ 分配 room_seq(单调)
                           │
                           ↓
                        ④ 写操作日志(WAL / LSM)
                           │
                           ↓
                        ⑤ 广播 ──────────────────→ 应用 op
                           │
                        ⑥ 定期压缩成快照
                           ↑
   新客户端 ── 快照 + 增量 ──┘

关键点:服务端不做"合并"这件事。

它只是:

  1. 给每个操作贴一个全局单调序号
  2. 把操作持久化
  3. 把操作广播给房间里的其他人
  4. 定期把日志压缩成快照,给新人用

状态本身是由每个客户端各自算出来的。 服务端甚至可以完全没有文档状态——它只需要日志和快照。

这个设计的直接好处是:服务端是无状态的(除了日志),可以随便重启、随便扩容。 代价是**"正确性"依赖于"所有客户端对同一串操作算出同样的状态"——而这正是 CRDT 提供的保证。**

把"状态的权威"从服务端拿掉,是协同编辑和普通 CRUD 服务最大的区别。 普通服务里,服务端存什么,客户端就显示什么。协同编辑里,服务端只存"发生了什么","现在是什么样"由每个端各自算。

第三步:那为什么还需要中心节点

CRDT 的理论模型是去中心化的(P2P 完全可行)。但工程上仍然需要服务端,理由有四个,而且每一个都跟"控制"无关,全是"工程可行性"层面的:

理由一:定序——日志需要一个确定的顺序

CRDT 说"顺序无关",但日志说"顺序必须确定"。 这两句话不矛盾:

  • 合并结果与顺序无关(CRDT 保证的)
  • 持久化必须有确定的顺序,否则崩溃恢复后重放的内容会不一致
pub struct OpLog {
    store: LsmStore,   // 就是前面写过的 LSM-Tree
}
 
impl OpLog {
    /// 追加一个操作:服务端分配全局序号
    pub fn append(&mut self, room: RoomId, op: &Operation) -> Result<u64> {
        let seq = self.next_seq(room)?;
 
        // key = room_id + seq(大端拼接),和 IM 消息表是同一个布局
        let key = op_key(room, seq);
        self.store.put(key, &encode_op(op))?;
 
        Ok(seq)
    }
 
    /// 重放:从某个 seq 之后的所有操作,按序读出来
    pub fn replay_from(&self, room: RoomId, from_seq: u64) -> impl Iterator<Item = Operation> {
        // 一次 range scan,天然有序 —— 因为 key 是按 seq 大端拼接的
        self.store.scan(op_key(room, from_seq)..op_key(room, u64::MAX))
            .map(|(_, v)| decode_op(&v))
    }
}

注意服务端分配的 room_seq 和操作本身携带的 CRDT 逻辑时钟是两个不同的东西——第五步会详细讲这个区分,它是整篇最容易搞混的地方。

理由二:持久化——总得有人负责"不丢"

P2P 的协同编辑,每个端都存一份完整日志。 一个一万字的文档、一年的编辑历史,几百个端各存一份。

这在理论上是可行的,在实践上是荒谬的。 更重要的是:如果一个用户的所有设备都丢了本地数据,他需要能从别处恢复。

所以"持久化"这件事必须有人承担,而且最好是少数几个地方承担。

理由三:成员与权限

"谁能编辑这个文档"是一个全局共识问题,不是一个可以各自计算的问题。

pub struct RoomMembership {
    /// 谁是 owner / editor / viewer
    pub roles: HashMap<UserId, Role>,
    /// 权限属于哪一代(用于权限变更前的操作判定)
    pub generation: u64,
}

权限校验必须在服务端做——因为它是"拒绝某些操作进入日志"的动作。如果让客户端自己判断,那么一个改过的客户端可以随便往日志里塞操作,而日志一旦被写入就会被所有端重放。

注意 generation 这个字段: 权限被撤销之后,那些在撤销之前生成、但还在路上的操作怎么办? 这是一个真实存在的边界问题——通常用"代"来划分:操作必须携带它生成时的 generation,撤销权限时把代 +1,服务端拒绝低代的操作。

理由四:扇出

一个 1000 人的文档,每个操作要发给 999 个接收者。 在 P2P 里这意味着 999 条出站连接(或者一个相对复杂的 gossip 网络)。

一个中心节点的扇出是它最擅长的事:收一条,广播 N 条。而且它还能顺带做去重、台账、和背压。

中心节点在协同编辑里的角色,和"交换机在以太网里的角色"是同一类:它不改变内容,只负责分发和记忆。 把它理解成"权威状态机"就错了——它是一个有序的、可靠的、可以扇出的日志。

第四步:快照——日志不能无限长

日志可以无限追加,但新人不能重放一年的操作。

时间线:
  seq 1 ────────────────────────────────────────→ seq 1000000
       │                    │                              │
    快照 A              快照 B                          现在
  (含 1..1000)       (含 1..50000)

新人加入时的加载路径:

pub struct RoomSnapshot {
    /// 快照物化出来的文档状态
    pub state: DocumentState,
    /// ★ 关键:这个快照包含了哪些操作
    pub version: VersionVector,
    /// 快照对应到哪个 seq
    pub upto_seq: u64,
}
 
impl Room {
    pub async fn join(&self, client_seq: Option<u64>) -> Result<JoinPayload> {
        // ① 拿到最新的快照
        let snapshot = self.load_latest_snapshot().await?;
 
        // ② 再拿快照之后的增量操作
        let delta = self.log.replay_from(self.room_id, snapshot.upto_seq + 1)
            .collect::<Vec<_>>();
 
        Ok(JoinPayload { snapshot, delta })
    }
}

version 这个字段是必须的,而且它比 upto_seq 更重要。 原因:

upto_seq 只说明"日志读到哪",但一个操作可能被"部分应用"——比如一个复合操作,或者因为因果依赖而暂缓应用的操作。用 upto_seq 做恢复依据,会出现"快照说包含了操作 50,但实际上因为依赖没到,只应用了一半"。

正确的做法是用 CRDT 自己的版本向量(version vector / dot 集合):

impl Room {
    /// 判断一个快照是否已经包含了某个操作
    pub fn snapshot_contains(&self, snap: &RoomSnapshot, op: &Operation) -> bool {
        // 按 CRDT 的因果时钟判断,而不是按物理 seq
        snap.version.contains(&op.dot)
    }
}

这就是"快照的边界必须用 CRDT 自己的时钟表达,而不是用日志的物理序号表达"这条规则。

为什么这个区别是本质的?因为日志序号是"服务端视角的顺序",而版本向量是"因果视角的已见集合"。 崩溃恢复、快照截断、增量补发——这三个操作都发生在"因果"这个层面,所以判据也必须是因果的。

一个"快照"要能被安全使用,必须能回答"我不包含什么"。 只记录"我读到哪"是不够的,因为"读到哪"不等于"处理完了哪"。这就是为什么所有认真的 CRDT 实现都会维护版本向量,而不是一个简单的水位。

第五步:一个操作要携带哪些信息

这是整篇里最容易设计错的地方。一个操作至少有三层身份:

pub struct Operation {
    /// ① 物理位置:服务端分配的全局序号,决定了它在日志里的位置
    pub room_seq: u64,
 
    /// ② 因果身份:这是"哪个副本的第几个操作"
    pub dot: Dot,
 
    /// ③ 内容:具体做了什么
    pub kind: OpKind,
 
    /// ④ 谁做的:用于权限审计和撤销
    pub actor: UserId,
 
    /// ⑤ 权限代:权限变更时的判据
    pub generation: u64,
}
 
/// 点(dot):一个副本的第 n 个操作
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Dot {
    /// 哪个副本(一个客户端会话一个,重连后换新的)
    pub replica: ReplicaId,
    /// 这个副本自己递增的计数器
    pub counter: u64,
}

为什么 room_seq 和 dot 不能合并

这是最常见的错误设计。 看起来很自然:"反正都是序号,用一个不行吗?"

不行,因为它们是两个不同的东西:

room_seq dot
谁分配 服务端(房间内单点) 客户端(本地递增)
何时分配 操作到达服务端时 操作产生的瞬间
全局唯一吗 是(房间内) 是(replica + counter 唯一)
离线状态下有值吗 没有 有
用途 日志位置、补发、快照截断 去重、因果判断、幂等

关键分歧在"离线"。 用户在飞机上改了三处文字,这三个操作在他本机产生时就必须有一个稳定的身份——因为它们会被应用在他本地的 CRDT 上,而且需要能判断"这两个操作是不是同一个"。

如果只有服务端分配的序号,那么离线操作的身份是不存在的,直到它联网上传。而在那之前,客户端已经根据它更新了本地状态——这时如果重传了两次,客户端就无法判断第二次来的是不是同一个操作。

所以 dot 必须在客户端生成,而且必须在应用操作之前生成。

pub struct ClientReplica {
    replica_id: ReplicaId,
    counter: u64,
    /// 已经应用过的操作(用于幂等判断)
    applied: VersionVector,
}
 
impl ClientReplica {
    pub fn local_edit(&mut self, kind: OpKind) -> Operation {
        // ★ 先递增计数器,再生成操作
        //   顺序反了的话,崩溃重启后会生成重复的 dot
        self.counter += 1;
        let dot = Dot { replica: self.replica_id, counter: self.counter };
 
        // 本地立即应用,不等服务端确认
        let op = Operation { room_seq: 0, dot, kind, actor: self.user, generation: 0 };
        self.apply(&op);
 
        op
    }
 
    /// 幂等应用:同一个 dot 只应用一次
    pub fn apply(&mut self, op: &Operation) -> bool {
        if self.applied.contains(&op.dot) {
            return false;   // 已经见过,直接忽略
        }
        self.applied.insert(op.dot);
        self.state.integrate(&op.kind);
        true
    }
}

applied 这个版本向量就是幂等性的全部实现。 而它的规模会随时间增长——这在第九步会变成一个真正的工程问题。

OpKind 的设计:位置必须用标识符,不能用下标

pub enum OpKind {
    Insert {
        /// ★ 不是"在第 5 个字符处插入",而是"在 id 为 X 的字符之后插入"
        after: Option<CharId>,
        ch: char,
        id: CharId,
    },
    Delete {
        target: CharId,
    },
    // 富文本还有格式化标记、属性变更等
}

为什么位置不能用下标? 设想两个人同时编辑:

初始:  "abc"
A 在位置 1 插入 'X'  →  "aXbc"
B 在位置 1 插入 'Y'  →  "aYbc"
 
合并时:
  如果操作用下标(在位置 1 插入),两个操作都指向位置 1
  → 合并结果依赖顺序,而且必然丢掉一个字符

用标识符之后:

A:在字符 'a' 之后插入 'X'
B:在字符 'a' 之后插入 'Y'
 
合并:两个操作都指向 'a' 后面 —— 这是一个"并列位置"
      CRDT 用 replica id 做 tie-break,得到一个确定顺序
      → "aXYbc" 或者 "aYXbc",两个副本结果必然相同(因为是同一个 tie-break 规则)

这就是"位置无关的插入"的全部意义:把"第几个"换成"在谁旁边",让操作在并发下仍然有意义。

凡是"位置"需要被并发地引用的地方,都不能用序号,必须用标识符。 这个思路在别处也出现:IM 里用会话 id 而不是"第几个会话"、版本控制里用内容哈希而不是文件名。序号是"某个时刻的快照",标识符是"一个持续的指称"——并发场景需要后者。

第六步:断线重连与补发

客户端重连时要交换两个方向的信息:

pub struct ReconnectRequest {
    pub room: RoomId,
    /// 我已经处理到哪个物理序号
    pub last_room_seq: u64,
    /// 我本地还没上传的离线操作
    pub pending: Vec<Operation>,
}
 
pub struct ReconnectResponse {
    /// 服务端从 last_room_seq 之后补发的操作
    pub missed: Vec<Operation>,
    /// 服务端已经收到的(用于从 pending 里剔除)
    pub acked_dots: Vec<Dot>,
}

这个交换里有三个必须处理的边界:

边界一:pending 里的操作可能已经被服务端收到过。 客户端上传之后、收到 ack 之前断线,重连时会把同一个操作再上传一次。服务端必须按 dot 去重——因为它可能已经写进日志了。

impl Room {
    pub fn accept_pending(&mut self, ops: Vec<Operation>) -> Result<Vec<Dot>> {
        let mut accepted = Vec::new();
 
        for op in ops {
            // ★ 按 dot 去重:同一个副本的同一个 counter 只接受一次
            if self.seen.contains(&op.dot) {
                accepted.push(op.dot);   // 当成已接受,让客户端清掉本地队列
                continue;
            }
 
            // 校验因果依赖:这个操作引用的字符存在吗?
            if !self.deps_satisfied(&op) {
                // 依赖没到 —— 不能直接丢弃(丢了就永久丢了)
                // 放进"待定区",等依赖到了再应用
                self.pending.push(op);
                continue;
            }
 
            let seq = self.log.append(self.room_id, &op)?;
            self.seen.insert(op.dot);
            self.broadcast(op, seq)?;
            accepted.push(op.dot);
        }
 
        Ok(accepted)
    }
}

边界二:因果依赖可能不满足。 一个离线操作是"在字符 X 之后插入",但字符 X 本身也在一个还没上传的离线操作里。这两个操作如果在同一个 pending 数组里且顺序正确,就没事;如果丢了顺序,就需要"待定区"。

"待定区"是一个很容易被漏掉的结构,而且它是必须的——因为丢弃一个因果未满足的操作,等于永久丢失用户的编辑。而把它放进待定区、等依赖到了再应用,是唯一正确的做法。

边界三:missed 和 pending 的操作可能是同一个。 客户端离线时生成了操作 A,同时服务端可能已经通过其他途径收到了 A(比如另一个设备同步上传的)。这又是靠 dot 去重解决的——所以 dot 的唯一性必须是全局的,不能只在单个连接内唯一。

第七步:awareness 绝对不能进日志

光标位置、选中范围、在线用户列表——这些看起来很像"协同状态",但它们和文档内容是完全不同的东西。

/// 易失状态:单独通道,单独生命周期
pub struct Awareness {
    pub user: UserId,
    pub cursor: Option<CursorPos>,
    pub selection: Option<Range>,
    /// 最后一次心跳时间
    pub last_seen: Instant,
}

如果把它塞进 CRDT 日志,会同时带来三个问题:

问题 表现
日志爆炸 光标每秒移动几次,日志增长比内容编辑快 100 倍
快照膨胀 快照里存着"某个人三小时前的光标位置",毫无意义
重放污染 新人加载快照时,会把一个早就断线的用户的光标也恢复出来

正确做法是独立通道 + 心跳超时:

pub struct AwarenessService {
    /// 每个房间的在线状态(只在内存里,不持久化)
    rooms: HashMap<RoomId, HashMap<UserId, Awareness>>,
    timers: TimerWheel,   // 就是前面写过的定时器
}
 
impl AwarenessService {
    pub fn heartbeat(&mut self, room: RoomId, user: UserId, state: Awareness) {
        // 更新状态 + 重置超时
        let entry = self.rooms.entry(room).or_default();
        entry.insert(user, Awareness { last_seen: Instant::now(), ..state });
 
        self.timers.schedule_after(
            Duration::from_secs(30),
            TimerKey::AwarenessTimeout { room, user },
        );
    }
 
    /// 超时就把这个用户从在线列表里摘掉 —— 不需要任何持久化操作
    pub fn on_timeout(&mut self, room: RoomId, user: UserId) {
        if let Some(map) = self.rooms.get_mut(&room) {
            map.remove(&user);
            // 广播"某人离开了",让其他人的界面上光标消失
        }
    }
}

注意这段代码里没有任何存储操作。 因为在线状态本来就是"会自己消失的状态"——用户断线了,它就该消失,不需要保留。

判断标准可以总结成一句话:

"如果这个状态在用户断线后应该消失,它就不该进日志。"

日志的语义是"这件事发生过,永远为真";而 awareness 的语义是"这个人现在在这里"。 把后者写进前者,就等于承诺"这个人在三小时前在这里,而这件事永远为真"——而它其实是一个会过期的观察,不是一个事实。

这个区分在可观测系统里也一模一样:指标(会过期)和审计日志(永久)不能用同一种存储。 后面写可观测后端时会再遇到同一道题。

第八步:分片、房间与热点

房间之间是完全独立的,所以分片很自然:

pub struct RoomRouter {
    /// 一致性哈希环:room_id → node
    ring: HashRing<NodeId>,
}
 
impl RoomRouter {
    pub fn node_for(&self, room: RoomId) -> NodeId {
        // 用一致性哈希而不是取模:
        // 加一个节点只影响 1/N 的房间,而不是全部重排
        self.ring.get(&room.to_bytes())
    }
}

为什么必须用一致性哈希? 因为房间是有状态的(日志、快照、在线连接)。用简单取模的话,加一个节点会让几乎全部房间重新分配——每个房间都要迁移日志和快照,还要断开重连。 而一致性哈希只影响约 1/N 的房间。

但有一个绕不过去的问题:热点房间。

房间 A:3 个人,每秒 2 个操作
房间 B:8000 个人,每秒 5000 个操作  ← 所有请求都打到同一个节点

一致性哈希解决不了热点——因为房间是分片的最小单位,而最热的那个房间只能落在一个节点上。

可行的做法有三条,都不是完美的:

做法 代价
把房间内部再切分(按文档段落/画布区域) CRDT 操作的因果依赖可能跨区域,实现复杂度剧增
只让"写"走单点,"读"(补发)走多副本 日志的读取端要一致,需要额外同步
给大房间单独开专用节点(手工打散) 运维负担,而且热点是不可预测的

实践中大多数系统选第三条——因为万人大文档本身就是罕见场景,用一个"手工大房间白名单"来回避,比设计一套通用的房间内分片要划算得多。

不是所有的可扩展性问题都值得用通用方案解决。 房间里一个 8000 人的文档,一年可能只有几个,为它设计一套房间内分片机制,会让所有房间的代码都变复杂。 而"给大房间单独一个节点"只需要一份配置表。分布式的第一原则是先问'这个规模真的会出现吗'。

第九步:元数据的膨胀——CRDT 最现实的代价

这里必须把最不好听的部分讲清楚。

文本 CRDT 的每一个字符都要带元数据:

纯文本内容:           1 个字符 = 1 字节
RGA / Yjs 那类的表示:  1 个字符 = 内容 + replica_id + 时钟 + 前后关系 = 20~50 字节

20 到 50 倍的放大。 一篇十万字的文档,CRDT 结构可能是几 MB。

更糟的是删除: 删除一个字符只是标记墓碑,它的位置标识符还必须保留(因为其他并发操作可能还在引用它)。所以"写了又删"的内容量是单调增长的。

pub struct TextCrdt {
    /// 字符节点:包含已删除的(墓碑)
    nodes: VecDeque<CharNode>,
    /// 墓碑数量 —— 这个比例就是膨胀的度量
    tombstones: usize,
}
 
impl TextCrdt {
    /// 真实大小(用户可见的内容)
    pub fn live_len(&self) -> usize {
        self.nodes.len() - self.tombstones
    }
 
    /// 膨胀率:墓碑占比
    pub fn tombstone_ratio(&self) -> f64 {
        self.tombstones as f64 / self.nodes.len() as f64
    }
}

回收墓碑的前提是"所有副本都已经看到了这个删除"。 因为一旦某个副本还没看到删除,它就可能生成一个"引用这个已删字符"的操作——如果字符已经被物理删除,这个操作就悬空了。

这个"所有副本都看到了"的判据,就是版本向量的交集:

impl Room {
    /// 找出所有副本都已经确认过的操作 —— 这些操作引用的墓碑可以被回收
    pub fn safe_gc_point(&self, replicas: &[VersionVector]) -> VersionVector {
        // 所有副本版本向量的"下确界":每个 replica 取最小值
        let mut result = VersionVector::new();
 
        for replica in replicas.iter() {
            for (id, counter) in replica.iter() {
                let min = replicas.iter()
                    .map(|v| v.get(id))
                    .min()
                    .unwrap_or(0);
                if min > 0 {
                    result.set(*id, min);
                }
            }
        }
 
        result
    }
}

但这里有个致命的现实问题:只要有一个**客户端长期不上线(比如一个用户三个月没打开过文档),它的版本向量就永远停在三个月前——而 GC 点会被它拖住,墓碑一个都回收不了。

这就是为什么实践中的做法是"用房间生命周期回避 GC":

做法 说明
房间归档时全量重建 文档停止编辑后,把状态物化成纯文本,丢掉全部 CRDT 元数据
定期"重新开一个房间" 类似日志轮转,新房间从当前内容开始
强制清理长期离线副本 超过阈值不上线的副本被"踢出",它的版本向量不再参与 GC 判定

第三种做法有代价:那个离线副本一旦回来,它本地的离线操作引用的字符可能已经被回收了。 处理方式是整个房间的状态全量同步给它(丢掉它本地的增量)——用户会看到"我的离线修改全没了",但这比数据不一致要好。

CRDT 的代价不在合并算法,在元数据的存活期。 每一个"让合并变得简单"的设计,都对应一份"必须一直保留、无法回收"的元数据。这是这个方案真正的账,而且它在所有宣传 CRDT 的文章里都很少被算清楚。

结论

把 CRDT、日志、快照拼成一个服务之后,能看清这套设计的形状:

              ┌─ 定序:服务端分配 room_seq,日志用它做物理顺序
服务端做的四件事 ├─ 持久化:日志是真相,快照是加速
              ├─ 分发:扇出(中心节点最擅长的事)
              └─ 权限:拒绝某些操作进入日志
 
              ┌─ 位置用标识符,不用下标(并发下才有意义)
操作必须携带的  ├─ dot:客户端生成,用于去重和因果
三层身份       └─ room_seq:服务端生成,用于日志和补发
 
              ┌─ 版本向量(因果),不是水位(物理)
快照的边界     └─ 必须能回答"我不包含什么"
 
              ┌─ 单独通道(易失,不持久化)
awareness     └─ 心跳超时自动消失

四条最值得记住的判断:

  1. dot 和 room_seq 不能合并。 一个在客户端生成(离线时也要有),一个在服务端生成(决定日志顺序)。
  2. 快照的边界要用版本向量表达,不能用日志序号。 "读到哪"不等于"处理完了哪"。
  3. 断线离线操作必须能进"待定区"。 丢弃因果未满足的操作 = 永久丢失用户的编辑。
  4. awareness 不进日志。 判据是"断线后该不该消失"。

这四条里没有一条是"CRDT 怎么合并"。 而这就是把算法变成系统之后,工作量真正转移的方向:从"数据结构的设计"转移到"身份的分配、边界的表达、和过期的判定"。

下一篇换到"时间的边界"这个更抽象的问题(流处理),那里甚至"什么时候能出结果"本身都需要被显式设计。