一个高性能RPC框架的连接管理

最新推荐文章于 2022-10-11 11:13:08 发布
最新推荐文章于 2022-10-11 11:13:08 发布
阅读量914 收藏
点赞数
分类专栏： RPC框架
既然说连接，先对EpollServer的连接管理做个介绍吧。客户端与服务器一次conn，被封装成为Connection类在服务器进行管理。
服务器连接有三种类型，分别为：
enum  EnumConnectionType
        {
             EM_TCP  = 0,
             EM_UDP  = 1,
             EM_BUS  = 2
        };


Connection成员属性
        time_t               _iLastRefreshTime ;// 最后刷新时间，初始化为初始化的当前时间
         BindAdapter          *  _pBindAdapter ;// 适配器
         TC_Socket             _sock ; // TC_Socket
         uint32_t              _uid ; // 连接的唯一编号， 默认为0
         int                   _lfd ; // 监听的socket， 默认为-1
         int                   _timeout ;// 超时时间
        string               _ip ; // ip
         uint16_t               _port ; // 端口， 默认为0
        string               _recvbuffer ; // 接收数据buffer
        string               _sendbuffer ; // 发送数据buffer
                   size_t                       _sendPos ;// 默认为0
         int                   _iHeaderLen ; // 需要过滤的头部字节数， 默认为0
         bool                  _bClose ; // 发送完当前数据就关闭连接， 默认为false
         int                   _iMaxTemQueueSize ;// 临时队列的最大长度， 默认为100
        EnumConnectionType   _enType ; // 连接类型， 默认为TCP
                   bool                    _bEmptyConn ; // 是否为空连接，默认为false，UDP一直为false
                   char                  *  _pRecvBuffer ; // 接收数据的临时buffer,加这个目的是对   udp 接收数据包大小进行设置,默认为null
                   size_t                       _nRecvBufferSize ;// 默认为64K，每次默认读取数据块大小

Connection提供了一系列的getter/setter方法修改上述属性，并且将那个EpollServer列为friend class,提供接收数据的功能操作接口。


注意!一大波数据正在袭来
当连接需要接收数据的时候（边缘触发，所以这里关键是一次性要将所有数据接收完）,我们需要一次性把数据接收完以后，把数据解析成一个一个完整的数据包，放入到指定的队列 o 中，首先Connection的buf是string的，本身不存在长度限制（可优化点），每次read的buf是8192个字节，不断的把客户端管道中的数据读取到Connection的Buf中，直到客户端EAGINE（没有数据了），或者接收到的数据小于每次读取的8192个字节。则表示已经没有数据了。所以这里如果长时间不处理，将会使得Connection的buf string堆积很多数据，如果没有数据可读了，则调用解析协议。

  int  TC_EpollServer::Connection::recv(  recv_queue  ::queue_type &o)
{
    o.clear ();

     char  buffer[8192] =  "\0" ;

     while (  true )
    {
         int  iBytesReceived = 0;

         if (  _lfd  == -1)
        {
                  if (  _pRecvBuffer )      //如果该connection分配了自己的数据接受buffer，则用自己的，否则每次接收每次new出来一块buffer。
                {
                     iBytesReceived =  _sock . recvfrom((  void *)  _pRecvBuffer ,  _nRecvBufferSize ,  _ip ,  _port , 0);
                }
                  else
                {
                     iBytesReceived =  _sock . recvfrom((  void *)buffer,  sizeof (buffer),  _ip ,  _port , 0);
                }
        }
         else
        {
            iBytesReceived = :: read(  _sock .getfd(), ( void *)buffer,  sizeof (buffer));
        }

         if  (iBytesReceived < 0)
        {
             if ( errno == EAGAIN )
            {
                 //没有数据了
                 break ;
            }
             else
            {
                 //客户端主动关闭
                 _pBindAdapter ->getEpollServer()-> debug(  "recv ["  +  _ip  +  ":"  +  TC_Common :: tostr(  _port ) +  "] close connection" );
                 return  -1;
            }
        }
         else   if ( iBytesReceived == 0)
        {
             //客户端主动关闭
             _pBindAdapter ->getEpollServer()-> debug(  "recv ["  +  _ip  +  ":"  +  TC_Common :: tostr(  _port ) +  "] close connection" );
             return  -1;
        }

         //保存接收到数据
         if (  _lfd  == -1)
        {
                  if (  _pRecvBuffer )
                {
                       _recvbuffer . append(  _pRecvBuffer , iBytesReceived);
                }
                  else
                {
                       _recvbuffer . append(buffer, iBytesReceived);
                }
        }
             else
           {
                  _recvbuffer . append(buffer, iBytesReceived);
           }

         //UDP协议
         if (  _lfd  == -1)
        {
             if (  _pBindAdapter -> isIpAllow(  _ip ) ==  true )
            {
                 parseProtocol(o);
            }
             else
            {
                  //udp ip无权限
                 _pBindAdapter ->getEpollServer()-> debug(  "accept ["  +  _ip  +  ":"  +  TC_Common  ::tostr(  _port ) +  "] ["  +  TC_Common :: tostr(  _lfd ) +  "] not allowed" );
            }
             _recvbuffer  =  "" ;
        }
         else
        {
             //接收到数据不超过buffer,没有数据了(如果有数据,内核会再通知你)
             if (( size_t)iBytesReceived <  sizeof (buffer))
            {
                 break ;
            }
             //字符串太长时 substr性能会急剧下降
             if (  _recvbuffer . length() > 8192)
            {
                parseProtocol(o);
            }
        }
    }

     if (  _lfd  != -1)
    {
         return  parseProtocol(o);
    }

     return  o. size();
}


解析方法将把Connection从客户端管道中获取的所有的数据（ _recvbuffer ）调用协议解析器进行协议解析，直到剩下的数据不构成一个完整的接受包为止。把这些请求包放入方法参数的队列中。
int  TC_EpollServer::Connection::parseProtocol( recv_queue ::queue_type &o)
{
     try
    {
         while  ( true )
        {
             //需要过滤首包包头
             if (  _iHeaderLen  > 0)
            {
                 if (  _recvbuffer . length() >= ( unsigned )  _iHeaderLen )
                {
                    string header =  _recvbuffer .substr(0,  _iHeaderLen );
                     _pBindAdapter ->getHeaderFilterFunctor()(( int )( TC_EpollServer  :: PACKET_FULL ), header);
                     _recvbuffer  =  _recvbuffer . substr( _iHeaderLen );
                     _iHeaderLen  = 0;
                }
                 else
                {
                     _pBindAdapter ->getHeaderFilterFunctor()(( int )( TC_EpollServer  :: PACKET_LESS ),  _recvbuffer );
                     _iHeaderLen  -=  _recvbuffer . length();
                     _recvbuffer  =  "" ;
                     break ;
                }
            }

            string ro;

             int  b =  _pBindAdapter ->getProtocol()(  _recvbuffer , ro);    //此处调用了Adapter关联的编码解码器，taf默认是AppProtocol::parse()

             if (b ==  TC_EpollServer ::  PACKET_LESS )
            {
                 //包不完全
                 break ;   
            }
             else  if (b ==  TC_EpollServer ::  PACKET_FULL ) 
            {
                 tagRecvData * recv =  new  tagRecvData();
                recv->  buffer            = ro;
                recv->  ip                =  _ip ;
                recv->  port              =  _port ;
                recv->  recvTimeStamp     =  TC_TimeProvider ::getInstance()->getNow();
                recv->  uid               = getId();
                recv->  isOverload        =  false ;
                recv->  isClosed          =  false ;

                       //收到完整的包才算
                       this ->  _bEmptyConn  =  false ;

                 //收到完整包
                o. push_back(recv);

                 if ((  int ) o. size() >  _iMaxTemQueueSize )
                {
                    insertRecvQueue(o);
                    o. clear();
                }

                 if (  _recvbuffer . empty())
                {
                     break ;
                }
            }
             else
            {
                 _pBindAdapter ->getEpollServer()-> error( "recv ["  +  _ip  +  ":"  +  TC_Common :: tostr( _port ) +  "],packet error." );
                 return  -1;                       //协议解析错误
            }
        }
    }
     catch (exception &ex)
    {
         _pBindAdapter ->getEpollServer()-> error( "recv protocol error:"  + string (ex.what()));
         return  -1;
    }
     catch (...)
    {
         _pBindAdapter ->getEpollServer()-> error( "recv protocol error" );
         return  -1;
    }

     return  o.size();
}

AppProtocol解析如下：
     /**
     * 解析协议
     * @param in, 目前的buffer
     * @param out, 一个完整的包
     *
     * @return int, 0表示没有接收完全, 1表示收到一个完整包
     */
     static  int  parse(string &in, string &out)
    {
         return  parseLen<10000000>(in,out);
    }

     template <taf::  Int32  iMaxLength >
     static  int  parseLen(string &in, string &out)
    {
         if (in.length() <  sizeof (taf:: Int32 ))  //首先需要一个int32来标志包的长度，所以我们的接受buff的长度起码得>int32,否则标识为收包不完整
        {
             return  TC_EpollServer ::  PACKET_LESS ;
        }

        taf::  Int32  iHeaderLen; //包的长度头

        memcpy(&iHeaderLen, in.c_str(),  sizeof (taf::  Int32 ));  //获取包的长度

        iHeaderLen = ntohl(iHeaderLen); //将网络顺序变为主机顺序，非常重要

         if (iHeaderLen < taf::  Int32 (  sizeof (taf::  Int32 ))|| iHeaderLen >  iMaxLength ) //如果当前的包的长度超过了最大长度或者小于一个int32的长度（包头本身）则认为协议错误
        {
             return  TC_EpollServer ::  PACKET_ERR ;
        }

         if (( int )in.length() < iHeaderLen)  //缓存区里面字段长度不够包头长度
        {
             return  TC_EpollServer ::  PACKET_LESS ;
        }

        out = in.substr( sizeof (taf:: Int32 ), iHeaderLen -  sizeof (taf:: Int32  ));

        in  = in. substr(iHeaderLen);//将刚才已经解析的完整的包部分从输入中去掉

         return  TC_EpollServer :: PACKET_FULL ;
    }

利用adapter中注册的protocol进行编解码，如果包不完整，则跳出，返回状态码，如果收包完整，则构建新的 tagRecvData，设置完整的包buff，并且赋予Connection的ID（这个Connection锁接收到的数据包都是这个Connection的ID）以及将接收数据  tagRecvData的状态设置为非空，将这个包放入临时接收数据队列。如果当前这个接受数据队列超出了临时队列的最大长度（否则则在返回后再插入，避免大量的请求阻塞在这里而不能得到及时处理导致的各种超时，所以每到一定数目，则先放入 adapter去进行处理 ），则将该接收队列中的数据包放到adapter的rbuffer中(这个rbuffer是所有Connection一起共享的，所以必须是线程安全的)，如果当前adapter已经过载，将数据包依次设置为过载状态（很重要）放前面，这样有利于该Adapter接口紧急处理，避免雪崩和滚雪球效应，否则放后面。

void  TC_EpollServer::Connection:: insertRecvQueue(  recv_queue ::queue_type &vRecvData)
{
     if (!vRecvData. empty())
    {
         //服务队列已超载  数据放在队列头部
         if (  _pBindAdapter ->isOverload())
        {
             recv_queue  ::queue_type::iterator it = vRecvData.begin();

             recv_queue  ::queue_type::iterator itEnd = vRecvData.end();

             while (it != itEnd)
            {
               (*it)-> isOverload =  true ;

               ++it;
            }
             _pBindAdapter -> insertRecvQueue(vRecvData,  false );
        }
         else
        {
             _pBindAdapter -> insertRecvQueue(vRecvData);
        }
    }
}



Connection需要集中管理起来
所有Connection都会被ConnectionList一个连接队列管理起来。统一进行超时检测等，空连接超时检测等， 连接队列 存储的数据为

                          pair<  Connection  *, multimap<time_t,  uint32_t  >::iterator >  list_data;


ConnectionList成员属性如下：
         TC_EpollServer                   *  _pEpollServer ; // 服务
         uint32_t                          _total ; // 总计连接数
        list<  uint32_t >                   _free ; // 空闲链表
        size_t                           _free_size ; // 空闲链元素个数
         list_data                        *  _vConn ; // 链接
        multimap<time_t,  uint32_t >       _tl ; // 超时链表
        time_t                           _lastTimeoutTime ; // 上次检查超时时间
         uint32_t                          _iConnectionMagic ; // 连接ID的魔数




ConnectionList初始化，指定ConnectionList可以管理的最大连接数目，建立最大连接数目需要的空间，并标识为可用。
void  TC_EpollServer::ConnectionList::init(  uint32_t  size)
{
     _lastTimeoutTime  =  TC_TimeProvider :: getInstance()->getNow();  //初始化检查超时时间

     _total  = size;

     _free_size   = 0;  //空闲连接数目初始化为0

     //初始化链接链表
     if (  _vConn )  delete []  _vConn ;  //如果空间存在，则删除先。

     //分配total+1个空间(多分配一个空间, 第一个空间其实无效)
     _vConn  =  new   list_data [  _total +1];  //分配最大连接数目需要的空间

     _iConnectionMagic    = ((  uint32_t )  _lastTimeoutTime ) << 20;  //连接ID的魔数

     //free从1开始分配, 这个值为 uid, 0保留为管道用, epollwait根据0判断是否是管道消息 ，表示空间的连接数目
     for (  uint32_t  i = 1; i <=  _total ; i++)
    {
         _vConn [i]. first = NULL;

         _free . push_back(i);

        ++  _free_size ;
    }
        
}

获取唯一ID，从当前free的空闲连接资源中取得一个可用连接的ID（也就是链表下标），并将之从free中去掉，并且与魔数或运算生成唯一ID。分配ID，相当于分配资源了。这里的魔数是ConnectionList建立的时候的时间<<20的值(剩下的12位留出来给该ConnectionList的下标，表明这个Connection存储在data_list的哪个位置)，主要是用于校验当前的链接是否是该ConnectionList管理的资源，Connection的ID是否是这个ConnectionList分配出去的。
uint32_t  TC_EpollServer::ConnectionList::getUniqId ()
{
     TC_ThreadLock ::  Lock  lock(*  this );

     uint32_t  uid =  _free . front();

    assert (uid > 0 && uid <=  _total  );

     _free . pop_front();

    --  _free_size ;

     return   _iConnectionMagic  | uid;
}

新增连接，首先锁住整个ConnectionList，获取连接的ID(该ID之前由该LIST生成)，获得当时分配资源的下标，并将至加载到指定链表数据的指定位置。并且将该connection放入到指定链表位置，同时将该connection的下标放入到超时管理的map中。
void  TC_EpollServer:: ConnectionList::add(  Connection  *cPtr, time_t iTimeOutStamp)
{
     TC_ThreadLock ::  Lock  lock(*  this );

     uint32_t  muid = cPtr->getId();
     uint32_t  magi = muid & (0xFFFFFFFF << 20);
     uint32_t  uid  = muid & (0x7FFFFFFF >> 11);

    assert (magi ==  _iConnectionMagic  && uid > 0 && uid <=  _total  && ! _vConn  [uid].first);

     _vConn [uid] = make_pair(cPtr,  _tl . insert(make_pair (iTimeOutStamp, uid)));
}


删除某个连接资源，根据指定的连接的ID,获得其在链表中的下标，从超时检测的map中移除他，从链表中找到该pair，删除connection资源，并且重新将他放到free可用中，同时更新freesize

void  TC_EpollServer::ConnectionList:: del( uint32_t  uid)
{
     TC_ThreadLock ::  Lock  lock(*  this );

     uint32_t  magi = uid & (0xFFFFFFFF << 20);
    uid           = uid & (0x7FFFFFFF >> 11);

    assert (magi ==  _iConnectionMagic  && uid > 0 && uid <=  _total  &&  _vConn  [uid].first);

    _del(uid);
}

void  TC_EpollServer::ConnectionList::_del(  uint32_t  uid)
{
    assert (uid > 0 && uid <=  _total  &&  _vConn  [uid].first);

     _tl . erase( _vConn  [uid].second);

     delete   _vConn [uid]. first;

     _vConn [uid]. first = NULL;

     _free . push_back(uid);

    ++  _free_size ;
}

超时检测，没秒检查一次，每次把超时最后检测时间更新一下，超时检测的时候需要锁住整个链表，

void  TC_EpollServer::ConnectionList::checkTimeout (time_t iCurTime)
{
     //至少1s才能检查一次
     if (iCurTime -  _lastTimeoutTime  < 1)
    {
         return ;
    }

     _lastTimeoutTime  = iCurTime;

     TC_ThreadLock ::  Lock  lock(*  this );

    multimap<time_t,  uint32_t  >::iterator it =  _tl  .begin();

     while (it !=  _tl . end())
    {
         //已经检查到当前时间点了, 后续不用在检查了
         if (it-> first > iCurTime)
        {
             break ;
        }

         uint32_t  uid = it-> second;

        ++it;

         //udp的监听端口, 不做处理
         if (  _vConn [uid]. first->getListenfd () == -1 ||  _vConn  [uid].first-> getType() ==  Connection ::  EM_BUS )
        {
             continue ;
        }

         //超时关闭
         _pEpollServer -> delConnection( _vConn  [uid].first,  false );

         //从链表中删除
        _del(uid);
    }


       if (  _pEpollServer ->IsEmptyConnCheck())
     {
           it =  _tl . begin();
             while (it !=  _tl . end())
           {
                  uint32_t  uid = it-> second;

                  //遍历所有的空连接
                  if (  _vConn [uid]. first->IsEmptyConn ())
                {
                       //获取空连接的超时时间点
                      time_t iEmptyTimeout = (it-> first -  _vConn  [uid].first-> getTimeout()) + ( _pEpollServer  ->getEmptyConnTimeout()/1000);

                       //已经检查到当前时间点了, 后续不用在检查了
                       if (iEmptyTimeout > iCurTime)
                     {
                             break ;
                     }

                       //udp的监听端口, 不做处理
                       if (  _vConn [uid]. first->getListenfd () == -1 ||  _vConn  [uid].first-> getType() ==  Connection ::  EM_BUS )
                     {
                           ++it;
                             continue ;
                     }

                       //超时关闭
                       _pEpollServer -> delConnection(  _vConn [uid]. first,  false );

                       //从链表中删除
                     _del(uid);
                }

                ++it;
           }
     }
}
chary8088
关注
专栏目录
rpc项目中的长连接与短连接的思考
qq_的博客
10-10 515
类似于http的长连接和短连接的概念，rpc项目中的短连接是指处理完一次rpc请求后就断开连接，长连接是指处理完一次rpc请求后不断开连接，复用连接。http中长连接是指处理完一次http请求和响应之后不断开tcp连接，http短连接是指处理完一次http请求和响应之后断开tcp连接（一般是服务器断开，至于为什么是服务器断开，则又是一篇小文章了hhh）。
RPC框架浅层理解
qq_45429238的博客
01-08 162
RPC（远程过程调用） 基础过程：客户端发送函数调用请求以及相关参数至远程服务端，服务端计算完成结果返回给客户端的过程即RPC（远程过程调用） 详细框架思路： RPC流程图： 过程描述： 1、当客户端产生一个需要调用远程服务器函数的请求时，利用诸如XML等java序列化协议将需要调用的函数名和相关参数序列化 2、利用相关的网络协议传输至API网关，API网关通过断言、过滤等服务方法对调用请求进行处理，如果不符合断言，则返回无效请求；如果满足断言和过滤条件，则向服务注册中心传递请求 3、服务注册中心通过相应
rpc中客户端的连接池的设计
junaozun的博客
09-13 1011
为什么需要连接池？ 连接池是一个创建和管理连接的缓冲池技术，我们知道，client 每次向 server 发起请求都会创建一个连接。一般一个 rpc 请求消耗的时间可能是几百毫秒到几秒，也就是说在一个比较短的时间内，这个连接就会被销毁。假设我们一秒钟需要处理 20w 个请求，假如不使用连接池的话，可能几万十几万的连接在短时间内都会被创建和销毁，这对 cpu 资源是一个很大的消耗，同时因为我们的端口数是 1~65535，除了一些端口被计算机内部占用，每次 client 创建连接都需要分配...
RPC框架的连接模型
much efforts, much luck
03-21 1742
一、RPC的客户端连接模型 1、连接成本： 使用TCP协议时，会在客户端和服务器之间建立一条虚拟的信道，这条虚拟信道就是指连接，而建议这条连接需要3次握手，拆毁这条连接需要4次挥手，可见，我们建立这条连接是有成本的，这个成本就是效率成本，简单点 说就是时间成本，你要想发送一段数据，必须先3次握手（来往3个包），然后才能发送数据，发送完了，你需要4次挥手（来往4个包）来断开这个连接。 其二，CPU资源成本，三次握手和4次挥手和发送数据都是从网卡里发送出去和接收的，还有其余的设备，比如防火墙，路由器等等，站在操
高性能RPC框架 nfs-rpc.7z
07-06
在本场景中，我们关注的是一个名为“nfs-rpc”的高性能RPC框架。NFS（Network File System）最初是UNIX系统间用于文件共享的协议，而这里的“nfs-rpc”可能是指将NFS协议与RPC概念相结合的一种实现，旨在提供高效的...
高性能RPC框架 nfs-rpc
06-02
RPC（Remote Procedure Call）是一种进程间通信机制，它允许一个程序调用另一个位于不同系统上的程序，就像调用本地函数一样。NFS-RPC（Network File System - Remote Procedure Call）是基于RPC的一种特定应用，...
Python-Doge是一个基于Python的高性能开源RPC框架
08-10
Python-Doge是一个专门为Python开发者设计的高性能、开源的RPC框架，其设计理念是简化服务之间的通信，提高系统的可扩展性和效率。与阿里巴巴的Dubbo和微博的Motan等知名RPC框架类似，Doge致力于为Python开发者提供...
TARS-PHP：PHP构建高性能RPC框架
01-03
TARS-PHP作为一个专门为PHP设计的高性能RPC框架，不仅继承了TARS框架的优秀特性，还充分利用了PHP语言的灵活性和易用性，使其成为构建高性能微服务的理想选择。无论是对于大型企业还是初创团队，TARS-PHP都能提供...
基于Java的源码-高性能RPC框架 nfs-rpc.zip
最新发布
07-23
本项目"nfs-rpc"是一个基于Java实现的高性能RPC框架，旨在提供高效、可靠且易用的服务调用解决方案。 在Java中，RPC框架如Hessian、Dubbo、gRPC等已经非常成熟，而nfs-rpc可能是针对特定场景或需求进行优化的版本。...
RPC研究
iteye_15082的博客
02-25 796
深入浅出RPC——深入篇 mindwind  ·  2014-09-22 出处：http://mindwind.me/blog/2014/09/22/深入浅出RPC——深入篇.html   「解析 RPC 的本质。」   《深入篇》我们主要围绕 RPC 的功能目标和实现考量去展开，一个基本的 RPC 框架应该提供什么功能，满足什么要求以及如何去实现它？   R...
php搭建简单rpc（解决mongodb连接数的问题）
洪光光的博客
11-20 1909
rpc解释RPC 的全称是 Remote Procedure Call 是一种进程间通信方式。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即程序员无论是调用本地的还是远程的，本质上编写的调用代码基本相同。 某网上解释，具体基础解释可以自行百度,其实我通俗的解释好了就是远程调用方法 现在有两台服务器A和B，这时候两台服务器分别运
RPC原理介绍
热门推荐
elricboa的专栏
12-18 1万+
面向服务架构SOA 任何大型网站的发展都伴随着网站架构的演进。网站架构一般最初是单应用设计，然后逐渐经历面向对象设计和模块化设计的架构，最终发展到面向服务的服务化架构。在单应用设计架构体系当中，我们关注的是方法和实体；而在面向服务的服务化架构中，我们则关注的是服务和API。网站架构演进图如下图所示： 传统应用开发中会面临研发成本高，运维效率低等挑战。 研发成本高主要体现在
RPC
够浪
03-19 2384
RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。 ​ 简单来说，就是跟远程访问或者web请求差不多，都是一个client向远端服务器请求服务返回结果，但是web请求使用的网络协议是http高层协议，而rpc所使用的协议多为TCP，是网络层协议，减少了信息的包装，加快了处理速度。...
grpc 报错 rpc: the client connection is closing
weixin_46173995的博客
10-11 2817
由于创建grpc客户端最终归属wireApp()，(依赖倒置实现解耦)，在function main()中已经返回，就会执行NewSocialClient中的defer()将连接关闭，导致调用失败。第一次写golang微服务，也是第一次接触gprc，底层原理还不太了解，盲猜跟openFeign差不多生成代理类，但grpc好像专门开放了端口，用protobuf协议传输。官方文档中的实例，main function中使用了defer()关闭连接，在defer。将NewSocialClient 中的。
RPC 使用中的一些注意点
weixin_33898876的博客
12-25 385
最近线上碰到一点小问题，分析其原因发现是出在对 RPC 使用上的一些细节掌握不够清晰导致。很多时候我们做业务开发会把 RPC 当作黑盒机制来使用，但若不对黑盒的工作原理有个基本掌握，也容易犯一些误用的微妙错误。 虽然曾经已经写过一篇《RPC 的概念模型与实现解析》 从概念模型和实现细节上讲述了 RPC 的原理，这一篇就从使用上的一些注意点来捋一捋吧。 同步 RPC 的调用通常为了方便使用，会被伪...
服务器 最大连接数：
xiaoliuliu2050的专栏
10-21 1万+
服务器可以设置  max_Threads  = 150  最大线程数量(最大并发数量，或者说最大的并发用户量) （可以处理连接的线程数量）  accept_count 如果服务器中所有线程都在工作，那排队的请求连接的数量 的值。 这样看 服务器 的最大线程数量 为 150 个。 最多 连接  1150 个。 第1151 个连接请求的时候，会等待connection_tim
究竟什么是RPC？
知行合一
11-11 5705
RPC：远程过程调用，是一种允许分布式应用程序调用网络上不同计算机的可用服务的机制。RPC服务会在注册表中给自己注册一个UUID，成为通用唯一标识符，这个UUID针对每一项服务都是一个唯一的值，且在所有的平台上通用。 当一项RPC服务启动的时候，它会获得一个高位端口，并且以其UUID对该端口进行注册，有些RPC服务则会随机使用高位端口，而有些服务每次都尽量使用相同的端口（如果可用）。但在服务的生
TARS开源项目：高性能RPC框架与运营管理平台
它不仅仅是一个简单的RPC框架，还配备了一个一体化的运营管理平台。该框架面向服务的名字注册和发现，为服务之间的通信提供了一种高效、可伸缩的解决方案。TARS框架还具备伸缩调度功能，这有助于实现运维的半托管...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值