memcached（7）
是什么？按照手册的说法：是为处理大批量句柄而作了改进的。当然，这不是内核才有的，它是在内核中被引进的，它几乎具备了之前所说的一切优点，被公认为下性能最好的多路就绪通知方法。
的相关系统调用
只有个系统调用。
创建一个的句柄。自从之后，参数是被忽略的。需要注意的是，当创建好句柄（即内核事件表）后，它就是会占用一个值，在下如果查看进程，是能够看到这个的，所以在使用完后，必须调用关闭，否则可能导致被耗尽。
的事件注册函数，它不同于是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。
第一个参数是的返回值。
第二个参数表示动作，用三个宏来表示：
：注册新的到中；
：修改已经注册的的监听事件；
：从中删除一个；
第三个参数是需要监听的。
第四个参数是告诉内核需要监听什么事，结构如下：
可以是以下几个宏的集合：
：表示对应的文件描述符可以读（包括对端正常关闭）；
：表示对应的文件描述符可以写；
：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
：表示对应的文件描述符发生错误；
：表示对应的文件描述符被挂断；
：将设为边缘触发模式，这是相对于水平触发来说的。
：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个的话，需要再次把这个加入到队列里
收集在epoll监控的事件中已经发送的事件。参数。告之内核这个有多大，这个的值不能大于创建时的，参数是超时时间（毫秒，会立即返回，将不确定，也有说法说是永久阻塞）。如果函数调用成功，返回对应上已准备好的文件描述符数目，如返回表示已超时。
epoll工作原理
同样只告知那些就绪的文件描述符，而且当我们调用获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（）技术（具体的实现是啥？），这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
另一个本质的改进在于采用基于事件的就绪通知方式。在中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而事先通过来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似的回调机制，迅速激活这个文件描述符，当进程调用时便得到通知。
的种工作方式水平触发（）和边缘触发（）
是epoll缺省的工作方式，并且同时支持block和no-block
socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你&的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表．
是高速工作方式，只支持no-block socket，它效率要比LT更高。ET与LT的区别在于，当一个新的事件到来时，ET模式下当然可以从epoll_wait调用中获取到这个事件，可是如果这次没有把这个事件对应的套接字缓冲区处理完，在这个套接字中没有新的事件再次到来时，在ET模式下是无法再次从epoll_wait调用中获取这个事件的。而LT模式正好相反，只要一个事件对应的套接字缓冲区还有数据，就总能从epoll_wait中获取这个事件。
epoll的优点：
支持一个进程打开大数目的描述符
最不能忍受的是一个进程所打开的是有一定限制的，由设置，默认值是。对于那些需要支持的上万连接数目的服务器来说显然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降，二是可以选择多进程的解决方案传统的方案，不过虽然上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完美的方案。不过则没有这个限制，它所支持的上限是最大可以打开文件的数目，这个数字一般远大于举个例子在内存的机器上大约是万左右，具体数目可以察看一般来说这个数目和系统内存关系很大。
效率不随数目增加而线性下降
传统的另一个致命弱点就是当你拥有一个很大的集合，不过由于网络延时，任一时间只有部分的是活跃的，但是每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是不存在这个问题，它只会对活跃的进行操作这是因为在内核实现中是根据每个上面的函数实现的。那么，只有活跃的才会主动的去调用函数，其他状态则不会，在这点上，实现了一个伪，因为这时候推动力在内核。在一些中，如果所有的基本上都是活跃的比如一个高速环境，并不比有什么效率，相反，如果过多使用效率相比还有稍微的下降。但是一旦使用模拟环境的效率就远在之上了。
使用加速内核与用户空间的消息传递
这点实际上涉及到的具体实现了。无论是还是都需要内核把消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，是通过内核于用户空间同一块内存实现的。而如果你想我一样从内核就关注的话，一定不会忘记手工这一步的。
这一点其实不算的优点了，而是整个平台的优点。也许你可以怀疑平台，但是你无法回避平台赋予你微调内核的能力。比如，内核协议栈使用内存池管理结构，那么可以在运行时期动态调整这个内存的大小通过完成。再比如函数的第个参数完成次握手的数据包队列长度，也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的网卡驱动架构。
linux下epoll如何实现高效处理百万句柄的
开发者们言必称iocp，linux开发者们则言必称epoll。大家都明白epoll是一种IO多路复用技术，可以非常高效的处理数以百万计的socket句柄，比起以前的select和poll效率高大发了。我们用起epoll来都感觉挺爽，确实快，那么，它到底为什么可以高速处理这么多并发连接呢？
建立一个epoll对象。参数size是内核保证能够正确处理的最大句柄数，多于这个最大数时内核可不保证效果。
可以操作上面建立的epoll，例如，将刚建立的socket加入到epoll中让其监控，或者把&epoll正在监控的某个socket句柄移出epoll，不再监控它等等。
在调用时，在给定的timeout时间内，当在监控的所有句柄中有事件发生时，就返回用户态的进程。
比select/poll的优越之处：因为后者每次调用时都要传递你所要监控的所有socket给select/poll系统调用，这意味着需要将用户态的socket列表copy到内核态，如果以万计的句柄会导致每次都要copy几十几百KB的内存到内核态，非常低效。而我们调用epoll_wait时就相当于以往调用select/poll，但是这时却不用传递socket句柄给内核，因为内核已经在epoll_ctl中拿到了要监控的句柄列表。
后，内核就已经在内核态开始准备帮你存储要监控的句柄了，每次调用epoll_ctl只是在往内核的数据结构里塞入新的socket句柄。
当epoll_wait调用时，仅仅观察这个list链表里有没有数据即eptime项即可。有数据就返回，没有数据就sleep，等到timeout时间到后即使链表没数据也返回。所以，epoll_wait非常高效。
仅需要从内核态copy少量的句柄到用户态而已，如何能不高效？！
链表是怎么维护的呢？当我们执行epoll_ctl时，除了把socket放到epoll文件系统里file对象对应的红黑树上之外，还会给内核中断处理程序注册一个回调函数，告诉内核，如果这个句柄的中断到了，就把它放到准备就绪list链表里。所以，当一个socket上有数据到了，内核在把网卡上的数据copy到内核中后就来把socket插入到准备就绪链表里了。
，就帮我们解决了大并发下的socket处理问题。执行epoll_create时，创建了红黑树和就绪链表，执行epoll_ctl时，如果增加socket句柄，则检查在红黑树中是否存在，存在立即返回，不存在则添加到树干上，然后向内核注册回调函数，用于当中断事件来临时向准备就绪链表中插入数据。执行epoll_wait时立刻返回准备就绪链表里的数据即可。
epoll的使用方法
那么究竟如何来使用呢？其实非常简单。
通过在包含一个头文件以及几个简单的将可以大大的提高你的网络服务器的支持人数。
首先通过来创建一个的句柄。这个函数会返回一个新的句柄，之后的所有操作将通过这个句柄来进行操作。在用完之后，记得用来关闭这个创建出来的句柄。
之后在你的网络主循环里面，每一帧的调用来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为：
其中为用创建之后的句柄，是一个的指针，当这个函数操作成功之后，里面将储存所有的读写事件。是当前需要监听的所有句柄数。最后一个是的超时，为的时候表示马上返回，为的时候表示一直等下去，直到有事件返回，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则返回。一般如果网络主循环是单独的线程的话，可以用来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用来保证主循环的效率。
返回之后应该是一个循环，遍历所有的事件。
几乎所有的程序都使用下面的框架：
epoll的程序实例
参考资料：
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：25251次
排名：千里之外
原创：33篇
转载：28篇
https://git.oschina.net/superlike
(1)(2)(1)(3)(3)(3)(11)(3)(2)(1)(4)(16)(1)(9)(1)17980人阅读
C++编程（37）
linux 网络编程（5）
处理大并发之二
对的理解，客户端服务端代码
该博客是一系列的博客，首先从最基础的epoll说起，然后研究libevent源码及使用方法，最后研究nginx和node.js，关于select,poll这里不做说明，只说明其相对于epoll的不足，其实select和poll我也没用过，因为我选择了epoll。
说起epoll，做过大并发的估计都不陌生，之前做了个STB的工具，用的就是epoll处理并发，测试1.5W的并发（非简单的发消息，包括多个服务端和客户端的处理）是通过的，epoll的功能强大，让我有一定的体会，在nginx和node.js中利用的就是libevent，而libevent使用的就是epoll，如果系统不支持epoll，会选择最佳的方式(select,poll或kqueue中的一种)。
基础资料：
epoll名词解释：
看下百科名片是怎么解释epoll的吧，（）epoll是Linux内核为处理大批量句柄而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著减少程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。
关于具体的说明可以参考网上资料，我这里罗列下epoll相对于其他多路复用机制（select,poll）的优点吧：
epoll优点：
1.&支持一个进程打开大数目的socket描述符。
2.&IO效率不随FD数目增加而线性下降，传统的select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。
3.&使用mmap加速内核与用户空间的消息传递。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。
select和poll的缺点：
1.&每次调用时要重复地从用户态读入参数。
2.&每次调用时要重复地扫描文件描述符。
3.&每次在调用开始时，要把当前进程放入各个文件描述符的等待队列。在调用结束后,又把进程从各个等待队列中删除。
分析的时候，发现一个博客介绍的不错，网址是：
epoll用的的数据结构和函数
typedef&union&epoll_data&{&
&&&&&&&&&&&&&&&&void&*&
&&&&&&&&&&&&&&&&int&&
&&&&&&&&&&&&&&&&__uint32_t&u32;&
&&&&&&&&&&&&&&&&__uint64_t&u64;&
&&&&&&&&}&epoll_data_t;&
&&&&&&&&struct&epoll_event&{&
&&&&&&&&&&&&&&&&__uint32_t&&&&&&&/*&epoll&events&*/&
&&&&&&&&&&&&&&&&epoll_data_t&&&&&&&/*&user&data&variable&*/&
&&&&&&&&};&
结构体epoll_event&被用于注册所感兴趣的事件和回传所发生待处理的事件.&
其中epoll_data&联合体用来保存触发事件的某个文件描述符相关的数据.&
例如一个client连接到服务器，服务器通过调用accept函数可以得到于这个client对应的socket文件描述符，可以把这文件描述符赋给epoll_data的fd字段以便后面的读写操作在这个文件描述符上进行。epoll_event&结构体的events字段是表示感兴趣的事件和被触发的事件可能的取值为：&
EPOLLIN&：表示对应的文件描述符可以读；&
EPOLLOUT：表示对应的文件描述符可以写；&
EPOLLPRI：表示对应的文件描述符有紧急的数据可读&
EPOLLERR：表示对应的文件描述符发生错误；&
EPOLLHUP：表示对应的文件描述符被挂断；&
EPOLLET：表示对应的文件描述符有事件发生；&
ET和LT模式
LT(level&triggered)是缺省的工作方式，并且同时支持block和no-block&socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。
ET&(edge-triggered)是高速工作方式，只支持no-block&socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了（比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK&错误）。但是请注意，如果一直不对这个fd作IO操作（从而导致它再次变成未就绪），内核不会发送更多的通知(only&once)，不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。
ET和LT的区别在于LT事件不会丢弃，而是只要读buffer里面有数据可以让用户读，则不断的通知你。而ET则只在事件发生之时通知。可以简单理解为LT是水平触发，而ET则为边缘触发。
ET模式仅当状态发生变化的时候才获得通知这里所谓的状态的变化并不包括缓冲区中还有未处理的数据也就是说如果要采用模式需要一直直到出错为止很多人反映为什么采用模式只接收了一部分数据就再也得不到通知了大多因为这样而模式是只要有数据没有处理就会一直通知下去的
1. int epoll_create(int size);
2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
3. int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
1.&int&epoll_create(int&size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
2.&int&epoll_ctl(int&epfd,&int&op,&int&fd,&struct&epoll_event&*event);
epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事
3.&int&epoll_wait(int&epfd,&struct&epoll_event&*events,int&maxevents,&int&timeout);
等待事件的产生，参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个&maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。
资料总结这么多，其实都是一些理论，关键还在于代码，下面附上我使用开发的服务端和客户端，该代码我会上传到我的资源里，可以免费下载。链接：
如果代码有可以告诉我。
首先对服务端和客户端做下说明：
我想实现的是客户端和服务端并发的程序，客户端通过配置并发数，说明有多少个用户去连接服务端。
客户端会发送消息：&Client:&i&send&message&Hello&Server!”，其中表示哪一个客户端；收到消息：&Recv&Server&Msg&Content:%s\n&。
发送：Client:&1&send&message&&Hello&Server!&
接收：Recv&Derver&Msg&Content:Hello,&client&fd:&6
服务端收到后给客户端回复消息：&Hello,&client&fd:&i&，其中表示服务端接收的用户区别是哪一个客户端。接收客户端消息：&Terminal&Received&Msg&Content:%s\n&
发送：Hello,&client&fd:&6
接收：Terminal&Received&Msg&Content:Client:&1&send&message&&Hello&Server!&
备注：这里在接收到消息后，直接打印出消息，如果需要对消息进行处理（如果消息处理比较占用时间，不能立即返回，可以将该消息放入一个队列中，然后开启一个线程从队列中取消息进行处理，这样的话不会因为消息处理而阻塞）。好像对这种有中处理方式，一个就是回调，要求回调函数，不占用太多的时间，基本能立即返回，另一种好像也是一个队列实现的，这个还需要研究。
服务端代码说明：
服务端在绑定监听后，开启了一个线程，用于负责接收客户端连接，加入到中，这样只要accept到客户端的连接，就将其&EPOLLIN到中，然后进入循环调用epoll_wait，监听到读事件，接收数据，并将事件修改为EPOLLOUT；反之监听到写事件，发送数据，并将事件修改为EPOLLIN。
cepollserver.h
C_EPOLL_SERVER_H
C_EPOLL_SERVER_H
#include &sys/epoll.h&
#include &sys/socket.h&
#include &netinet/in.h&
#include &fcntl.h&
#include &arpa/inet.h&
#include &stdio.h&
#include &stdlib.h&
#include &iostream&
#include &pthread.h&
#define _MAX_SOCKFD_COUNT 65535
class CEpollServer
CEpollServer();
~CEpollServer();
bool InitServer(const char* chIp, int iPort);
void Listen();
static void ListenThread( void* lpVoid );
void Run();
m_iEpollFd;
m_ListenThreadId;// 监听线程句柄
cepollserver.cpp
#include &cepollserver.h&
CEpollServer::CEpollServer()
CEpollServer::~CEpollServer()
close(m_isock);
bool CEpollServer::InitServer(const char* pIp, int iPort)
m_iEpollFd = epoll_create(_MAX_SOCKFD_COUNT);
//设置非阻塞模式
int opts = O_NONBLOCK;
if(fcntl(m_iEpollFd,F_SETFL,opts)&0)
printf(&设置非阻塞模式失败!\n&);
m_isock = socket(AF_INET,SOCK_STREAM,0);
if ( 0 & m_isock )
printf(&socket error!\n&);
　　sockaddr_in listen_
listen_addr.sin_family=AF_INET;
listen_addr.sin_port=htons ( iPort );
listen_addr.sin_addr.s_addr=htonl(INADDR_ANY);
listen_addr.sin_addr.s_addr=inet_addr(pIp);
int ireuseadd_on = 1;//支持端口复用
setsockopt(m_isock, SOL_SOCKET, SO_REUSEADDR, &ireuseadd_on, sizeof(ireuseadd_on) );
if ( bind ( m_isock, ( sockaddr * ) &listen_addr,sizeof ( listen_addr ) ) !=0 )
printf(&bind error\n&);
if ( listen ( m_isock, 20) &0 )
printf(&listen error!\n&);
printf(&服务端监听中...\n&);
// 监听线程，此线程负责接收客户端连接，加入到epoll中
if ( pthread_create( &m_ListenThreadId, 0, ( void * ( * ) ( void * ) ) ListenThread, this ) != 0 )
printf(&Server 监听线程创建失败!!!&);
　　// 监听线程
　　void CEpollServer::ListenThread( void* lpVoid )
CEpollServer *pTerminalServer = (CEpollServer*)lpV
sockaddr_in remote_
int len = sizeof (remote_addr);
while ( true )
int client_socket = accept (pTerminalServer-&m_isock, ( sockaddr * ) &remote_addr,(socklen_t*)&len );
if ( client_socket & 0 )
printf(&Server Accept失败!, client_socket: %d\n&, client_socket);
struct epoll_
ev.events = EPOLLIN | EPOLLERR | EPOLLHUP;
ev.data.fd = client_
//记录socket句柄
epoll_ctl(pTerminalServer-&m_iEpollFd, EPOLL_CTL_ADD, client_socket, &ev);
　　void CEpollServer::Run()
while ( true )
struct epoll_event
events[_MAX_SOCKFD_COUNT];
int nfds = epoll_wait( m_iEpollFd, events,
_MAX_SOCKFD_COUNT, -1 );
for (int i = 0; i & i++)
int client_socket = events[i].data.
char buffer[1024];//每次收发的字节数小于1024字节
memset(buffer, 0, 1024);
if (events[i].events & EPOLLIN)//监听到读事件，接收数据
int rev_size = recv(events[i].data.fd,buffer, 1024,0);
if( rev_size &= 0 )
cout && &recv error: recv size: & && rev_size &&
struct epoll_event event_
event_del.data.fd = events[i].data.
event_del.events = 0;
epoll_ctl(m_iEpollFd, EPOLL_CTL_DEL, event_del.data.fd, &event_del);
printf(&Terminal Received Msg Content:%s\n&,buffer);
struct epoll_
ev.events = EPOLLOUT | EPOLLERR | EPOLLHUP;
ev.data.fd = client_
//记录socket句柄
epoll_ctl(m_iEpollFd, EPOLL_CTL_MOD, client_socket, &ev);
　　else if(events[i].events & EPOLLOUT)//监听到写事件，发送数据
char sendbuff[1024];
sprintf(sendbuff, &Hello, client fd: %d\n&, client_socket);
int sendsize = send(client_socket, sendbuff, strlen(sendbuff)+1, MSG_NOSIGNAL);
if(sendsize &= 0)
struct epoll_event event_
event_del.data.fd = events[i].data.
event_del.events = 0;
epoll_ctl(m_iEpollFd, EPOLL_CTL_DEL, event_del.data.fd, &event_del);
printf(&Server reply msg ok! buffer: %s\n&, sendbuff);
struct epoll_
ev.events = EPOLLIN | EPOLLERR | EPOLLHUP;
ev.data.fd = client_
//记录socket句柄
epoll_ctl(m_iEpollFd, EPOLL_CTL_MOD, client_socket, &ev);
cout && &EPOLL ERROR\n& &&
epoll_ctl(m_iEpollFd, EPOLL_CTL_DEL, events[i].data.fd, &events[i]);
#include &iostream&
#include &cepollserver.h&
int main()
CEpollServer
theApp.InitServer(&127.0.0.1&, 8000);
theApp.Run();
客户端代码：
说明：测试是两个并发进行测试，每一个客户端都是一个长连接。代码中在连接服务器（ConnectToServer）时将用户和关联起来。用户和是一一对应的关系。
cepollclient.h
#ifndef _DEFINE_EPOLLCLIENT_H_
#define _DEFINE_EPOLLCLIENT_H_
#define _MAX_SOCKFD_COUNT 65535
#include&iostream&
#include &sys/epoll.h&
#include &sys/socket.h&
#include &netinet/in.h&
#include &fcntl.h&
#include &arpa/inet.h&
#include &errno.h&
#include &sys/ioctl.h&
#include &sys/time.h&
#include &string&
* @brief 用户状态
typedef enum _EPOLL_USER_STATUS_EM
CONNECT_OK = 1,//连接成功
SEND_OK = 2,//发送成功
RECV_OK = 3,//接收成功
}EPOLL_USER_STATUS_EM;
*@CEpollClient class 用户状态结构体
struct UserStatus
EPOLL_USER_STATUS_EM iUserS//用户状态
int iSockFd;//用户状态关联的socketfd
char cSendbuff[1024];//发送的数据内容
int iBuffL//发送数据内容的长度
unsigned int uEpollE//Epoll events
class CEpollClient
* 函数名:CEpollClient
* 描述:构造函数
* @param [in] iUserCount
* @param [in] pIP IP地址
* @param [in] iPort 端口号
* @return 无返回
CEpollClient(int iUserCount, const char* pIP, int iPort);
* 函数名:CEpollClient
* 描述:析构函数
* @return 无返回
~CEpollClient();
* 函数名:RunFun
* 描述:对外提供的接口，运行epoll类
* @return 无返回值
int RunFun();
* 函数名:ConnectToServer
* 描述:连接到服务器
* @param [in] iUserId 用户ID
* @param [in] pServerIp 连接的服务器IP
* @param [in] uServerPort 连接的服务器端口号
* @return 成功返回socketfd,失败返回的socketfd为-1
int ConnectToServer(int iUserId,const char *pServerIp,unsigned short uServerPort);
* 函数名:SendToServerData
* 描述:给服务器发送用户(iUserId)的数据
* @param [in] iUserId 用户ID
* @return 成功返回发送数据长度
int SendToServerData(int iUserId);
* 函数名:RecvFromServer
* 描述:接收用户回复消息
* @param [in] iUserId 用户ID
* @param [in] pRecvBuff 接收的数据内容
* @param [in] iBuffLen 接收的数据长度
* @return 成功返回接收的数据长度，失败返回长度为-1
int RecvFromServer(int iUserid,char *pRecvBuff,int iBuffLen);
* 函数名:CloseUser
* 描述:关闭用户
* @param [in] iUserId 用户ID
* @return 成功返回true
bool CloseUser(int iUserId);
* 函数名:DelEpoll
* 描述:删除epoll事件
* @param [in] iSockFd socket FD
* @return 成功返回true
bool DelEpoll(int iSockFd);
m_iUserC//用户数量；
struct UserStatus *m_pAllUserS//用户状态数组
m_iEpollFd;//需要创建epollfd
m_iSockFd_UserId[_MAX_SOCKFD_COUNT];//将用户ID和socketid关联起来
m_iP//端口号
m_ip[100];//IP地址
cepollclient.cpp
#include &cepollclient.h&
CEpollClient::CEpollClient(int iUserCount, const char* pIP, int iPort)
strcpy(m_ip, pIP);
m_iPort = iP
m_iUserCount = iUserC
m_iEpollFd = epoll_create(_MAX_SOCKFD_COUNT);
m_pAllUserStatus = (struct UserStatus*)malloc(iUserCount*sizeof(struct UserStatus));
for(int iuserid=0; iuserid&iUserC iuserid++)
m_pAllUserStatus[iuserid].iUserStatus = FREE;
sprintf(m_pAllUserStatus[iuserid].cSendbuff, &Client: %d send message \&Hello Server!\&\r\n&, iuserid);
m_pAllUserStatus[iuserid].iBuffLen = strlen(m_pAllUserStatus[iuserid].cSendbuff) + 1;
m_pAllUserStatus[iuserid].iSockFd = -1;
memset(m_iSockFd_UserId, 0xFF, sizeof(m_iSockFd_UserId));
CEpollClient::~CEpollClient()
free(m_pAllUserStatus);
int CEpollClient::ConnectToServer(int iUserId,const char *pServerIp,unsigned short uServerPort)
if( (m_pAllUserStatus[iUserId].iSockFd = socket(AF_INET,SOCK_STREAM,0) ) & 0 )
cout &&&[CEpollClient error]: init socket fail, reason is:&&&strerror(errno)&&&,errno is:&&&errno&&
m_pAllUserStatus[iUserId].iSockFd = -1;
m_pAllUserStatus[iUserId].iSockFd;
struct sockaddr_
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(uServerPort);
addr.sin_addr.s_addr = inet_addr(pServerIp);
int ireuseadd_on = 1;//支持端口复用
setsockopt(m_pAllUserStatus[iUserId].iSockFd, SOL_SOCKET, SO_REUSEADDR, &ireuseadd_on, sizeof(ireuseadd_on));
unsigned long ul = 1;
ioctl(m_pAllUserStatus[iUserId].iSockFd, FIONBIO, &ul); //设置为非阻塞模式
connect(m_pAllUserStatus[iUserId].iSockFd, (const sockaddr*)&addr, sizeof(addr));
m_pAllUserStatus[iUserId].iUserStatus = CONNECT_OK;
m_pAllUserStatus[iUserId].iSockFd = m_pAllUserStatus[iUserId].iSockFd;
return m_pAllUserStatus[iUserId].iSockFd;
int CEpollClient::SendToServerData(int iUserId)
sleep(1);//此处控制发送频率，避免狂打日志，正常使用中需要去掉
int isendsize = -1;
if( CONNECT_OK == m_pAllUserStatus[iUserId].iUserStatus || RECV_OK == m_pAllUserStatus[iUserId].iUserStatus)
isendsize = send(m_pAllUserStatus[iUserId].iSockFd, m_pAllUserStatus[iUserId].cSendbuff, m_pAllUserStatus[iUserId
].iBuffLen, MSG_NOSIGNAL);
if(isendsize & 0)
cout &&&[CEpollClient error]: SendToServerData, send fail, reason is:&&&strerror(errno)&&&,errno is:&&&errno&
printf(&[CEpollClient info]: iUserId: %d Send Msg Content:%s\n&, iUserId, m_pAllUserStatus[iUserId].cSendbuff
m_pAllUserStatus[iUserId].iUserStatus = SEND_OK;
int CEpollClient::RecvFromServer(int iUserId,char *pRecvBuff,int iBuffLen)
int irecvsize = -1;
if(SEND_OK == m_pAllUserStatus[iUserId].iUserStatus)
irecvsize = recv(m_pAllUserStatus[iUserId].iSockFd, pRecvBuff, iBuffLen, 0);
if(0 & irecvsize)
cout &&&[CEpollClient error]: iUserId: & && iUserId && &RecvFromServer, recv fail, reason is:&&&strerror(errn
o)&&&,errno is:&&&errno&&
else if(0 == irecvsize)
cout &&&[warning:] iUserId: &&& iUserId && &RecvFromServer, STB收到数据为0，表示对方断开连接,irecvsize:&&&ire
cvsize&&&,iSockFd:&&& m_pAllUserStatus[iUserId].iSockFd &&
printf(&Recv Server Msg Content:%s\n&, pRecvBuff);
m_pAllUserStatus[iUserId].iUserStatus = RECV_OK;
bool CEpollClient::CloseUser(int iUserId)
close(m_pAllUserStatus[iUserId].iSockFd);
m_pAllUserStatus[iUserId].iUserStatus = FREE;
m_pAllUserStatus[iUserId].iSockFd = -1;
int CEpollClient::RunFun()
int isocketfd = -1;
for(int iuserid=0; iuserid&m_iUserC iuserid++)
struct epoll_
isocketfd = ConnectToServer(iuserid, m_ip, m_iPort);
if(isocketfd & 0)
cout &&&[CEpollClient error]: RunFun, connect fail& &&
m_iSockFd_UserId[isocketfd] =//将用户ID和socketid关联起来
event.data.fd =
event.events = EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP;
m_pAllUserStatus[iuserid].uEpollEvents = event.
epoll_ctl(m_iEpollFd, EPOLL_CTL_ADD, event.data.fd, &event);
　　while(1)
struct epoll_event events[_MAX_SOCKFD_COUNT];
char buffer[1024];
memset(buffer,0,1024);
int nfds = epoll_wait(m_iEpollFd, events, _MAX_SOCKFD_COUNT, 100 );//等待epoll事件的产生
for (int ifd=0; ifd& ifd++)//处理所发生的所有事件
struct epoll_event event_
int iclientsockfd = events[ifd].data.
cout && &events[ifd].data.fd: & && events[ifd].data.fd &&
int iuserid = m_iSockFd_UserId[iclientsockfd];//根据socketfd得到用户ID
if( events[ifd].events & EPOLLOUT )
int iret = SendToServerData(iuserid);
if( 0 & iret )
event_nfds.events = EPOLLIN|EPOLLERR|EPOLLHUP;
event_nfds.data.fd =
epoll_ctl(m_iEpollFd, EPOLL_CTL_MOD, event_nfds.data.fd, &event_nfds);
cout &&&[CEpollClient error:] EpollWait, SendToServerData fail, send iret:&&&iret&&&,iuserid:&&&iuser
　　id&&&,fd:&&&events[ifd].data.fd&&
DelEpoll(events[ifd].data.fd);
CloseUser(iuserid);
　　else if( events[ifd].events & EPOLLIN )//监听到读事件，接收数据
int ilen = RecvFromServer(iuserid, buffer, 1024);
if(0 & ilen)
cout &&&[CEpollClient error]: RunFun, recv fail, reason is:&&&strerror(errno)&&&,errno is:&&&errno&&e
DelEpoll(events[ifd].data.fd);
CloseUser(iuserid);
else if(0 == ilen)
cout &&&[CEpollClient warning:] server disconnect,ilen:&&&ilen&&&,iuserid:&&&iuserid&&&,fd:&&&events[
　　ifd].data.fd&&
DelEpoll(events[ifd].data.fd);
CloseUser(iuserid);
m_iSockFd_UserId[iclientsockfd] =//将socketfd和用户ID关联起来
event_nfds.data.fd =
event_nfds.events = EPOLLOUT|EPOLLERR|EPOLLHUP;
epoll_ctl(m_iEpollFd, EPOLL_CTL_MOD, event_nfds.data.fd, &event_nfds);
cout &&&[CEpollClient error:] other epoll error&&&
DelEpoll(events[ifd].data.fd);
CloseUser(iuserid);
　　bool CEpollClient::DelEpoll(int iSockFd)
bool bret =
struct epoll_event event_
if(0 & iSockFd)
event_del.data.fd = iSockFd;
event_del.events = 0;
if( 0 == epoll_ctl(m_iEpollFd, EPOLL_CTL_DEL, event_del.data.fd, &event_del) )
cout &&&[SimulateStb error:] DelEpoll,epoll_ctl error,iSockFd:&&&iSockFd&&
m_iSockFd_UserId[iSockFd] = -1;
　　#include &cepollclient.h&
　　int main(int argc, char *argv[])
CEpollClient *pCEpollClient = new CEpollClient(2, &127.0.0.1&, 8000);
if(NULL == pCEpollClient)
cout&&&[epollclient error]:main init&&&&Init CEpollClient fail&&&
pCEpollClient-&RunFun();
if(NULL != pCEpollClient)
delete pCEpollC
pCEpollClient = NULL;
运行结果：
如是转载，请指明原出处：，谢谢合作！
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：356483次
积分：3978
积分：3978
排名：第6256名
原创：72篇
评论：328条
(3)(2)(2)(1)(1)(10)(2)(1)(1)(4)(1)(19)(20)(7)}