Brpc understanding

We only have three user classes ：Server、Channel and Controller, They correspond to each other server End ,client End and adjustment parameter set .

There is no need to deliberate, such as “Client How to initialize ”,“XXXManager What's the usage? ”,“Context and Controller What is the relationship of ” And so on

It's easy to do ：

Build service #include <baidu/rpc/server.h>, And use... According to notes or examples server object
Access to the service is #include <baidu/rpc/channel.h>, And use... According to notes or examples Channel object
Want to control once RPC Parameters to access , Just look at it. baidu/rpc/controller.h What's in it . Please note that , This class is Server and Channel Public , It is divided into three paragraphs , They are marked as Client-side,Server-sdie and Both-side methods
One 、Channel
Channel Can be shared by all threads , You don't need to create separate for each thread Channel, There is no need to lock mutual exclusion . however Channel The creation and Init Not thread safe , Please make sure that Init After success, it will be accessed by multiple threads , Destruct after no thread access .

management client, Number of threads configured 、 To join or place in length brpc::ChannelOptions, Or through gflags Global configuration

Init The function is divided into connecting to a server or service cluster

1. Connect to a server

// options by NULL The default value int Init(EndPoint server_addr_and_port, const ChannelOptions* options);
int Init(const char* server_addr_and_port, const ChannelOptions* options);
int Init(const char* server_addr, int port, const ChannelOptions* options);

This kind of Init The connected servers often have fixed servers ip Address , There is no need for naming services and load balancing , It's relatively light to create .

However, do not frequently create domain names Channel. This requires a query dns, It may take up to 10 second ( Inquire about DNS The default timeout for )

2. Connect clusters

int Init(const char* naming_service_url,
const char* load_balancer_name,
const ChannelOptions* options);

This kind of Channel It is necessary to start from... On a regular basis naming_service_url Get the list of servers from the specified naming service , And pass load_balancer_name The specified load balancing algorithm selects a machine to send requests .

You shouldn't create this class dynamically before every request （ Connect to the service cluster ）Channel. Because creating and destructing this kind of Channel Involve more resources , For example, you have to access the naming service once when creating ,

Otherwise, you don't know which servers are available . because Channel Can be shared by multiple threads , In general, there is no need to dynamically create .

client Set up

（1）brpc:ChannelOptions For initialization Channel

（2）brpc::Controller For a time RPC Medium coverage ChannelOptions Options in , It can be different each time according to the context

（3） overall situation gflags Used to adjust the behavior of some underlying code

Controller Characteristics ：

One Controller Corresponding once RPC, There can only be one user , The default thread is unsafe .
Cannot be shared , Pointers cannot be shared
Founded in RPC Prior to the start , Deconstruction in RPC After that, there are two modes
a Sync RPC front Controller Put it on the stack , Self destruct after leaving the scope
b asynchronous RPC front new Controller, done Delete in