阶段六模拟考察
第六阶段加强,我们按真实强度来:每轮 1 道主问题,我会根据你的回答追问,指出概念混淆和设计漏洞,再让你补充。 问题会从架构逐渐深入到并发、事务和恢复机制。
第一题
问
第一题:用户 A 给在线用户 B 发送一条私聊消息,从 A 的 TCP 数据到达 ChatServer,到 B 收到推送,整个过程如何执行?
请结合当前实现讲清楚这条路径,重点解释:
- Session 解出消息后,如何通过 LogicRouter 选择业务资源?任务在哪个线程或 strand 执行?
- MySQL 保存成功后,响应怎样返回 A,推送怎样找到 B 的全部在线连接?
- 这条路径中的 Session 状态、数据库连接和在线索引分别由谁管理,怎样避免并发访问冲突?
你可以用“谁调用谁、数据传到哪里、状态发生什么变化”的方式回答。我会从你给出的执行顺序里继续追问。
答
首先,A和B肯定都已经完成了Token认证并且对应的Session都已经绑定了用户ID,可能A和B有多个在线连接,我们还要关注他们在Server里登记的在线索引。整个过程可以简化为这样一个流程:接收解帧->选择业务资源->事务保存->分别发送确认和远程推送。
- A的Session在自己的strand内接收消息、解帧并排队。我们自定义了ILV消息协议并用MessageProtocol类分割数据,调用try_pop提取完整ILV帧,半帧保留,多帧按解出顺序进入request_queue_,解出的消息结构体里面只有id和text。
- Session::dispatch()入队后检查processing_,当前无任务就取队首处理任务丢进LogicRouter池里处理,其中逻辑线程处理完后再次丢进该Session的strand,最后再调用dispatch,保证任务处理的连续性,不会同时挂起多条业务。
- Session通过LogicRouter轮询选择一组业务资源,接着把任务投递到这组任务的strand。其中Router通过原子计数fetch_add递增后对Context取模返回一组LogicContext资源,每组Context有自己的MySQL连接、TokenStore、Dispatcher等等。
- 这里有一个重点,因为我们使用的是多逻辑线程并发处理业务,他们可能会同时进入数据库修改,所以我们必须使用MySQL事务来保证业务的原子性,save_message创建WriteTransaction,其构造函数时便声明”START TRANSACTION”,按照用户ID锁定双方账号行,再执行消息INSERT,最后”COMMIT”,若失败便”ROLLBACK”。相关用户的写入由MySQL行锁跨连接协调。这和Context strand的作用不同:strand保护同一组连接串行使用,事务锁协调不同组、甚至不同ChatServer对同一业务数据的竞争。
- 保存成功后,返回A的确认和推送A其他连接和B的通知分成两条异步路径。Dispatcher返回一个DispatchResult,携带必须返回的确认和可选的PendingDelivery。发送给其他用户的消息组PendingDelivery先调用Server.deliver_message()投递给其他相关Session,而确认消息则再次投递进本Session strand。
- 我们用unordered_multimap保存了全部在线连接,用这个数据结构确保快速查询而且支持同一键可以对应多个值,Server在自己的strand里查B的全部在线连接,再交给各连接发送
若在线投递期间断线,消息仍保留在 MySQL,后续由收件补读或历史查询恢复。
追问:第 4 点里的设计动机
问
接下来追问你第 4 点里的设计动机:
保存一条消息只有一个 INSERT,MySQL 自己就能保证这条语句的原子性。我们为什么还要在分配消息 ID 前,按用户 ID 顺序锁住双方账号行?
请用下面这个场景回答:
- 两个独立数据库连接,同时给 B 保存消息。
- 事务 T1 先拿到消息 ID 100,但迟迟没有提交。
- 事务 T2 拿到消息 ID 101,先提交。
- B 此时补读收件消息,把游标推进到 101,随后 T1 才提交。
如果只用事务、不锁账号行,会出现什么问题?当前的账号行锁怎样阻止它,为什么又要按用户 ID 升序加锁?
答
这里加账号行锁,主要是为了保证补读游标不会跳过晚提交的小 ID 消息。事务保证一次写入的原子性,但自增 ID 的分配顺序不等于事务的提交顺序。
如果只开事务而不锁账号行,题目中的过程完全可能发生:
- T1 执行 INSERT,取得 ID 100,但还没有提交,普通收件查询看不到这条记录。
- T2 执行 INSERT,取得 ID 101,先提交。
- B 用 WHERE recipient_id = B AND id > 当前游标 ORDER BY id ASC 补读,看到了 101,把游标推进到 101。
- T1 随后提交,100 才变成可见记录,但 B 后续的补读条件已经是 id > 101,因此不会再读到 100。
这条消息没有丢出数据库,却被当前向前推进的收件游标永久跳过了。重新从 0 补读或查询历史仍可能找到它,但当前补读链已经发生遗漏。即使两次 INSERT 都放在事务里,这个问题也依然存在,因为两个独立事务之间没有建立所需的提交先后关系。
当前实现把双方账号行当成相关写入共同竞争的锁定对象,执行顺序是:开启事务 → 按顺序锁双方账号 → INSERT 分配消息 ID → COMMIT 释放锁。
假设 T1 已经锁住 B 的账号行并取得 ID 100,T2 也要给 B 保存消息,就必须先取得同一个 B 账号行的锁。T1 提交前,T2 会等待,尚不能执行 INSERT,因此也拿不到 101。等 T1 提交、100 已经可见后,T2 才能继续插入和提交。这样就阻止了“B 能查到已提交的 101,却查不到尚未提交的 100”这一组合。
这里不是让普通收件查询也去抢账号锁,而是在写入端约束分配 ID 和提交的顺序,让查询端可以安全地按 ID 推进游标。如果 T1 回滚,留下自增 ID 空洞也没有问题,因为那个 ID 对应的消息以后不会再提交出现。
之所以按用户 ID 升序加锁,是为了避免相反方向写入形成锁等待环。例如 A 给 B 发消息,同时 B 给 A 发消息,如果都按“先发送者、后接收者”加锁,就可能出现:
T1 持有 A 的锁,等待 B;
T2 持有 B 的锁,等待 A。
统一按较小用户 ID、较大用户 ID 的顺序获取锁,两条路径会先竞争同一把锁,另一条事务在第一步等待,不会各持一把再互相等待。这能避免这组账号行锁因获取顺序相反而形成的死锁,但不能据此宣称数据库里的所有死锁都被消除了。
严格说,只保护 B 的收件游标,锁接收者 B 就能协调这个场景;当前锁双方,是为了让涉及同一用户的消息与好友相关写入遵守统一的协调规则,并覆盖本人参与的双向消息读取。代价是涉及同一热点用户的写入会串行等待,没有共同用户的写入仍可并行。这个保证也以相关写入都遵守同一加锁协议为前提,绕过它直接 INSERT 就会破坏上述顺序。
下一题:持久化、网络响应和重试之间的关系
问
下一题考察持久化、网络响应和重试之间的关系。假设发生下面的过程:
A 发送消息,MySQL 已经提交成功;但 A 的连接随后断开,尚未收到 2022,也没有收到同步的 2023。B 可能已经收到推送。A 重新登录后,因为不确定是否发送成功,又发送了一次相同正文。
请结合当前设计回答:
- A 的 Session 停止后,已经提交的消息是否还应该继续投递给 B?代码怎样保证投递不依赖 A 仍在线?
- 当前再次发送会不会产生重复消息?为什么客户端按服务端消息 ID 去重解决不了这种重复?
- 如果要求“用户重试同一次发送,也只保存一条消息”,你会怎样修改请求字段、数据库约束和服务端处理流程?
答
- 继续投递。逻辑任务在数据库提交后,先把 PendingDelivery 交给 Server,再把响应投回 A 的 Session。A 停止时只丢弃自身响应,不取消给 B 的投递。
- 当前重发会重复保存。两次 INSERT 会得到不同消息 ID,客户端按服务端 ID 去重只能合并同一条记录的多次到达,无法识别这两条记录属于同一次发送。
- 增加发送幂等标识。客户端生成 client_message_id,同一次发送的重试始终复用它;数据库增加 (sender_id, client_message_id) 唯一约束。服务端首次请求保存并推送,重复请求校验接收方和正文一致后返回原消息 ID,不重复保存或触发新推送;内容不一致则报冲突。客户端需保存待确认请求,才能在重启后继续复用原标识。
追问:Session 已经用了 strand,为什么还需要 request_queue_ 和 processing_?
问
Session 已经用了 strand,为什么还需要 request_queue_ 和 processing_?如果把它们删除,每解出一帧就直接投递给 LogicRouter,会出现什么问题?
答
strand 保证 Session 的回调不同时执行,request_queue_ 和 processing_ 保证上一条异步业务完成并应用结果后,才提交下一条业务。两者解决的问题不同。
Session 把任务 post 到 LogicContext 后,当前回调就可以返回,strand 不会等待数据库业务完成。如果每解出一帧就直接投给 Router,相邻请求可能分到不同 Context 并行执行,从而出现:
身份状态错误:认证请求尚未完成,后一条发送请求就复制了尚未绑定的 user_id_,被当成未认证请求。
业务顺序改变:客户端先发送消息、再查询历史,查询可能先执行,读不到刚发送的消息;两次发送也可能按相反顺序保存。
响应乱序:结果返回 Session strand 时虽然逐个执行,但先完成的业务可能先返回,strand 不会替它恢复请求顺序。
当前做法是:完整帧先入队,processing_ 限制每个 Session 只有一条在途业务,结果回到 Session strand 并应用后,再处理下一条。同连接保持有序,不同连接仍可并行。
追问:为什么异步操作经常捕获 self = shared_from_this()
问
Session 提交异步操作时,为什么经常捕获 self = shared_from_this(),而不是直接捕获 this?如果 stop() 从 Server 的 sessions_ 中删除了这个 Session,它会立刻析构吗?
请结合“Server 持有的 shared_ptr”和“在途回调持有的 shared_ptr”解释即可。
答
因为异步操作发起后,Session 可能先停止,但完成回调还会稍后执行。只捕获 this 无法保证这段时间对象仍然存在。
如果回调只捕获 this,Server 删除 sessions_ 中最后一份 shared_ptr 后,Session 就会析构,内部接收缓冲区也被释放。即使 socket 关闭取消了读取,完成回调仍会执行,此时访问 this 就是访问已销毁的对象。哪怕回调只是检查 stopped_ 然后 return,读取这个成员本身也需要对象还活着。
所以当前由 Server 的 shared_ptr 管理连接登记期间的所有权,由在途回调捕获的 self 保证异步操作收尾期间的生命周期。Server 删除登记项后,只要还有回调持有 self,Session 就不会立即析构;最后一个回调释放所有权后才析构。stopped_ 则让这些回调只做收尾,不再继续收发。这是当前异步操作安全所必需的,不只是为以后优雅退出做准备。
追问:为什么 Session 要把编码后的消息放进 send_queue_?
问
为什么 Session 要把编码后的消息放进 send_queue_,等 async_write 完成后再弹出?下面这样写有什么问题?
void Session::send(...) {
auto frame = protocol::encode_frame(id, body);
boost::asio::async_write(
socket_,
boost::asio::buffer(frame),
[self = shared_from_this()](auto error, auto bytes) {
// 处理结果
});
}
这段代码已经用 self 保住了 Session,为什么仍然不安全?
答
这段代码虽然捕获了 self,但它只保证 Session 不被提前析构,并没有同时解决线程访问、发送内存生命周期和异步写入顺序的问题。具体有 3 点:
- 没有保证在 Session strand 内执行。如果多个线程直接调用 send(),就可能并发操作 socket 和发送状态;完成回调也没有绑定 strand,后续访问 Session 状态同样缺少串行保证。不过,如果 send() 的约定是只能在 strand 内调用,入口就不必重复 post,当前项目采用的就是这种方式。
- 局部 frame 提前销毁。asio::buffer() 不拥有内存,send() 返回后 frame 被释放;self 只保住 Session,保不住这个局部变量。
- 可能启动重叠写入。即使补上 strand,连续两个任务仍可能先后启动两次 async_write(),因为 strand 不会等待异步操作完成。还需要发送队列和 writing_,保证前一次完成后才启动下一次。
所以,strand 保证状态访问串行,发送队列保证写操作不重叠,在途帧的所有者保证发送内存有效,self 保证 Session 存活,这几项不能互相替代。
一道数据库基础题:好友申请同意时的事务
问
一道数据库基础题:
好友申请被同意时,为什么“修改申请状态”和“插入好友关系”必须放在同一个事务里?如果分成两次独立提交,中间第二步失败,会出现什么状态?
再补充一句即可:已经同意过的申请被重复点击“同意”,服务端应该返回成功还是报错,为什么?
答
会出现“通知显示已同意,但好友列表中没有对方”的不一致状态。同一个事务能保证第二步失败时,第一步也回滚,申请仍为 pending。
已经同意过的申请再次点击“同意”,应返回成功和原终态。 这是同一操作的幂等重试,不应重复插入好友关系或重复广播;当前实现用 changed = false 表示本次没有产生新的状态变化。
下一题:客户端缓存与服务端数据的关系
问
下一题看客户端缓存与服务端数据的关系:
客户端已经把消息保存到 SQLite,为什么还需要服务端的收件补读、双向历史和最近会话查询?
不用讲接口编号,分别说明它们解决什么问题,再回答:为什么不能直接拿 SQLite 中最大的消息 ID,作为收件补读的起始游标?
答
SQLite 只保存这台设备已经获取过的消息,不能代表服务端完整数据,所以仍需要 3 类查询:
- 收件补读:找回客户端离线期间或实时推送未收到的消息。
- 双向历史:按聊天对象查询双方记录,加载本地尚未缓存的更早消息。
- 最近会话:在新设备或缓存丢失时,找回聊过的人和最后一条消息,包括只发送过、没有收到回复的会话。
不能把 SQLite 最大消息 ID 当作收件补读游标,因为“缓存中见过的最大 ID”不等于“此前所有收件消息都已完整读取”。 缓存混合了发送确认、实时推送、历史和最近会话等来源,可能有空缺。例如本地已缓存发出的消息 200,但离线收到的消息 150 尚未获取;如果从 200 开始补读,150 就会被跳过。
收件游标必须独立维护,只能在一整页收件消息成功处理后推进。当前实现每次登录从 0 开始补读,再按消息 ID 与缓存合并去重。
下一题:服务端并发设计——为什么要 N 个 LogicContext?
问
下一题回到你这阶段的服务端并发设计:
既然已经有 N 个逻辑 worker,为什么还要创建 N 个 LogicContext,并让每组独占一条 MySQL 连接?能不能只保留一条连接,让所有 worker 共用,再用互斥锁保护?
请说明这种加锁方案是否可行、会怎样影响查询和写入的并行性,以及为什么锁的范围不能简单缩到“每次 SQL 调用”。
答
共用一条连接并加互斥锁是可行的,但会把数据库业务串行化;N 个 worker 并不意味着能够在同一条连接上同时执行 N 条 SQL。
当前创建 N 个 LogicContext,是为了让每组独占一条 MySQL 连接及对应业务资源。同组任务由自己的 strand 串行执行,不同组可以通过不同连接同时查询或写入;涉及相同数据时,再由 MySQL 行锁协调。Context 也不固定绑定某条 worker 线程,它代表一组受串行约束的资源。
如果所有 worker 共用一条连接,互斥锁可以避免并发操作连接,但一次慢查询或锁等待就会占住这条连接,其他查询和写入都只能等待,无法实现数据库操作的真正并行,等待互斥锁还会占用逻辑 worker。
锁的范围不能简单缩到每次 SQL 调用,因为事务状态属于数据库连接,不属于调用它的线程。 例如:
worker 1:START TRANSACTION
worker 1:修改申请状态v2
worker 2:插入一条消息
worker 1:COMMIT
即使每次 SQL 调用都加锁、没有同时执行,worker 2 的 INSERT 仍会进入 worker 1 在这条连接上开启的事务,随后被一起提交或回滚。另一个 worker 若执行 COMMIT,也可能提前提交别人的事务。
所以,共用连接时,锁至少必须覆盖完整事务,从开启到提交或回滚,期间禁止其他业务插入使用;普通非事务查询也要遵守同一把锁,这样的话数据库的操作基本就全部串行了,极大拖累性能。当前用多组独立连接,让每组事务拥有独立的连接状态,才使查询和写入能够真正并行。
下一题:LogicRouter 的调度取舍
问
下一题考察当前 LogicRouter 的调度取舍:
假设有 2 个逻辑 worker、2 个 LogicContext。Context 1 正执行一条等待数据库行锁的写入,Context 2 已处理完任务,目前空闲。此时用户 C 发来一条很快就能完成的查询,轮询恰好选中了 Context 1。
这条查询会怎样执行?空闲的 worker 能否直接把它拿去执行?为什么?
请结合 Context 的 strand、数据库连接归属和轮询规则回答,再说明:如果希望减少这种等待,你会优先怎样调整调度,又需要保留什么约束?
答
查询会排在 Context 1 的 strand 中,等前面的写入结束后再执行。空闲 worker 不能直接执行它,因为同一 strand 的任务不能并发,Context 1 的同步 MySQL 连接也不能被并发使用。Context 不固定绑定 worker,但任务选定 Context 后就使用该组资源。
要减少等待,优先把纯轮询改为选择空闲或未完成任务较少的 Context,同时保留每个 Context 内串行访问连接、同一 Session 上一条结果应用后才提交下一条的约束。
追问:Context 的“未完成任务数”如何维护?
问
继续追问你提出的调度改进:
如果给每个 Context 增加一个“未完成任务数”,供多个 Session 并发选择负载较小的 Context,这个计数应该怎样维护?
请沿一次请求的执行过程说明:什么时候加 1、什么时候减 1,是否需要原子操作。如果两个 Session 同时观察到 Context 2 最空闲,并同时选择了它,会不会破坏数据库连接的并发安全,还是只影响负载分配?
答
计数应覆盖“已选定并准备提交、已排队、正在执行”的业务任务;多个 Session 并发读写它时,需要原子操作或统一加锁。 沿一次请求的过程看:
- 选择 Context 后、投递任务前加 1,把这次选择计入负载,不能等 handler 开始执行才加,否则排队任务会被漏算。
- 任务进入该 Context 的 strand,随后由 worker 执行;排队和执行期间都保持这份计数。
- 业务 handler 结束时减 1,无需等结果回到 Session 并应用,因为这时已经不再占用 Context 的业务资源。正常返回和异常退出都应减数,可以用作用域清理保证;如果投递失败,也需要撤销之前的加 1。
如果采用原子计数,读取用 load(),增减用 fetch_add()、fetch_sub();计数仅用于估计负载,不负责发布业务数据,通常使用 memory_order_relaxed 即可。
两个 Session 同时读到 Context 2 最空闲,并各自加 1、投递过去,不会破坏数据库连接的并发安全,只可能让负载分配不够均衡。 因为两条任务仍经过 Context 2 的 strand,使用同一连接时仍串行执行。原子计数保证不会丢失增减,但不能让“扫描最小值 → 选择 → 加 1”整体成为原子操作;若要求严格协调选择,需要给这段过程加锁,而当前用于近似调度时,可以先接受这种短暂偏差。
追问:数据库顺序与推送顺序不一致时如何处理?
问
两个不同 Session 同时给 B 发消息,分别由不同 Context 处理:
- T1 保存消息 100 并提交成功,但逻辑线程在调用 Server::deliver_message() 前暂时被调度出去。
- T2 随后保存消息 101 并提交,先把推送投递到 Server strand。
- T1 恢复执行,再投递消息 100。
我们已经通过账号行锁保证相关消息的 ID 分配与提交顺序一致,为什么 B 仍可能先收到 101、再收到 100?Server strand 和 Session 发送队列能否自动恢复消息 ID 顺序?
请接着说明:当前 Qt 应怎样处理这种乱序,以及为什么收到实时推送 101 时,不能顺手把收件补读游标推进到 101。
答
账号行锁保证数据库中的 ID 分配与提交顺序,不保证提交后推送任务的投递顺序。 T1 提交 100 后已经释放锁,随后被暂停;T2 可以提交 101 并先调用 Server::deliver_message(),因此 Server strand 完全可能先处理 101,后处理 100。
Server strand 只保证其 handler 串行执行,不会按消息 ID 重新排序。Session 发送队列也只按入队顺序发送,因此若入队顺序是 101 → 100,网络发送顺序就是 101 → 100。TCP 保留这个发送顺序,也不会替应用恢复数据库顺序。
Qt 应把消息 ID 顺序与网络到达顺序分开处理。 当前的合并方式就是按消息 ID 用 lower_bound() 找位置:先收到 101 就插入,随后收到 100 再放到 101 前面;已有 ID 则去重。旧消息补入后不能覆盖 101 的会话摘要或让会话排序退后,也不能因为稍后补读再次取得同一条消息而重复增加未读数。
实时推送 101 只能证明这条消息已收到,不能证明 101 之前的所有收件消息都已收到。 如果立即把收件补读游标设为 101,后续查询 WHERE id > 101 就会跳过尚未收到的 100;一旦 100 的推送因断线丢失,本次补读便无法找回它。
因此,收件补读游标只能由按原游标查询、完整校验并成功合并的收件页面推进;实时推送只合并消息,不修改该游标。这样下一页仍能查到 100 和 101,客户端补入缺失的 100,并将已收到的 101 去重。