程序博客网 > windows dream scence

服务器-TCP 在 EPOLL 模型中的注意细节

来源：互联网 发布：windows dream scence 编辑：程序博客网 时间：2024/06/04 18:43
 

前段时间在公司开发了基于udp的流媒体转发服务器，在公网udp转发ts，花屏比较严重。课下之余写了epoll-tcp模型的转发服务器作为测试，比较一下效果，其间遇到不少问题，在此做个笔记。代码最后附上


一、业务需求：终端录制视频（android编码h264）  客户端请求视频  服务器负责转发

因为是测试用没有考虑配置文件，负载均衡，安全认证等


二、协议指定


1、音视频 协议定义：总长度不大于1500 bytes， 终端启动后就进行发送数据

长度 short

终端id  int

类型 byte

包序号 short

帧类型 byte

数据

2 byte

4 byte

1 byte

2 byte

1 byte



类型标志：0xF0  视频

                    0xF1  音频

                    0x00  指令


2、指令协议  用于客户端请求视频

长度 short

终端id  int

类型 byte

指令 int

2 byte

4 byte

1 byte

4 byte


 指令：0x0010  请求报活

             0x0011   停止请求

  


三、数据结构关联


1、会话管理

struct Connection       //终端、客户端 会话管理
{

    int          term;          // 终端id， 用于客户端时表示请求目标的id
    int          sock;         //tcp 

    time_t   tm;             //上次活动时间

    int         bufsize;       //用于epoll 接收
    int         wantsize;
    int         recvsize;
    char    *recvbuf;

    CBufQue bufque;   //循环队列，客户端用于缓存要发送的数据

}


typedef map<int, Connection*> MAPConnection;  // socket -Connection   //存储会话

typedef set<int> SETSocket;                                    //socket

typedef map<int, SETSocket*> MAPTermClient;  // 一个终端可以转发到多个客户端，保存客户端的key


2、流程管理

     线程1-terminal：接收终端视频 ： epoll  ET模式  非阻塞socket

     线程2-media：将接受的视频数据分发到对应的客户端发送缓冲队列

     线程3-client：接收客户端的请求， 分发视频数据，epoll LT模式 非阻塞 socket

     线程4-cmd：处理客户端的指令，请求停止等 


四、代码注意细节

1、socket 设置非堵塞

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. bool NetCommon::SetSockBlock(const int &fd, bool block)  
  2. {  
  3.     if(block)  
  4.     {  
  5.         int flags = fcntl(fd, F_GETFL, 0);  
  6.         fcntl(fd, F_SETFL, flags&~O_NONBLOCK);  
  7.     }  
  8.     else  
  9.     {  
  10.         int flags = fcntl(fd, F_GETFL, 0);  
  11.         fcntl(fd, F_SETFL, flags|O_NONBLOCK);  
  12.     }  
  13.     return true;  
  14. }  

2、socket 设置SO_REUSEADDR
[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. bool NetCommon::SetReuseAddr(const int &fd, bool reuse)  
  2.  {  
  3.      int opt = 0;  
  4.      if(reuse)  
  5.      {  
  6.          opt = 1;  
  7.      }  
  8.      else  
  9.      {  
  10.          opt = 0;  
  11.      }  
  12.   
  13.      if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)  
  14.      {  
  15.          return false;  
  16.      }  
  17.      return true;  
  18.  }  

为什么要设置此项呢？参考  http://blog.csdn.net/liuhongxiangm/article/details/17301311


3、accept 

 LT模式比较清晰，就不说了     

 ET模式下accept存在的问题
 考虑这种情况：多个连接同时到达，服务器的TCP就绪队列瞬间积累多个就绪连接，由于是边缘触发模式，epoll只会通知一次，accept只处理一个连接，导致TCP就绪队列中剩下的连接都得不到处理。

解决办法是用while循环抱住accept调用，处理完TCP就绪队列中的所有连接后再退出循环。如何知道是否处理完就绪队列中的所有连接呢？accept返回-1并且errno设置为EAGAIN就表示所有连接都处理完。

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. int ctcpserver::acceptterminal(Connection *pConn)  
  2. {  
  3.     while(true)  
  4.     {  
  5.         int newsock = accept(pConn->sock,NULL, NULL);  
  6.   
  7.         if(newsock < 0)  
  8.         {  
  9.             if(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)  
  10.             {  
  11.                 break;  
  12.             }  
  13.             return -1;  
  14.         }  
  15.         if( newsock > 0)  
  16.         {  
  17.             NetCommon::SetSockBlock(newsock,false);  
  18.             NetCommon::SetReuseAddr(newsock, true);  
  19.   
  20.            if(m_mapConnTerminal.size() > 500)  
  21.            {  
  22.                 close(newsock);  
  23.                 return 0;  
  24.            }  
  25.   
  26.             Connection *newcon = new Connection;  
  27.             newcon->sock = newsock;  
  28.             newcon->wantsize = 2;  
  29.             newcon->recvsize = 0;  
  30.             time( &(newcon->tm));  
  31.   
  32.             if(m_epollTerminal.EpollAdd(newsock, EPOLLIN|EPOLLET, newcon) < 0)  
  33.             {  
  34.                 delete newcon;  
  35.                 newcon = NULL;  
  36.                 close(newsock);  
  37.                 return -1;  
  38.             }  
  39.             m_mapConnTerminal.insert(make_pair<int, Connection*>(newsock,newcon));  
  40.         }  
  41.     }  
  42.   
  43.     return 0;  
  44. }  



4、recv

 Epoll ET模式 非阻塞socket，必须独到没有数据可读，此处的设计是每个socket对应一个connection，connection中有一个数据包的长度wantsize，接收完一个数据包之后，会将此数据包放入队列等待处理，循环接收下一个数据包

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. int ctcpserver::recvn(Connection *pConn)  
  2. {  
  3.     int iret = 0;  
  4.     //wantsize < 2048  
  5.     while(pConn->recvsize < pConn->wantsize)  
  6.     {  
  7.         iret = recv(pConn->sock, pConn->buf+pConn->recvsize,pConn->wantsize-pConn->recvsize, 0);  
  8.         if(iret == -1)  
  9.         {  
  10.             if(errno == EINTR)  
  11.             {  
  12.                  break;  
  13.             }  
  14.             else if(errno == EWOULDBLOCK || errno == EAGAIN)  
  15.             {  
  16.                 break;  
  17.             }  
  18.             else  
  19.             {  
  20.                 return -1;  
  21.             }  
  22.         }  
  23.         if(iret == 0)  
  24.         {  
  25.             return -1;  
  26.         }  
  27.   
  28.         pConn->recvsize += iret;  
  29.     }  
  30.   
  31.     time(&(pConn->tm));  
  32.   
  33.     return  pConn->recvsize;  
  34. }  


此函数是在epoll接到事件后调用，协议约定数据包前俩字节是长度
[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. int ctcpserver::recvtrminal(Connection *pConn)  
  2. {  
  3.     int iret = 0;  
  4.     while(true)  
  5.     {  
  6.         iret = recvn(pConn);  
  7.         if(iret < 0)  
  8.         {  
  9.             close(pConn->sock);  
  10.             m_epollTerminal.EpollDel(pConn->sock,pConn);  
  11.             m_mapConnTerminal.erase(pConn->sock);  
  12.             delete pConn;  
  13.             pConn = NULL;  
  14.   
  15.             return -1; //error  
  16.         }  
  17.         if(pConn->recvsize != pConn->wantsize) //no data recv  
  18.         {  
  19.             break;  
  20.         }  
  21.         else  
  22.         {  
  23.             if(pConn->wantsize == 2) //接收玩的是数据的长度信息，去设置数据的接收大小  
  24.             {  
  25.                 pConn->wantsize = *(short*)(pConn->buf);  
  26.                 if(pConn->wantsize > 2048 || pConn->wantsize < 2) //设计是不大于1500，此处为了兼容其他测试  
  27.                 {  
  28.                     close(pConn->sock);  
  29.                     m_epollTerminal.EpollDel(pConn->sock,pConn);  
  30.                     m_mapConnTerminal.erase(pConn->sock);  
  31.                     delete pConn;  
  32.                     pConn = NULL;  
  33.   
  34.                     return -1; //something error with data  
  35.                 }  
  36.             }  
  37.             else            //接收完一个数据包  
  38.             {  
  39.                 BufNode *pnode = m_bufQueMedia.AllocNode();  
  40.                 if(pnode != NULL )  
  41.                 {  
  42.                     memset( pnode->pBuf,0,pnode->nMaxLen);  
  43.                     pnode->nLen = pConn->recvsize;  
  44.                     memcpy(pnode->pBuf, pConn->buf,pConn->recvsize);  
  45.                     pnode->sock = pConn->sock;  
  46.                     m_bufQueMedia.PushNode(pnode);   //media 线程负责处理数据  
  47.                     m_semMediaTask.Post();  
  48.   
  49.                 }  
  50.                 pConn->recvsize = 0;  
  51.                 pConn->wantsize = 2;  
  52.             }  
  53.         }  
  54.     }  
  55.   
  56.     return 0;  
  57. }  

epoll 循环，epoll添加socket时，epoll_eveny关联的是connection* ，在收到事件是，可以直接取来接收存放数据
[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. int ctcpserver::terminalloop()  
  2. {  
  3.     int event_count = 0;  
  4.     while(true)  
  5.     {  
  6.         event_count = m_epollTerminal.EpollWait();  
  7.         if(event_count < 0)  
  8.         {  
  9.             if(errno == EINTR)  
  10.             {  
  11.                 continue;  
  12.             }  
  13.             return 0;  
  14.         }  
  15.         else if(event_count > 0)  
  16.         {  
  17.             m_mutexTerminal.Lock();  
  18.             for(int index=0; index < event_count; index++)  
  19.             {  
  20.                 Connection *pConn  = (Connection*)(m_epollTerminal.GetEVPtr(index));  
  21.                 if(pConn->sock == m_terminalsock)  
  22.                 {  
  23.                     if(acceptterminal(pConn) < 0)  
  24.                     {  
  25.                         return 0;  
  26.                     }  
  27.                 }  
  28.                 else  
  29.                 {  
  30.                     if( m_epollTerminal.GetEVEvents(index)&EPOLLIN )  
  31.                     {  
  32.                         if(recvtrminal(pConn) < 0)  
  33.                         {  
  34.                             continue;  
  35.                         }  
  36.                     }  
  37.                     else if(m_epollTerminal.GetEVEvents(index)&EPOLLOUT)  
  38.                     {  
  39.   
  40.                     }  
  41.                 }  
  42.             }  
  43.             m_mutexTerminal.UnLock();  
  44.         }  
  45.     }  
  46.     return 0;  
  47. }  

5、send

这个问题比较谨慎处理，EPOLLOUT 到底在什么时候触发？？

ET 模式下，转发一片文章 http://www.cnblogs.com/moodlxs/archive/2011/12/16/2290288.html

ET模式称为边缘触发模式，顾名思义，不到边缘情况，是死都不会触发的。

EPOLLOUT事件：
EPOLLOUT事件只有在连接时触发一次，表示可写，其他时候想要触发，那你要先准备好下面条件：
1.某次write，写满了发送缓冲区，返回错误码为EAGAIN。
2.对端读取了一些数据，又重新可写了，此时会触发EPOLLOUT。
简单地说：EPOLLOUT事件只有在不可写到可写的转变时刻，才会触发一次，所以叫边缘触发，这叫法没错的！

其实，如果你真的想强制触发一次，也是有办法的，直接调用epoll_ctl重新设置一下event就可以了，event跟原来的设置一模一样都行（但必须包含EPOLLOUT），关键是重新设置，就会马上触发一次EPOLLOUT事件。

EPOLLIN事件：
EPOLLIN事件则只有当对端有数据写入时才会触发，所以触发一次后需要不断读取所有数据直到读完EAGAIN为止。否则剩下的数据只有在下次对端有写入时才能一起取出来了。
现在明白为什么说epoll必须要求异步socket了吧？如果同步socket，而且要求读完所有数据，那么最终就会在堵死在阻塞里。

LT模式 比较明了，只要可写就一直触发EPOLLOUT

在此测试项目，用了LT模式，但如何避免一直触发？

当有数据需要发送时，添加EPOLLOUT监听事件。当发送完成后移除此事件

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. int ctcpserver::sendclient(Connection *pConn)  
  2. {  
  3.    //  
  4.     BufNode *pnode = pConn->bufque.FrontNode(); //  
  5.     if(pnode != NULL)  
  6.     {  
  7.       int  iret =   send(pConn->sock, pnode->pBuf,pnode->nLen,0);  
  8.       if(iret <= 0)  
  9.        {  
  10.           if(errno != EAGAIN || errno == EWOULDBLOCK || errno == EAGAIN)  
  11.           {  
  12.                  return 0;  
  13.           }  
  14.           else  
  15.           {  
  16.               close(pConn->sock);  
  17.               m_epollClient.EpollDel(pConn->sock,pConn);  
  18.               m_mapConClient.erase(pConn->sock);  
  19.               delete pConn;  
  20.               pConn = NULL;  
  21.   
  22.         //      cout << "m_mapConClient count:" << m_mapConClient.size() << endl;  
  23.               return -1;  
  24.           }  
  25.   
  26.        }  
  27.       else  
  28.       {  
  29.           pConn->bufque.PopNode();  
  30.           pConn->bufque.FreeNode(pnode);  
  31.       }  
  32.   
  33.     }  
  34.     if(pConn->bufque.GetUsedNodeCount() == 0)  
  35.     {  
  36.        <span style="color:#990000;"> m_epollClient.EpollMod(pConn->sock, EPOLLIN, pConn);</span><span style="color: rgb(153, 0, 0); font-family: Georgia, Times, 'Times New Roman', serif;">//移除EPOLLOUT 监听</span><span style="color:#990000;">  
  37. </span>    }  
  38.   
  39.     return 0;  
  40. }  


[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. int ctcpserver::mediataskloop()  
  2. {  
  3.     while (true)  
  4.     {  
  5.         m_semMediaTask.Wait();  
  6.         BufNode *pnode = m_bufQueMedia.PopNode();  
  7.         if(pnode == NULL)  
  8.         {  
  9.             continue;  
  10.         }  
  11.         //id-client  
  12.         int id = *(int*)(pnode->pBuf+2);  
  13.   
  14.         m_mutexTermClient.Lock();  
  15.         MAPTermClientIt itTermClient = m_mapTermClient.find(id);  
  16.         if(itTermClient == m_mapTermClient.end())  
  17.         {  
  18.             SETSocket *pSetSock = new  SETSocket;  
  19.             pSetSock->clear();  
  20.             m_mapTermClient.insert(make_pair<int, SETSocket*>(id,pSetSock));  
  21.         }  
  22.         else  
  23.         {  
  24.             SETSocket *pSetSock= itTermClient->second;  
  25.             if(!pSetSock->empty())  
  26.             {  
  27.                 SETSocketIt itSock;  
  28.                 m_mutexClient.Lock();  
  29.                 for(itSock=pSetSock->begin(); itSock != pSetSock->end(); ++ itSock)  
  30.                 {  
  31.                     int sock = *itSock;  
  32.                     MAPConnectionIt itConnClient = m_mapConClient.find(sock);  
  33.                     if(itConnClient != m_mapConClient.end())  
  34.                     {  
  35.                         Connection *pConn = itConnClient->second;  
  36.                         BufNode *pnodeClient = pConn->bufque.AllocNode();  
  37.                         if(pnodeClient == NULL)  
  38.                         {  
  39.                             continue;  
  40.                         }  
  41.                         memcpy(pnodeClient->pBuf, pnode->pBuf, pnode->nLen );  
  42.                         pnodeClient->nLen = pnode->nLen;  
  43.                         pConn->bufque.PushNode(pnodeClient);  
  44.                       <span style="color:#990000;">  m_epollClient.EpollMod(pConn->sock, EPOLLIN|EPOLLOUT, pConn); //添加EPOLLOUT 监听</span>  
  45.                     }  
  46.                     else  
  47.                     {  
  48.                         pSetSock->erase(itSock);  
  49.                     }  
  50.                 }  
  51.                 m_mutexClient.UnLock();  
  52.             }  
  53.         }  
  54.         m_mutexTermClient.UnLock();  
  55.   
  56.         m_bufQueMedia.FreeNode(pnode);  
  57.     }  
  58.   
  59.     return 0;  
  60. }  

附上代码：http://download.csdn.net/detail/liuhongxiangm/6709063



                   

版权声明：本文为博主原创文章，未经博主允许不得转载。

0 0
windows dream scence windows dream scence
原创粉丝点击
热门IT博客
不转不是中国人 知乎不转不是中国人 知乎
ecshop 水果商城源码ecshop 水果商城源码
淘宝上6s官换机靠谱吗
淘宝拍单免费送衣服
apache ftp http访问
苹果手机短信恢复软件
怎样在淘宝开店铺介绍
软件著作权申请表范文
淘宝上的虚拟试衣间
steam 恐怖游戏 知乎
怎么查看服务器的域名
手机港澳台直播软件
java replaceall 空格
python 构造函数
什么是炒黄金知乎
淘宝助理没有创建宝贝
c语言99乘法表下三角
冰心卡盟域名
sql查询数据库名称
医疗数据采集平台
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 魔戒索伦 混沌魔君索伦森 霍亨索伦城堡 霍亨索伦家族 索伦森怎么打 索伦之眼 神农不死 留学英国南安普顿索伦特大学 索佩 索佳 索佳全站仪数据线 索佳全站仪价格 索佳set02n全站仪 索佳全站仪型号 索兰女鞋 索兰 索兰鞋子 索兰旗舰店 索兰调 亿通索兰 索兰女鞋专卖店 清华索兰太阳能 索兰空气源热泵 清华索兰空气能热水器 富贵鸟女鞋 浴普索兰太阳能 索兰恩之怒 索兰鲁克宝珠 插编钢丝绳索具 钢丝绳索具 002342巨力索具股吧 索具螺旋扣 巨力索具股票行情 巨力索具资金流向 巨力索具股份有限公司 不锈钢索具 链条成套索具 钢丝绳索具加工 吊装索具 索具链条 吊装带索具 索具

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里