非阻塞的思路：处理客户端的请求，处理完新建一个实例处理新的客户端请求。

服务端的函数关系调用链条是这样的：

Run() -> HandleRpcs() -> CallData() -> Proceed() ->

( ... -> Proceed() -> CallData() -> ... ) 构造函数

while(true){ ... } 队列死循环 -> Proceed()

简单做个小测试，便可以发现，异步处理请求的思路是通过构造函数和队列来做的。




grpc需要异步吗_grpc需要异步吗


未完待续 ...

// greeter_async_server.cc
#include <memory>
#include <iostream>
#include <string>
#include <thread>

#include <grpcpp/grpcpp.h>
#include <grpc/support/log.h>

#include "helloworld.grpc.pb.h"

using grpc::Server;
using grpc::ServerAsyncResponseWriter;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::ServerCompletionQueue;
using grpc::Status;
using helloworld::HelloRequest;
using helloworld::HelloReply;
using helloworld::Greeter;

class ServerImpl final {
 public:
  ~ServerImpl() {
    server_->Shutdown();
    // 始终在服务之后关闭完成队列。
    cq_->Shutdown();
  }

  // 此代码中没有关闭处理。
  void Run() {
    std::string server_address("0.0.0.0:50051");

    ServerBuilder builder;
    // 在没有任何认证机制的情况下监听给定地址。
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    // 注册 service_ 作为我们与客户沟通的实例。 在这种情况下，它对应于异步服务。
    builder.RegisterService(&service_);
    // 获取用于与gRPC运行时进行异步通信的完成队列。
    cq_ = builder.AddCompletionQueue();
    // 最后组装服务器。
    server_ = builder.BuildAndStart();
    std::cout << "Server listening on " << server_address << std::endl;

    // 继续进入服务器的主循环。
    HandleRpcs();
  }

 private:
  // 包含提供请求所需的状态和逻辑的类。
  class CallData {
   public:
    // 接受“service”实例（在本例中表示异步服务器）
    // 和用于与gRPC运行时进行异步通信的完成队列“cq”。
    CallData(Greeter::AsyncService* service, ServerCompletionQueue* cq)
        : service_(service), cq_(cq), responder_(&ctx_), status_(CREATE) {
      // 立即调用服务逻辑。
      Proceed();
    }

    void Proceed() {
      if (status_ == CREATE) {
        // 使此实例进入PROCESS状态。
        status_ = PROCESS;

        /* 作为初始CREATE状态的一部分，我们*request*系统开始处理SayHello请求。
           在此请求中，“this”行为是唯一标识请求的标记
          （以便不同的CallData实例可以同时为不同的请求提供服务），
           在这种情况下是此CallData实例的内存地址。
        */
        service_->RequestSayHello(&ctx_, &request_, &responder_, cq_, cq_,this);
      } else if (status_ == PROCESS) {
        /*在我们处理此CallData的一个客户端时，生成一个新的CallData实例来为新客户端提供服务。
          该实例将释放自己作为其FINISH状态的一部分。
        */
        new CallData(service_, cq_);
        // 实际处理。
        std::string prefix("Hello ");
        reply_.set_message(prefix + request_.name());

        /* 我们完成了！ 让gRPC运行时知道我们已经完成了，
           使用此实例的内存地址作为事件的唯一标识标记。
        */
        status_ = FINISH;
        responder_.Finish(reply_, Status::OK, this);
      } else {
        GPR_ASSERT(status_ == FINISH);
        // 一旦进入FINISH状态，就自行解除分配（CallData）。
        delete this;
      }
    }

   private:
    // 与异步服务器的gRPC运行时通信的方法。
    Greeter::AsyncService* service_;
    // 用于异步服务器通知的生产者 - 消费者队列。
    ServerCompletionQueue* cq_;
    // rpc的上下文，允许调整它的各个方面，如使用压缩，身份验证，以及将元数据发送回客户端。
    ServerContext ctx_;

    // 我们从客户那里获得了什么。
    HelloRequest request_;
    // 我们寄回给客户的是什么。
    HelloReply reply_;

    // 回到客户端的方法。
    ServerAsyncResponseWriter<HelloReply> responder_; 

    // 让我们实现一个具有以下状态的小型状态机。
    enum CallStatus { CREATE, PROCESS, FINISH };
     // 当前的服务状态。
    CallStatus status_; 
  };

  // 如果需要，可以在多个线程中运行。
  void HandleRpcs() {
    // 生成一个新的CallData实例来为新客户端提供服务。
    new CallData(&service_, cq_.get());
    void* tag;  //唯一标识请求。
    bool ok;
    while (true) {
      /* 阻止等待从完成队列中读取下一个事件。 
         事件由其标记唯一标识，标记是CallData实例的内存地址。 
         应始终检查Next的返回值。 
         此返回值告诉我们是否存在任何类型的事件或cq_正在关闭。
      */
      GPR_ASSERT(cq_->Next(&tag, &ok));
      GPR_ASSERT(ok);
      static_cast<CallData*>(tag)->Proceed();
    }
  }

  std::unique_ptr<ServerCompletionQueue> cq_;
  Greeter::AsyncService service_;
  std::unique_ptr<Server> server_;
};

int main(int argc, char** argv) {
  ServerImpl server;
  server.Run();

  return 0;
}