Appearance
手机和电脑离线改了同一篇笔记,谁该覆盖谁?
周一早上,你在手机上给购物笔记补了一行“买咖啡豆”。电脑也有这篇笔记,只是还没连上网;同一时间,你在电脑上把“周五去超市”改成了“周六去超市”。晚上两台设备终于同步,服务器收到了两个版本。它该留哪份?
如果按到达顺序,后上传的会盖掉先上传的。手机上新加的咖啡豆,可能就这样没了。如果按设备时间,问题也没有消失:两台设备的时钟未必一致,网络延迟与离线时间更不是“谁先编辑”的可靠证据。即便时钟完全准,这两次编辑也可能是真正并行发生的;时间较晚,不代表编辑者看过较早那次修改。
我们需要回答的是另一个问题:第二次修改做出时,是否已经看到了第一次修改? 如果看到了,它是前一版本的后代;如果两边都是从同一份旧笔记分别改出来的,就出现了分叉。向量时钟记录的正是这种因果关系。它不会替我们决定该保留哪句话,也不会把两段文字自动拼好。
两份笔记从哪里分开的
先给版本标一个很小的元数据。手机最初保存的版本记作 {手机: 1},它已经同步给电脑。之后两台设备都断网,各自从这份共同版本继续编辑:
| 版本 | 修改内容 | 版本向量 |
|---|---|---|
| 共同版本 | 原购物笔记 | {手机: 1} |
| 手机版本 | 加上“买咖啡豆” | {手机: 2} |
| 电脑版本 | 改成“周六去超市” | {手机: 1, 电脑: 1} |
手机编辑时把自己的计数从 1 加到 2。电脑保留从共同版本读到的 {手机: 1},再把自己的计数从 0 加到 1。这里的数字不是时间戳,也不是内容字数,只是这个参与者在已知历史之上产生新事件的次数。
判断先后时,把没有出现的参与者视为计数 0,再逐项比较。若 A 的每一项都小于或等于 B,且至少有一项严格小于,A 才能说是 B 的祖先。共同版本 {手机: 1} 小于手机版本,也小于电脑版本,所以它可以被两边的后代取代。但手机与电脑的版本互相都不小于对方:手机这边是 2 对 1,电脑这边是 0 对 1。它们不能按因果先后排成一条线。
这就是“并发”的含义。它不要求两个人在同一秒按下保存;哪怕电脑晚了几个小时,只要它编辑时仍只知道共同版本,两次修改就分属不同的历史分支。服务器可以把两个分支都留下,交给应用判断如何合并。它不能从向量里看出“周六”是否比“咖啡豆”更重要。
可以把两台设备的表故意调得很不准:手机显示 8:03,电脑显示 8:27。电脑界面上的时间更晚,仍不意味着它看过手机的修改。反过来,手机可能在 8:30 收到电脑的同步结果,再于 8:31 改一次;即便手机系统时间被调回 7:00,这次修改仍然是电脑版本的后代。因果顺序依赖“读过哪个版本再写”,不依赖屏幕上显示几点。业务若要按时间展示日志,可以另外记时间戳;不要拿它替代版本上下文。
为了避免凭直觉判断,我把上述步骤写成一个只用 Python 标准库的小程序。核心比较只有十几行:
python
def relation(left, right):
actors = left.keys() | right.keys()
left_le_right = all(left.get(a, 0) <= right.get(a, 0) for a in actors)
right_le_left = all(right.get(a, 0) <= left.get(a, 0) for a in actors)
if left_le_right and right_le_left:
return "same"
if left_le_right:
return "before"
if right_le_left:
return "after"
return "concurrent"把 {手机: 2} 和 {手机: 1, 电脑: 1} 代进去,结果是 concurrent。这里的 same 只表示两个向量相同,并不保证两份正文相同。这个区别到了多设备共用标识或重复请求时,会直接影响数据是否安全。
合并后的新版本为什么要记住两边
假设用户在同步界面上看见两份修改,手工合并出一篇既保留咖啡豆、又写着周六去超市的笔记。新内容不能只沿用手机的 {手机: 2},否则下次电脑拿自己的 {手机: 1, 电脑: 1} 再来,服务器仍会认为它们是两个分支。合并时先逐项取最大值,得到 {手机: 2, 电脑: 1};手机在这个合并结果上完成一次新编辑,变成 {手机: 3, 电脑: 1}。
这时新版本的每一项都不小于原来的两个分支。程序分别比较,会得到“手机旧版本在新版本之前”和“电脑旧版本在新版本之前”。这才表示两边的历史都被新的结果接纳了。向量的合并与正文的合并是两道工序:前者告诉系统新版本见过哪些旧版本,后者决定最终显示什么内容。只做前者,仍可能把正文合并错;只做后者而丢掉版本上下文,下次同步又会生出旧冲突。
这里特别容易犯一个错:用户合并了两段正文,服务端却把新内容写在它最先读到的手机分支上,版本仍是 {手机: 3}。电脑的 {手机: 1, 电脑: 1} 并没有被这个向量覆盖。下一次同步时,服务器只能再次报冲突。用户会觉得“我刚才不是已经合并了吗”,而系统里确实没有记录“我合并时也看过电脑那份”。这就是合并操作必须带上全部被接纳分支的上下文的原因。
这里也有一个容易混淆的词:并发不等于“必须让用户手工选一次”。如果产品的数据结构允许按字段合并,或某些操作本来就能交换顺序,应用可以自动处理。购物笔记是自由文本,两个人都改同一句时,系统通常不知道用户本意。此时保留两个版本、展示差异,比悄悄选一个更诚实。选择最后写入覆盖也可以是明确的产品策略,但要承认它会丢掉某些并发修改。
版本跟着正文走,丢了就会误判
再把实验改坏一次。电脑明明读过共同版本 {手机: 1},上传时却只传正文,忘了附带这个版本上下文。服务器若从空向量开始给它记成 {电脑: 1},再拿共同版本 {手机: 1} 比较,会得到“并发”。现实中,电脑这次修改明明是在共同版本之后。问题不在比较算法,而在调用者没有把自己见过的历史带回来。
这类误判通常不会立刻丢数据,却会产生本可避免的冲突。若同一篇笔记反复读、改、写,每次都缺上下文,服务器就可能积累越来越多的分叉版本。真正的同步协议需要把正文与因果上下文作为一组信息处理;服务端也要核对这组上下文是否属于这篇笔记,不能把另一篇文档的版本向量借来用。
从接口设计看,读取笔记不能只返回正文。它至少要一并返回能代表所见历史的上下文,例如版本向量或一个由服务端签发、能查回向量的不透明版本标识。客户端离线编辑时要把它与编辑内容放在同一条本地待同步记录里。上传时再把它带回服务端。若本地只缓存正文,事后从服务器取“当前版本号”补上,反而是在谎称这次离线编辑见过服务器后来的修改;系统可能因此错误地覆盖真正并发的版本。
这也解释了为什么“保存按钮按下时取当前最新版本”并不安全。对于联网状态下的在线编辑,那样做也许是合理的前置读取;对于已经在本地改了一小时的离线草稿,当前最新版本可能是别人半小时前改出的内容。草稿的因果上下文应固定在它开始编辑所依据的那个版本,直到用户明确处理了新冲突。
还有一个更隐蔽的前提:参与者标识必须能区分两个独立修改者。若手机和电脑误用了同一个标识,且都从 {手机: 1} 开始,各自加一次都会得到 {手机: 2}。向量比较会说两者“相同”,可是正文可能完全不同。实验特意把这两次写入算了一遍,确实得到 same。这不是向量时钟能自动修复的情况;参与者身份的分配、重装应用后的延续或重置,都得由同步系统设计。单纯把设备名字当键,不能保证在所有生命周期里不冲突。
删除一篇笔记,为什么还得留一份记录
现在把例子换一下。手机读到共同版本 {手机: 1} 后,决定删除这篇笔记。电脑离线保存着旧内容,过两天才重新联网。如果服务端所谓的“删除”只是把当前存储里的记录直接抹掉,电脑把旧副本同步上来时,服务器看见的可能只是一篇从没见过的笔记。用户明明删过,它却又回来了。
这不是向量比较失灵,而是比较所需的证据也被删掉了。一个做法是先保存删除标记,也叫墓碑:正文为空,但版本仍在。手机的删除版本是 {手机: 2}。电脑若只上传未经修改的旧版本 {手机: 1},比较结果是旧版本在删除版本之前,服务端就能拒绝旧内容重新出现。
我在实验里把“留下墓碑”和“过早清掉墓碑”分别跑了一次。旧副本与墓碑一起参与比较时,只留下删除版本;先清掉墓碑再接收旧副本,旧正文就成了唯一候选版本。输出如下:
text
old replica with tombstone: [None]
old replica after premature purge: ['old note']实际系统不能永远保留每个墓碑,也不能随便选一个固定天数就断言安全。能否清理,取决于系统是否知道旧副本都已追上、离线设备允许多久后回来、是否还有备份或延迟队列可能重放旧版本。若离线时限没有上界,想同时保证“删完就永远不会复活”和“墓碑很快清理”,就得另有同步协议或持久的删除历史来支撑。这里的小实验只展示因果比较的必要条件,不提供一套可直接用于生产的垃圾回收算法。
但电脑可能不是只带着旧内容回来。它也许在离线期间把笔记改了,版本变成 {手机: 1, 电脑: 1}。这时删除 {手机: 2} 与编辑互不包含,实验会保留两个候选:
text
delete vs concurrent edit: [None, 'new text']界面该显示“笔记已删除”,还是让用户看到“另一台设备在删除期间修改过它”?向量只能说这两件事没有因果先后,不能替用户做选择。若产品直接让删除覆盖编辑,得明白那会丢掉电脑上的新内容;若让编辑恢复笔记,得明白手机用户的删除意图被推翻了。更稳妥的产品交互可能是保留冲突副本,并明确提示用户决定。具体怎么做取决于这篇笔记的业务价值,而不是向量时钟的公式。
同一条修改重发两遍,计数要不要加两次
离线同步的请求不一定只来一次。手机发出“把周五改为周六”,服务端保存成功,响应却断了。手机不知道服务器有没有收到,重试同一个请求是合理的。问题在于:第二次到达是新的编辑事件,还是第一次事件的重复投递?
如果服务端每收一次请求就给手机计数加 1,同一笔修改会从 {手机: 1} 变成 {手机: 2},重试又变成 {手机: 3}。正文可能恰好一样,看起来没坏,但版本历史已经凭空多了一次事件。更麻烦的是,请求可能包含“在末尾添加一行”这类非幂等操作;重复执行会真的多出一行。向量时钟记录因果,不会识别两个 HTTP 请求是不是同一个业务操作。
示例程序给修改加了一个操作编号 edit-42。服务端第一次处理时记住“这个编号对应的旧版本、正文和处理结果”;再次收到完全相同的编号与输入,就返回之前的结果,不再增加计数。运行输出中,两次拿到的都是 {手机: 2},记录数仍为 1:
text
retry of one operation: {'phone': 2} {'phone': 2}
same operation ID, different body: rejected第二行特意试了“编号相同,正文却变了”。这种请求不能悄悄当作重试,也不能悄悄生成新版本,否则客户端与服务端对“同一次操作”的理解就不一致。演示代码用内存字典,重启后记录会消失,多台服务之间也不共享;真实服务至少要把操作编号与请求摘要、处理结果持久化,并处理并发写入。操作编号还得限定在用户和笔记范围内,不能让别人的编号影响这篇笔记。
这里有两套不同的去重依据:版本向量用来判断历史包含关系;操作编号用来识别请求重放。前者回答“这个版本见过哪个版本”,后者回答“这是不是刚才那一次提交”。把其中一个当成另一个用,都会留下漏洞。
冲突交给谁:存储层能判断,正文还得有人负责
回到最初那两份购物笔记。服务器知道它们并发,却不知道“咖啡豆”和“周六去超市”该如何组合。一个做法是把两个候选版本都留着,读的时候一起交给应用;应用展示差异,或根据业务规则合并,再写入一个同时继承两边上下文的新版本。Dynamo 论文把这种并行版本的协调交给调用方;Riak 文档把并存的值称为 siblings。它们都说明了同一件事:发现冲突,只是解决冲突的前半段。
留两个版本并不总是好事。若每次读取都不处理冲突,下一轮离线写入可能又添新的分支。笔记列表因此越来越难展示,存储层也会背上更多版本。反过来,简单地按时间戳挑一个“赢家”虽然让数据结构干净,却可能无声地丢掉另一台设备的修改。对于自由文本,我更倾向把两份内容作为待处理冲突交给用户;若字段有明确语义,例如一个只增不减的集合,可以考虑按字段设计自动合并。不能因为有向量时钟,就承诺任何文本都能自动合并。
还有一种常见误会:冲突一旦在某次读取中被展示,系统就能马上把两个版本压成一个。假设用户还没点确认,手机又离线改了一次,当前界面显示的两个候选已经不是最新集合。提交合并结果时,服务端仍需核对这份合并是基于哪些版本;若又出现新分支,要重新协调,不能把新写入盖掉。示例程序里 merge() 只是对计数逐项取最大值,正文仍得由应用给出;二者必须作为同一次有条件的写入处理。
设想同步界面只显示两份正文:手机的“周五去超市,买咖啡豆”和电脑的“周六去超市”。用户选择合并为“周六去超市,买咖啡豆”。如果系统只做两份文本的差异比较,可能还看不出“周五”改成“周六”与末尾新增咖啡豆分别来自哪一次编辑。把共同祖先“周五去超市”也取出来,做三方比较,才有机会识别两边改动的位置。这个例子可以自动合并,但若双方都把“周五”改成不同日期,就不能再装作它们不会冲突。三方合并负责正文,版本向量负责历史;两者要配合,不能互相替代。
真正落库时还有一个竞态:用户读到两个分支,开始手工合并;这期间另一台设备上传了第三个分支。若合并写入没有检查“我现在处理的还是读到的那批版本吗”,第三个分支可能被静默丢掉。服务端需要在同一次原子操作里比较当前分支集合、保存新正文和新上下文;不匹配就让用户重新查看冲突。示例程序没有数据库,也没有并发写入模拟,所以这里只能给出应检查的条件,不能声称它已验证了这种竞态。
为什么把设备计数放进向量,还不能照搬到生产
到这里,手机、电脑各占一个计数,很容易让人以为“多加一个 map 字段就能做同步”。前面共用标识的实验已经说明,参与者身份不能随便取。设备重装、账号在新设备登录、离线副本长期不再出现,都会影响标识分配和元数据清理。参与者越多,版本携带的计数也可能越长。试图把旧参与者从向量里剪掉,又可能丢掉原有的因果证据。
本文用设备当参与者,是为了把一次离线编辑讲清楚。Dynamo 论文里的向量项对应存储节点及其计数,读写还要携带上下文;它处理的是多副本键值存储,不是一款笔记应用。Riak 的实现又有自己的版本演进:官方文档建议 2.0 及以后使用 dotted version vectors,因为普通向量虽然能识别并发,却难以把每个并发值对应到一个独立更新事件;同一上下文下的多次并发写入可能形成大量重复 sibling。给事件附上单独的 dot 后,系统更容易识别重复值。
所以不能把本文的 Python 字典说成 Dynamo 或 Riak 的实现,也不能从这段程序推断它们的线上性能。它只是一个可以手算、可以跑断言的因果模型。真正的产品还要回答:谁产生参与者 ID,客户端拿到哪个版本上下文,服务端如何原子保存正文和元数据,重试如何去重,删除标记何时可清理,冲突在页面上怎么呈现。这些问题中,只有一部分由向量的偏序比较直接解决。
最后,手机和电脑上的修改都去哪了
这篇笔记最初只有 {手机: 1}。手机离线加咖啡豆,产生 {手机: 2};电脑从同一份旧版改日期,产生 {手机: 1, 电脑: 1}。服务端比较出并发,保留两份。用户看完差异,决定两处都保留,合并后的版本继承两边的历史,再进行一次新写入。之后,旧副本即使迟到,也能凭向量关系认出它在新版本之前。
若其中一次操作是删除,不能只抹掉正文;否则旧副本可能把笔记带回来。若客户端没收到响应而重试,不能只靠向量判断是不是重复业务操作;要另有稳定的操作编号。若设备没带回自己读到的版本上下文,服务器会把本来有先后的修改误判成并发。每一步都不复杂,漏掉其中一步却会让系统作出与用户意图相反的决定。
读者可以把上面的四组向量手算一遍,再下载完整示例,在本地运行 python3 offline_notes.py;本次运行的原始输出也一并留着供对照。程序只用 Python 标准库,断言的是模型里的因果关系、墓碑保留和重复请求去重,没有模拟真实的多副本网络与持久化存储。最重要的是别把 concurrent 读成“同一时刻”,也别把“能检测冲突”误读成“系统知道该保留哪句话”。