用 Rust 从零搭一个协同编辑服务:CRDT 管收敛,日志管顺序
讲 CRDT 的那篇回答了一个很漂亮的问题:怎么设计数据结构,让合并结果和顺序无关。
但那篇只回答了"数据怎么合并"。一个协同编辑服务还要回答另外四个问题:
- 新加入的人怎么拿到"当前状态"(没法把一年的操作全重放一遍)
- 操作日志无限增长怎么办
- 谁来决定"持久化的顺序"——如果顺序无关,那日志里凭什么有顺序?
- 一个一万人的文档,怎么分片和扩展
这四个问题的答案都不在 CRDT 里。 这篇就是讲它们。
第一步:先选状态型还是操作型——这道分岔决定后面所有设计
CRDT 有两大流派,它们的服务端设计完全不同:
| 状态型(CvRDT) | 操作型(CmRDT) | |
|---|---|---|
| 传输内容 | 整个状态(或状态差量) | 单个操作 |
| 合并方式 | 求并集(join),天然幂等 | 应用操作,要求不丢不重、因果有序 |
| 传输量 | 大(状态大小) | 小(操作大小) |
| 依赖的传输层 | 最终一致即可(甚至可以靠 gossipsub) | 必须有一个可靠广播层 |
| 典型场景 | 计数器、集合、配置 | 文本编辑、图形编辑 |
协同编辑几乎必然选操作型,原因有两个:
原因一:状态太大。 一篇十万字的文档,状态型就意味着每有一个人改动一个字,就要把十万字的状态传给别人——虽然可以做差量,但差量本身的计算又是一套复杂机制。
原因二:操作日志有独立价值。 有了操作流,你免费获得:审计(谁改了哪一段)、回放(把文档恢复到某个时刻)、离线编辑(客户端攒一堆操作,联网后一起发)。
但操作型有一个必须自己承担的义务:可靠广播。
操作型 CRDT 的前提:
✓ 不丢 —— 每个操作都要送达所有副本
✓ 不重 —— 或者让应用操作是幂等的
✓ 因果有序 —— 先"插入字符"再"删除它",顺序不能反这正是"日志"的用武之地。 换句话说:操作型 CRDT 把"合并的复杂度"换成了"传输层的复杂度",而传输层恰好是可以用日志 + 序号解决的问题。
没有一个 CRDT 是"不需要基础设施"的。 状态型把复杂度放在"状态大小和合并频率"上,操作型放在"可靠投递"上。选择哪一种,取决于你更擅长解决哪个问题——而服务端的日志和序号,恰好是工程上最成熟的那一块。
第二步:架构全景——服务端不是状态的权威
这是理解整个系统最重要的一张图:
客户端 A 服务端 客户端 B
──────── ────── ────────
本地 CRDT ① 收到 op
│ ② 立即本地应用 │
│ (不等确认) ↓
└─── op ───────────→ ③ 分配 room_seq(单调)
│
↓
④ 写操作日志(WAL / LSM)
│
↓
⑤ 广播 ──────────────────→ 应用 op
│
⑥ 定期压缩成快照
↑
新客户端 ── 快照 + 增量 ──┘关键点:服务端不做"合并"这件事。
它只是:
- 给每个操作贴一个全局单调序号
- 把操作持久化
- 把操作广播给房间里的其他人
- 定期把日志压缩成快照,给新人用
状态本身是由每个客户端各自算出来的。 服务端甚至可以完全没有文档状态——它只需要日志和快照。
这个设计的直接好处是:服务端是无状态的(除了日志),可以随便重启、随便扩容。 代价是**"正确性"依赖于"所有客户端对同一串操作算出同样的状态"——而这正是 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 └─ 心跳超时自动消失四条最值得记住的判断:
dot和room_seq不能合并。 一个在客户端生成(离线时也要有),一个在服务端生成(决定日志顺序)。- 快照的边界要用版本向量表达,不能用日志序号。 "读到哪"不等于"处理完了哪"。
- 断线离线操作必须能进"待定区"。 丢弃因果未满足的操作 = 永久丢失用户的编辑。
- awareness 不进日志。 判据是"断线后该不该消失"。
这四条里没有一条是"CRDT 怎么合并"。 而这就是把算法变成系统之后,工作量真正转移的方向:从"数据结构的设计"转移到"身份的分配、边界的表达、和过期的判定"。
下一篇换到"时间的边界"这个更抽象的问题(流处理),那里甚至"什么时候能出结果"本身都需要被显式设计。