跳到主要内容
约 8 分钟2 张卡

消息传递

消息传递是一种并发设计:一组状态只由一个线程持有和修改,其他线程想改它,就发一条命令过去,由持有者按顺序执行。它和「多个线程直接访问同一个对象、靠锁协调」是两种思路。前者把同步问题换成了交接问题:不用在每条读写路径上加锁,但要想清楚消息里的对象归谁、结果怎么返回、队列满了怎么办、服务关闭时剩下的命令怎么处理。

1. 面试核心​

先记住这几条,再读正文
  • 单一所有者独占状态的修改权,其他线程通过不可变消息提交操作,由所有者串行执行。卡 · 共享对象的同步范围
  • 发送者在入队后继续修改消息中的可变对象,会与消费者产生数据竞争。
  • 有界队列限制待处理消息的数量,队列满时必须等待、拒绝或降级,把消费者处理不过来的情况反馈给发送者。
  • 消息携带的 CompletableFuture 把成功结果或异常交回调用方,处理失败也要完成对应的 Future,否则调用方会一直等。
  • 用毒丸结束 FIFO 队列的消费时,要先停止所有生产者,再把终止消息排在已接受的消息之后。卡 · 消费者异常与关闭协议

2. 共享对象的同步范围​

多个线程直接访问同一个业务对象时,所有访问路径都要遵守同一套同步规则。比如下面的订单簿,取消订单会修改内部的 HashMap:

public final class OrderBook {
private final Map<Long, Order> orders = new HashMap<>();

public void cancel(long id) {
orders.remove(id);
}
}

多个线程直接调用 cancel 时,需要用同一把锁保护 orders。如果还有创建订单、汇总查询,这些读写路径也要用这把锁。锁要保护的不只是 map 本身,还有 map 和订单状态之间必须始终成立的关系,这种关系叫不变量,比如「map 里的订单都处于未取消状态」。调用路径越多,越容易漏掉某一条。

另一种做法是让一个消费者线程独占整个 OrderBook,其他线程只发命令。这个消费者就是状态的单一所有者:

BlockingQueue<Command> mailbox = new LinkedBlockingQueue<>(1_000);

void eventLoop() throws InterruptedException {
while (!Thread.currentThread().isInterrupted()) {
Command command = mailbox.take();
command.apply(orderBook);
}
}

mailbox 是容量为 1000 的 FIFO(先进先出)队列。消费者每次取出一条命令,执行完再取下一条,所以状态修改按出队顺序一条一条进行。

只要 orderBook 和它内部的可变对象只由这个消费者访问,OrderBook 的方法就不用为多个调用者加锁,其他线程的查询和修改都通过消息完成。这个循环只展示了正常消费,命令失败和关闭的处理放在第 7 节。

3. 消息与状态所有权​

消息应该带齐一次状态转换需要的信息,并尽量用不可变值。比如取消订单只需要传订单 ID,由所有者去查自己管理的订单:

record CancelOrder(long orderId) implements Command {
public void apply(OrderBook book) {
book.cancel(orderId);
}
}

record 的字段在构造后就固定了,orderId 又是基本类型值,发送者和消费者之间没有可以共同修改的东西。业务需要取消原因的话,再加一个 String 字段也一样安全,因为 String 不可变。

麻烦出在集合这类可变数据上。record 只固定字段的值,如果字段指向一个 ArrayList,发送者入队后继续增删这个列表,就会和正在读它的消费者竞争。传递可变数据时,有三种明确所有权的方式:

  • 传不可变对象,发送者和消费者都只能读。
  • 复制一份快照,发送者之后的修改不影响消费者手里的副本。副本里的元素如果可变,也要复制或限制访问。
  • 只传标识符,由所有者去查自己管理的数据。

可见性方面,Java 并发工具包(JUC)的队列保证:一个线程在放入元素之前的写入,对另一个线程取出这个元素之后的操作可见。这个保证只覆盖入队之前的写入,入队之后发送者再改什么,消费者不一定看得到,所以仍然要靠上面的所有权约定。

4. 结果通道​

调用方发出命令后,还需要知道操作是否成功、拿到返回值。做法是让消息带上一个 CompletableFuture,消费者处理完时写入结果:

record CreateOrder(Order order, CompletableFuture<Long> reply) {}

结果通道就是这里的 reply,它把处理结果交回调用方。创建成功时,所有者调用 reply.complete(id);失败时调用 reply.completeExceptionally(error)。Order 如果是可变对象,也要按上一节的方式交接。

调用方等待结果时要设截止时间,并处理异常。否则消费者一旦卡住或退出,排队请求对应的调用线程都会一直等下去,故障就从消费者扩散到了调用方。

等 Future 超时并不代表命令没执行:命令已经在队列里,之后仍可能被处理。所以调用方超时后,应该用订单号这类稳定的业务标识去查询结果,重试时也要避免重复创建同一个订单。

5. 有界队列与过载​

消息传递没有消除处理能力的上限。消费者每秒处理 1000 条,生产者持续每秒提交 2000 条,队列每秒就多积压 1000 条,无界队列最终会耗尽内存,排在后面的请求也会等得越来越久。有界队列用固定容量限制积压,容量用完时,让提交方决定怎么办。

BlockingQueue 提供三种提交方式,区别在队列满时的行为:

  • put 一直等到队列腾出空间,适合允许生产者等待的流程。
  • offer 立即返回,队列已满时返回 false,调用方可以直接拒绝请求。
  • 带超时的 offer 最多等待给定时间,把排队时间纳入请求的时间预算。

队列满之后具体怎么处理,要看消息的业务含义:

  • 订单命令要明确返回拒绝或超时,让调用方知道提交失败。
  • 重复的统计消息可以按业务规则合并,减少待处理数量。
  • 刷新通知可以只保留最新一次,旧的已经被新的取代,丢掉没有损失。

运行时还要监控队列积压和处理延迟,及早发现消费者长期跟不上生产者。

6. 共享状态的适用场景​

消息传递适合把一组需要连续修改的状态交给同一个线程,代价是排队延迟和异步的错误处理。单个所有者的处理能力有限,所有请求都集中到它身上,它自己就成了热点。下面三类简单场景,直接共享状态更合适:

  • 只维护几个独立计数器时,用原子类更清楚。
  • 读多写少、允许读到某一时刻的配置时,发布不可变快照,读者直接读。
  • 临界区短、竞争低,而且调用方需要同步拿到结果时,用普通锁。

需要提高消息处理能力时,可以按互不影响的 key 分片,每个分片由一个消费者负责。同一个 key 必须稳定地路由到同一个所有者,才能保持对它的串行修改。热点 key 仍然会让某个分片积压,所以还要观察各分片的负载。

跨分片的一致性或事务需要额外协调,分片本身解决不了。选择设计时,要明确状态归谁、吞吐目标是多少、失败后怎么处理,以及怎样观察积压和延迟。

7. 消费者异常与关闭协议​

消费者出错或服务关闭时,已经接受的命令仍然要有结果。BlockingQueue 没有统一的关闭方法,停止接收和处理剩余消息的规则都要业务自己约定。

毒丸是一种特殊的终止消息,消费者读到它就退出。FIFO 队列可以按下面的顺序有序关闭:

  1. 停止接收新命令,并协调所有生产者结束提交。
  2. 把毒丸放到已接受的消息之后,消费者先处理完剩余命令,才会读到它。
  3. 等待消费者退出。有多个消费者时,要放入足够多的毒丸,每个消费者各读到一个。

第 1 步不能省:如果毒丸入队后还有生产者提交命令,这些命令会排在毒丸后面,消费者退出后就没人处理,调用方的 Future 也永远不会完成。

单条命令抛出异常时,先给它完成异常回复,再判断状态还能不能继续用。状态仍然一致,可以继续消费下一条;命令只做了一半修改、状态已经不一致时,应该停止消费并恢复状态。

需要立即取消消费时,中断可以让阻塞在 take() 上的消费者退出等待;正在执行的命令要自己检查中断才能停下。消费者退出后,队列里还没处理的消息要拒绝,或者交给其他消费者接管,并完成各自的结果通道。

8. 常见问题​

8.1 使用队列以后还会有竞态吗?​

会。只要交接之后还有多个线程修改同一个对象,就存在竞争。比如发送者继续增删消息里的列表,消费者就会读到变化中的内容;多个消费者直接修改同一份业务状态,也一样需要同步。所以所有权约定要覆盖消息本身,以及它引用到的所有可变对象。

8.2 FIFO 队列能保证业务操作按顺序完成吗?​

9. 面试题卡片​

先想答案,再翻面先在心里答一遍,再点开卡片对照参考回答。卡片之间可以左右切换,看完会回到这里。
逐张翻看 2 张 →
未标记的卡读完后明天进入复习;已标记的按状态安排

10. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明