Linux C++ 实战：基于 gRPC 编写同步 Server 与 Client

三、同步客户端实现

客户端通过 Channel 连接服务端，创建 Stub 来发起调用。注意不同 RPC 模式下的读写逻辑差异。

/*
 * 同步客户端
 */
#include <grpcpp/grpcpp.h>
#include "./build/example.grpc.pb.h"
#include <vector>

using grpc::Channel;
using grpc::ClientContext;
using grpc::ClientReader;
using grpc::ClientWriter;
using grpc::ClientReaderWriter;
using grpc::Status;
using example::ExampleService;
using example::Request;
using example::Response;

class ExampleClient {
public:
    ExampleClient(std::shared_ptr<Channel> channel)
        : stub_(ExampleService::NewStub(channel)) {}

    // 1. 一元 RPC
    void CallUnary(const std::string& msg) {
        Request req;
        req.set_data(msg);
        Response res;
        ClientContext ctx;
        Status status = stub_->UnaryCall(&ctx, req, &res);
        if (status.ok()) std::cout << "Unary: " << res.data() << std::endl;
    }

    // 2. 服务端流式 RPC
    void CallServerStream(const std::string& msg) {
        Request req;
        req.set_data(msg);
        ClientContext ctx;
        std::unique_ptr<ClientReader<Response>> reader = stub_->ServerStream(&ctx, req);
        Response res;
        while (reader->Read(&res)) { // Read() 阻塞等待响应，收到数据时返回 true，收到结束标记时返回 false
            std::cout << "Server Stream: " << res.data() << std::endl;
        }
    }

    // 3. 客户端流式 RPC
    void CallClientStream(const std::vector<std::string>& msgs) {
        ClientContext ctx;
        Response res;
        std::unique_ptr<ClientWriter<Request>> writer = stub_->ClientStream(&ctx, &res);
        for (const auto& msg : msgs) {
            Request req;
            req.set_data(msg);
            writer->Write(req); // 发送数据给服务端
        }
        writer->WritesDone(); // 发送结束标记，告诉服务端'发完了'
        Status status = writer->Finish(); // 阻塞等待服务端的响应
        if (status.ok()) std::cout << "Client Stream: " << res.data() << std::endl;
    }

    // 4. 双向流式 RPC
    void CallBidiStream(const std::vector<std::string>& msgs) {
        ClientContext ctx;
        std::unique_ptr<ClientReaderWriter<Request, Response>> stream = stub_->BidiStream(&ctx);
        // 写请求
        for (const auto& msg : msgs) {
            Request req;
            req.set_data(msg);
            stream->Write(req);
        }
        stream->WritesDone(); // 读响应
        Response res;
        while (stream->Read(&res)) {
            std::cout << "Bidi Stream: " << res.data() << std::endl;
        }
    }

private:
    std::unique_ptr<ExampleService::Stub> stub_;
};

int main() {
    ExampleClient client(grpc::CreateChannel("localhost:50051", grpc::InsecureChannelCredentials()));
    client.CallUnary("Hello");
    client.CallServerStream("Hi");
    client.CallClientStream({"A", "B", "C"});
    client.CallBidiStream({"X", "Y", "Z"});
    return 0;
}

四、消息发送与接收时机

同步 API 的最大特点是阻塞。理解何时发送、何时接收，对于调试和性能调优至关重要。

1. 一元 RPC (Unary)

• 客户端发送：调用 stub_->UnaryCall() 时，Request 被序列化并立即发送，随后线程阻塞等待响应。
• 服务端发送：执行 return Status::OK 时，之前设置的 Response 随状态码一起发送给客户端。

2. 服务端流式 RPC (Server Streaming)

• 客户端发送：调用 stub_->ServerStream() 时，Request 立即发送，函数返回 ClientReader 用于后续读取。
• 服务端发送：每次调用 writer->Write() 时，数据立即推送给客户端；循环结束后返回 Status::OK 表示流结束。

3. 客户端流式 RPC (Client Streaming)

• 客户端发送：每次 writer->Write() 发送一条数据；调用 WritesDone() 通知服务端不再发送；最后 Finish() 阻塞等待最终响应。
• 服务端发送：所有请求读取完毕后，设置 Response 并返回 Status::OK。

4. 双向流式 RPC (Bidirectional Streaming)

• 客户端发送：循环 Write 发送请求，WritesDone() 标记结束。
• 服务端发送：循环 Write 实时回显响应。

总结对比

掌握这些时序细节，能帮助你更准确地排查 gRPC 同步调用中的死锁或超时问题。