异步RPC调用消息缓冲区阻塞：如何逐个执行并等待回调？

为什么你的当前方案失效 #

你的代码里sendmultipleasync的do-while(wait)是忙等阻塞循环，会完全占用当前线程的执行资源。而异步RPC的回调函数success()通常需要在同一个线程的事件循环（或消息队列）中处理——线程被死循环卡死，事件循环根本没机会运行，wait永远不会被设为false，导致循环无限卡住。

解决方案 #

方案1：基于回调的链式执行（无多线程） #

放弃循环等待，改用回调触发下一次调用，让前一个RPC的回调完成后再发起下一个，自然实现逐个执行：

#include <vector>

// 保存待发送的节点列表与当前执行索引
std::vector<Peer> pending_peers;
size_t current_idx = 0;

void success() {
    // 前一个RPC执行完成，推进到下一个节点
    current_idx++;
    if (current_idx < pending_peers.size()) {
        send_to_single_peer(pending_peers[current_idx]);
    } else {
        // 所有任务完成，清理状态
        pending_peers.clear();
        current_idx = 0;
    }
}

void send_to_single_peer(const Peer& peer) {
    // 发起异步RPC，指定success为完成回调
    rpc_sendcustommsg(peer, success);
}

void sendmultipleasync(const std::vector<Peer>& peers) {
    pending_peers = peers;
    current_idx = 0;
    if (!pending_peers.empty()) {
        send_to_single_peer(pending_peers[0]);
    }
}

方案2：改用同步RPC调用（最简单） #

如果你的RPC库支持同步调用（发起后阻塞直到返回结果），直接在循环里逐个执行即可，逻辑最简单：

void send_to_single_peer_sync(const Peer& peer) {
    // 同步RPC调用，直到返回结果
    rpc_sendcustommsg_sync(peer);
}

void sendmultiple_sync(const std::vector<Peer>& peers) {
    for (const auto& peer : peers) {
        send_to_single_peer_sync(peer);
    }
}

缺点是当前线程会被阻塞直到所有调用完成，适合对主线程无阻塞要求的场景。

方案3：用单线程异步执行（不阻塞主线程） #

如果不想阻塞主线程，可以把同步调用的逻辑放到单独的子线程中，让子线程逐个执行RPC：

#include <thread>
#include <vector>

void send_in_background(const std::vector<Peer>& peers) {
    std::thread worker([peers]() {
        for (const auto& peer : peers) {
            send_to_single_peer_sync(peer);
        }
    });
    // 根据需求选择detach（线程后台运行）或join（主线程等待完成）
    worker.detach();
}

这样主线程可以继续处理其他任务，RPC调用在后台逐个执行，不会导致缓冲区阻塞。

内容的提问来源于stack exchange，提问作者Aditya Sharma