服务器 libevent中epoll使用实例demo

简介: 名词解释:man epoll之后,得到如下结果: NAME       epoll - I/O event notification facility SYNOPSIS       #include DESCRIPTION       epoll is a variant of poll(2...

名词解释:man epoll之后,得到如下结果:

NAME
       epoll - I/O event notification facility

SYNOPSIS
       #include <sys/epoll.h>

DESCRIPTION
       epoll is a variant of poll(2) that can be used either as Edge or Level
       Triggered interface and scales well to large numbers of  watched  fds.
       Three  system  calls  are provided to set up and control an epoll set:
       epoll_create(2), epoll_ctl(2), epoll_wait(2).

       An epoll set is connected to a file descriptor created  by  epoll_cre-
       ate(2).   Interest for certain file descriptors is then registered via
       epoll_ctl(2).  Finally, the actual wait is started by epoll_wait(2).

其实,一切的解释都是多余的,按照我目前的了解,EPOLL模型似乎只有一种格式,所以大家只要参考我下面的代码,就能够对EPOLL有所了解了,代码的解释都已经在注释中:

while (TRUE)
 {
  int nfds = epoll_wait (m_epoll_fd, m_events, MAX_EVENTS, EPOLL_TIME_OUT);//等待EPOLL时间的发生,相当于监听,至于相关的端口,需要在初始化EPOLL的时候绑定。
  if (nfds <= 0)
   continue;
  m_bOnTimeChecking = FALSE;
  G_CurTime = time(NULL);
  for (int i=0; i<nfds; i++)
  {
   try
   {
    if (m_events[i].data.fd == m_listen_http_fd)//如果新监测到一个HTTP用户连接到绑定的HTTP端口,建立新的连接。由于我们新采用了SOCKET连接,所以基本没用。
    {
     OnAcceptHttpEpoll ();
    }
    else if (m_events[i].data.fd == m_listen_sock_fd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口,建立新的连接。
    {
     OnAcceptSockEpoll ();
    }
    else if (m_events[i].events & EPOLLIN)//如果是已经连接的用户,并且收到数据,那么进行读入。
    {
     OnReadEpoll (i);
    }

    OnWriteEpoll (i);//查看当前的活动连接是否有需要写出的数据。
   }
   catch (int)
   {
    PRINTF ("CATCH捕获错误/n");
    continue;
   }
  }
  m_bOnTimeChecking = TRUE;
  OnTimer ();//进行一些定时的操作,主要就是删除一些短线用户等。
 }

 其实EPOLL的精华,按照我目前的理解,也就是上述的几段短短的代码,看来时代真的不同了,以前如何接受大量用户连接的问题,现在却被如此轻松的搞定,真是让人不得不感叹。

今天搞了一天的epoll,想做一个高并发的代理程序。刚开始真是郁闷,一直搞不通,网上也有几篇介绍epoll的文章。但都不深入,没有将一些注意的地方讲明。以至于走了很多弯路,现将自己的一些理解共享给大家,以少走弯路。 

epoll用到的所有函数都是在头文件sys/epoll.h中声明,有什么地方不明白或函数忘记了可以去看一下。 
epoll和select相比,最大不同在于: 

1epoll返回时已经明确的知道哪个sokcet fd发生了事件,不用再一个个比对。这样就提高了效率。 
2select的FD_SETSIZE是有限止的,而epoll是没有限止的只与系统资源有关。 

1、epoll_create函数
函数声明:int epoll_create(int size)
该函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间,用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个epoll fd上能关注的最大socket fd数。随你定好了。只要你有空间。可参见上面与select之不同2. 

22、epoll_ctl函数 
函数声明:int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) 
该函数用于控制某个epoll文件描述符上的事件,可以注册事件,修改事件,删除事件。 
参数: 
epfd:由 epoll_create 生成的epoll专用的文件描述符; 
op:要进行的操作例如注册事件,可能的取值EPOLL_CTL_ADD 注册、EPOLL_CTL_MOD 修 改、EPOLL_CTL_DEL 删除 

fd:关联的文件描述符; 
event:指向epoll_event的指针; 
如果调用成功返回0,不成功返回-1 

用到的数据结构 
typedef union epoll_data { 
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t; 

struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};


如: 
struct epoll_event ev;
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);


常用的事件类型:
EPOLLIN :表示对应的文件描述符可以读;
EPOLLOUT:表示对应的文件描述符可以写;
EPOLLPRI:表示对应的文件描述符有紧急的数据可读
EPOLLERR:表示对应的文件描述符发生错误;
EPOLLHUP:表示对应的文件描述符被挂断;
EPOLLET:表示对应的文件描述符有事件发生;


3、epoll_wait函数
函数声明:int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)
该函数用于轮询I/O事件的发生;
参数:
epfd:由epoll_create 生成的epoll专用的文件描述符;
epoll_event:用于回传代处理事件的数组;
maxevents:每次能处理的事件数;
timeout:等待I/O事件发生的超时值(单位我也不太清楚);-1相当于阻塞,0相当于非阻塞。一般用-1即可
返回发生事件数。

 

 

 

 

[java]  view plain copy
 
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <errno.h>  
  4. #include <string.h>  
  5. #include <sys/types.h>  
  6. #include <netinet/in.h>  
  7. #include <sys/socket.h>  
  8. #include <sys/wait.h>  
  9. #include <unistd.h>  
  10. #include <arpa/inet.h>  
  11. #include <openssl/ssl.h>  
  12. #include <openssl/err.h>  
  13. #include <fcntl.h>  
  14. #include <sys/epoll.h>  
  15. #include <sys/time.h>  
  16. #include <sys/resource.h>  
[java]  view plain copy
 
  1. #define MAXBUF 1024  
  2. #define MAXEPOLLSIZE 10000  
[java]  view plain copy
 
  1. /* 
  2. setnonblocking - 设置句柄为非阻塞方式 
  3. */  
  4. int setnonblocking(int sockfd)  
  5. {  
  6.     if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)  
  7.  {  
  8.         return -1;  
  9.     }  
  10.     return 0;  
  11. }  
[java]  view plain copy
 
  1. /* 
  2. handle_message - 处理每个 socket 上的消息收发 
  3. */  
  4. int handle_message(int new_fd)  
  5. {  
  6.     char buf[MAXBUF + 1];  
  7.     int len;  
  8.       
  9.  /* 开始处理每个新连接上的数据收发 */  
  10.     bzero(buf, MAXBUF + 1);  
  11.      
  12.  /* 接收客户端的消息 */  
  13.     len = recv(new_fd, buf, MAXBUF, 0);  
  14.     if (len > 0)  
  15.  {  
  16.         printf  
  17.             ("%d接收消息成功:'%s',共%d个字节的数据/n",  
  18.              new_fd, buf, len);  
  19.  }  
  20.     else  
  21.  {  
  22.         if (len < 0)  
  23.      printf  
  24.                 ("消息接收失败!错误代码是%d,错误信息是'%s'/n",  
  25.                  errno, strerror(errno));  
  26.         close(new_fd);  
  27.         return -1;  
  28.     }  
  29.     /* 处理每个新连接上的数据收发结束 */  
  30.     return len;  
  31. }  
  32. /************关于本文档******************************************** 
  33. *filename: epoll-server.c 
  34. *purpose: 演示epoll处理海量socket连接的方法 
  35. *wrote by: zhoulifa(<a href="mailto:zhoulifa@163.com">zhoulifa@163.com</a>) 周立发(<a href="http://zhoulifa.bokee.com">http://zhoulifa.bokee.com</a>) 
  36. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
  37. *date time:2007-01-31 21:00 
  38. *Note: 任何人可以任意复制代码并运用这些文档,当然包括你的商业用途 
  39. * 但请遵循GPL 
  40. *Thanks to:Google 
  41. *Hope:希望越来越多的人贡献自己的力量,为科学技术发展出力 
  42. * 科技站在巨人的肩膀上进步更快!感谢有开源前辈的贡献! 
  43. *********************************************************************/  
  44. int main(int argc, char **argv)  
  45. {  
  46.     int listener, new_fd, kdpfd, nfds, n, ret, curfds;  
  47.     socklen_t len;  
  48.     struct sockaddr_in my_addr, their_addr;  
  49.     unsigned int myport, lisnum;  
  50.     struct epoll_event ev;  
  51.     struct epoll_event events[MAXEPOLLSIZE];  
  52.     struct rlimit rt;  
  53.  myport = 5000;  
  54.  lisnum = 2;   
  55.       
  56.  /* 设置每个进程允许打开的最大文件数 */  
  57.     rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;  
  58.     if (setrlimit(RLIMIT_NOFILE, &rt) == -1)   
  59.  {  
  60.         perror("setrlimit");  
  61.         exit(1);  
  62.     }  
  63.     else   
  64.     {  
  65.         printf("设置系统资源参数成功!/n");  
  66.     }  
[java]  view plain copy
 
  1.     /* 开启 socket 监听 */  
  2.     if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1)  
  3.     {  
  4.         perror("socket");  
  5.         exit(1);  
  6.     }  
  7.     else  
  8.     {  
  9.         printf("socket 创建成功!/n");  
  10.  }  
  11.    
  12.     setnonblocking(listener);  
[java]  view plain copy
 
  1.     bzero(&my_addr, sizeof(my_addr));  
  2.     my_addr.sin_family = PF_INET;  
  3.     my_addr.sin_port = htons(myport);  
  4.     my_addr.sin_addr.s_addr = INADDR_ANY;  
[java]  view plain copy
 
  1.     if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)   
  2.     {  
  3.         perror("bind");  
  4.         exit(1);  
  5.     }   
  6.     else  
  7.     {  
  8.         printf("IP 地址和端口绑定成功/n");  
  9.  }  
  10.     if (listen(listener, lisnum) == -1)   
  11.     {  
  12.         perror("listen");  
  13.         exit(1);  
  14.     }  
  15.     else  
  16.     {  
  17.         printf("开启服务成功!/n");  
  18.  }  
  19.       
  20.  /* 创建 epoll 句柄,把监听 socket 加入到 epoll 集合里 */  
  21.     kdpfd = epoll_create(MAXEPOLLSIZE);  
  22.     len = sizeof(struct sockaddr_in);  
  23.     ev.events = EPOLLIN | EPOLLET;  
  24.     ev.data.fd = listener;  
  25.     if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0)   
  26.  {  
  27.         fprintf(stderr, "epoll set insertion error: fd=%d/n", listener);  
  28.         return -1;  
  29.     }  
  30.  else  
  31.     {  
  32.   printf("监听 socket 加入 epoll 成功!/n");  
  33.  }  
  34.     curfds = 1;  
  35.     while (1)   
  36.  {  
  37.         /* 等待有事件发生 */  
  38.         nfds = epoll_wait(kdpfd, events, curfds, -1);  
  39.         if (nfds == -1)  
  40.   {  
  41.             perror("epoll_wait");  
  42.             break;  
  43.         }  
  44.         /* 处理所有事件 */  
  45.         for (n = 0; n < nfds; ++n)  
  46.   {  
  47.             if (events[n].data.fd == listener)   
  48.    {  
  49.                 new_fd = accept(listener, (struct sockaddr *) &their_addr,&len);  
  50.                 if (new_fd < 0)   
  51.     {  
  52.                     perror("accept");  
  53.                     continue;  
  54.                 }   
  55.     else  
  56.     {  
  57.      printf("有连接来自于: %d:%d, 分配的 socket 为:%d/n",  
  58.                              inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);  
  59.     }  
  60.                 setnonblocking(new_fd);  
  61.                 ev.events = EPOLLIN | EPOLLET;  
  62.                 ev.data.fd = new_fd;  
  63.                 if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0)  
  64.     {  
  65.                     fprintf(stderr, "把 socket '%d' 加入 epoll 失败!%s/n",  
  66.                             new_fd, strerror(errno));  
  67.                     return -1;  
  68.                 }  
  69.                 curfds++;  
  70.             }   
  71.    else  
  72.    {  
  73.                 ret = handle_message(events[n].data.fd);  
  74.                 if (ret < 1 && errno != 11)  
  75.     {  
  76.                     epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,&ev);  
  77.                     curfds--;  
  78.                 }  
  79.             }  
  80.         }  
  81.     }  
  82.     close(listener);  
  83.     return 0;  
  84. }  

 epoll_wait运行的原理是 等侍注册在epfd上的socket fd的事件的发生,如果发生则将发生的sokct fd和事件类型放入到events数组中。 并且将注册在epfd上的socket fd的事件类型给清空,所以如果下一个循环你还要关注这个socket fd的话,则需要用epoll_ctl(epfd,EPOLL_CTL_MOD,listenfd,&ev)来重新设置socket fd的事件类型。这时不用EPOLL_CTL_ADD,因为socket fd并未清空,只是事件类型清空。这一步非常重要。 

 

二、第二个示例:

 

1. Epoll是何方神圣?

Epoll可是当前在Linux下开发大规模并发网络程序的热门人选,Epoll 在Linux2.6内核中正式引入,和select相似,其实都I/O多路复用技术而已,并没有什么神秘的。

其实在Linux下设计并发网络程序,向来不缺少方法,比如典型的Apache模型(Process Per Connection,简称PPC),TPC(Thread PerConnection)模型,以及select模型和poll模型,那为何还要再引入Epoll这个东东呢?那还是有得说说的…

2. 常用模型的缺点

如果不摆出来其他模型的缺点,怎么能对比出Epoll的优点呢。

2.1 PPC/TPC模型

这两种模型思想类似,就是让每一个到来的连接一边自己做事去,别再来烦我。只是PPC是为它开了一个进程,而TPC开了一个线程。可是别烦我是有代价的,它要时间和空间啊,连接多了之后,那么多的进程/线程切换,这开销就上来了;因此这类模型能接受的最大连接数都不会高,一般在几百个左右。

2.2 select模型

1. 最大并发数限制,因为一个进程所打开的FD(文件描述符)是有限制的,由FD_SETSIZE设置,默认值是1024/2048,因此Select模型的最大并发数就被相应限制了。自己改改这个FD_SETSIZE?想法虽好,可是先看看下面吧…

2. 效率问题,select每次调用都会线性扫描全部的FD集合,这样效率就会呈现线性下降,把FD_SETSIZE改大的后果就是,大家都慢慢来,什么?都超时了??!!

3. 内核/用户空间 内存拷贝问题,如何让内核把FD消息通知给用户空间呢?在这个问题上select采取了内存拷贝方法。

2.3 poll模型

基本上效率和select是相同的,select缺点的2和3它都没有改掉。

3. Epoll的提升

把其他模型逐个批判了一下,再来看看Epoll的改进之处吧,其实把select的缺点反过来那就是Epoll的优点了。

3.1. Epoll没有最大并发连接的限制,上限是最大可以打开文件的数目,这个数字一般远大于2048, 一般来说这个数目和系统内存关系很大,具体数目可以cat /proc/sys/fs/file-max察看。

3.2. 效率提升,Epoll最大的优点就在于它只管你“活跃”的连接,而跟连接总数无关,因此在实际的网络环境中,Epoll的效率就会远远高于select和poll。

3.3. 内存拷贝,Epoll在这点上使用了“共享内存”,这个内存拷贝也省略了。

 

 

4. Epoll为什么高效

Epoll的高效和其数据结构的设计是密不可分的,这个下面就会提到。

首先回忆一下select模型,当有I/O事件到来时,select通知应用程序有事件到了快去处理,而应用程序必须轮询所有的FD集合,测试每个FD是否有事件发生,并处理事件;代码像下面这样:

 

int res = select(maxfd+1, &readfds, NULL, NULL, 120);

if(res > 0)

{

    for(int i = 0; i < MAX_CONNECTION; i++)

    {

        if(FD_ISSET(allConnection[i],&readfds))

        {

            handleEvent(allConnection[i]);

        }

    }

}

// if(res == 0) handle timeout, res < 0 handle error

 

Epoll不仅会告诉应用程序有I/0事件到来,还会告诉应用程序相关的信息,这些信息是应用程序填充的,因此根据这些信息应用程序就能直接定位到事件,而不必遍历整个FD集合。

intres = epoll_wait(epfd, events, 20, 120);

for(int i = 0; i < res;i++)

{

    handleEvent(events[n]);

}

5. Epoll关键数据结构

前面提到Epoll速度快和其数据结构密不可分,其关键数据结构就是:

structepoll_event {

    __uint32_t events;      // Epoll events

    epoll_data_t data;      // User datavariable

};

typedef union epoll_data {

    void *ptr;

   int fd;

    __uint32_t u32;

    __uint64_t u64;

} epoll_data_t;

可见epoll_data是一个union结构体,借助于它应用程序可以保存很多类型的信息:fd、指针等等。有了它,应用程序就可以直接定位目标了。

6. 使用Epoll

既然Epoll相比select这么好,那么用起来如何呢?会不会很繁琐啊…先看看下面的三个函数吧,就知道Epoll的易用了。

 

intepoll_create(int size);

生成一个Epoll专用的文件描述符,其实是申请一个内核空间,用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个Epoll fd上能关注的最大socket fd数,大小自定,只要内存足够。

intepoll_ctl(int epfd, intop, int fd, structepoll_event *event);

控制某个Epoll文件描述符上的事件:注册、修改、删除。其中参数epfd是epoll_create()创建Epoll专用的文件描述符。相对于select模型中的FD_SET和FD_CLR宏。

intepoll_wait(int epfd,structepoll_event * events,int maxevents,int timeout);

等待I/O事件的发生;参数说明:

epfd:由epoll_create() 生成的Epoll专用的文件描述符;

epoll_event:用于回传代处理事件的数组;

maxevents:每次能处理的事件数;

timeout:等待I/O事件发生的超时值;

返回发生事件数。

相对于select模型中的select函数。

7. 例子程序

下面是一个简单Echo Server的例子程序,麻雀虽小,五脏俱全,还包含了一个简单的超时检查机制,简洁起见没有做错误处理。

[cpp]  view plain copy
  1. //     
  2. // a simple echo server using epoll in linux    
  3. //     
  4. // 2009-11-05    
  5. // 2013-03-22:修改了几个问题,1是/n格式问题,2是去掉了原代码不小心加上的ET模式;  
  6. // 本来只是简单的示意程序,决定还是加上 recv/send时的buffer偏移  
  7. // by sparkling    
  8. //     
  9. #include <sys/socket.h>    
  10. #include <sys/epoll.h>    
  11. #include <netinet/in.h>    
  12. #include <arpa/inet.h>    
  13. #include <fcntl.h>    
  14. #include <unistd.h>    
  15. #include <stdio.h>    
  16. #include <errno.h>    
  17. #include <iostream>    
  18. using namespace std;    
  19. #define MAX_EVENTS 500    
  20. struct myevent_s    
  21. {    
  22.     int fd;    
  23.     void (*call_back)(int fd, int events, void *arg);    
  24.     int events;    
  25.     void *arg;    
  26.     int status; // 1: in epoll wait list, 0 not in    
  27.     char buff[128]; // recv data buffer    
  28.     int len, s_offset;    
  29.     long last_active; // last active time    
  30. };    
  31. // set event    
  32. void EventSet(myevent_s *ev, int fd, void (*call_back)(int, int, void*), void *arg)    
  33. {    
  34.     ev->fd = fd;    
  35.     ev->call_back = call_back;    
  36.     ev->events = 0;    
  37.     ev->arg = arg;    
  38.     ev->status = 0;  
  39.     bzero(ev->buff, sizeof(ev->buff));  
  40.     ev->s_offset = 0;    
  41.     ev->len = 0;  
  42.     ev->last_active = time(NULL);    
  43. }    
  44. // add/mod an event to epoll    
  45. void EventAdd(int epollFd, int events, myevent_s *ev)    
  46. {    
  47.     struct epoll_event epv = {0, {0}};    
  48.     int op;    
  49.     epv.data.ptr = ev;    
  50.     epv.events = ev->events = events;    
  51.     if(ev->status == 1){    
  52.         op = EPOLL_CTL_MOD;    
  53.     }    
  54.     else{    
  55.         op = EPOLL_CTL_ADD;    
  56.         ev->status = 1;    
  57.     }    
  58.     if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)    
  59.         printf("Event Add failed[fd=%d], evnets[%d]\n", ev->fd, events);    
  60.     else    
  61.         printf("Event Add OK[fd=%d], op=%d, evnets[%0X]\n", ev->fd, op, events);    
  62. }    
  63. // delete an event from epoll    
  64. void EventDel(int epollFd, myevent_s *ev)    
  65. {    
  66.     struct epoll_event epv = {0, {0}};    
  67.     if(ev->status != 1) return;    
  68.     epv.data.ptr = ev;    
  69.     ev->status = 0;  
  70.     epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);    
  71. }    
  72. int g_epollFd;    
  73. myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd    
  74. void RecvData(int fd, int events, void *arg);    
  75. void SendData(int fd, int events, void *arg);    
  76. // accept new connections from clients    
  77. void AcceptConn(int fd, int events, void *arg)    
  78. {    
  79.     struct sockaddr_in sin;    
  80.     socklen_t len = sizeof(struct sockaddr_in);    
  81.     int nfd, i;    
  82.     // accept    
  83.     if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1)    
  84.     {    
  85.         if(errno != EAGAIN && errno != EINTR)    
  86.         {    
  87.         }  
  88.         printf("%s: accept, %d", __func__, errno);    
  89.         return;    
  90.     }    
  91.     do    
  92.     {    
  93.         for(i = 0; i < MAX_EVENTS; i++)    
  94.         {    
  95.             if(g_Events[i].status == 0)    
  96.             {    
  97.                 break;    
  98.             }    
  99.         }    
  100.         if(i == MAX_EVENTS)    
  101.         {    
  102.             printf("%s:max connection limit[%d].", __func__, MAX_EVENTS);    
  103.             break;    
  104.         }    
  105.         // set nonblocking  
  106.         int iret = 0;  
  107.         if((iret = fcntl(nfd, F_SETFL, O_NONBLOCK)) < 0)  
  108.         {  
  109.             printf("%s: fcntl nonblocking failed:%d", __func__, iret);  
  110.             break;  
  111.         }  
  112.         // add a read event for receive data    
  113.         EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);    
  114.         EventAdd(g_epollFd, EPOLLIN, &g_Events[i]);    
  115.     }while(0);    
  116.     printf("new conn[%s:%d][time:%d], pos[%d]\n", inet_ntoa(sin.sin_addr),   
  117.             ntohs(sin.sin_port), g_Events[i].last_active, i);    
  118. }    
  119. // receive data    
  120. void RecvData(int fd, int events, void *arg)    
  121. {    
  122.     struct myevent_s *ev = (struct myevent_s*)arg;    
  123.     int len;    
  124.     // receive data  
  125.     len = recv(fd, ev->buff+ev->len, sizeof(ev->buff)-1-ev->len, 0);      
  126.     EventDel(g_epollFd, ev);  
  127.     if(len > 0)  
  128.     {  
  129.         ev->len += len;  
  130.         ev->buff[len] = '\0';    
  131.         printf("C[%d]:%s\n", fd, ev->buff);    
  132.         // change to send event    
  133.         EventSet(ev, fd, SendData, ev);    
  134.         EventAdd(g_epollFd, EPOLLOUT, ev);    
  135.     }    
  136.     else if(len == 0)    
  137.     {    
  138.         close(ev->fd);    
  139.         printf("[fd=%d] pos[%d], closed gracefully.\n", fd, ev-g_Events);    
  140.     }    
  141.     else    
  142.     {    
  143.         close(ev->fd);    
  144.         printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));    
  145.     }    
  146. }    
  147. // send data    
  148. void SendData(int fd, int events, void *arg)    
  149. {    
  150.     struct myevent_s *ev = (struct myevent_s*)arg;    
  151.     int len;    
  152.     // send data    
  153.     len = send(fd, ev->buff + ev->s_offset, ev->len - ev->s_offset, 0);  
  154.     if(len > 0)    
  155.     {  
  156.         printf("send[fd=%d], [%d<->%d]%s\n", fd, len, ev->len, ev->buff);  
  157.         ev->s_offset += len;  
  158.         if(ev->s_offset == ev->len)  
  159.         {  
  160.             // change to receive event  
  161.             EventDel(g_epollFd, ev);    
  162.             EventSet(ev, fd, RecvData, ev);    
  163.             EventAdd(g_epollFd, EPOLLIN, ev);    
  164.         }  
  165.     }    
  166.     else    
  167.     {    
  168.         close(ev->fd);    
  169.         EventDel(g_epollFd, ev);    
  170.         printf("send[fd=%d] error[%d]\n", fd, errno);    
  171.     }    
  172. }    
  173. void InitListenSocket(int epollFd, short port)    
  174. {    
  175.     int listenFd = socket(AF_INET, SOCK_STREAM, 0);    
  176.     fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking    
  177.     printf("server listen fd=%d\n", listenFd);    
  178.     EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]);    
  179.     // add listen socket    
  180.     EventAdd(epollFd, EPOLLIN, &g_Events[MAX_EVENTS]);    
  181.     // bind & listen    
  182.     sockaddr_in sin;    
  183.     bzero(&sin, sizeof(sin));    
  184.     sin.sin_family = AF_INET;    
  185.     sin.sin_addr.s_addr = INADDR_ANY;    
  186.     sin.sin_port = htons(port);    
  187.     bind(listenFd, (const sockaddr*)&sin, sizeof(sin));    
  188.     listen(listenFd, 5);    
  189. }    
  190. int main(int argc, char **argv)    
  191. {    
  192.     unsigned short port = 12345; // default port    
  193.     if(argc == 2){    
  194.         port = atoi(argv[1]);    
  195.     }    
  196.     // create epoll    
  197.     g_epollFd = epoll_create(MAX_EVENTS);    
  198.     if(g_epollFd <= 0) printf("create epoll failed.%d\n", g_epollFd);    
  199.     // create & bind listen socket, and add to epoll, set non-blocking    
  200.     InitListenSocket(g_epollFd, port);    
  201.     // event loop    
  202.     struct epoll_event events[MAX_EVENTS];    
  203.     printf("server running:port[%d]\n", port);    
  204.     int checkPos = 0;    
  205.     while(1){    
  206.         // a simple timeout check here, every time 100, better to use a mini-heap, and add timer event    
  207.         long now = time(NULL);    
  208.         for(int i = 0; i < 100; i++, checkPos++) // doesn't check listen fd    
  209.         {    
  210.             if(checkPos == MAX_EVENTS) checkPos = 0; // recycle    
  211.             if(g_Events[checkPos].status != 1) continue;    
  212.             long duration = now - g_Events[checkPos].last_active;    
  213.             if(duration >= 60) // 60s timeout    
  214.             {    
  215.                 close(g_Events[checkPos].fd);    
  216.                 printf("[fd=%d] timeout[%d--%d].\n", g_Events[checkPos].fd, g_Events[checkPos].last_active, now);    
  217.                 EventDel(g_epollFd, &g_Events[checkPos]);    
  218.             }    
  219.         }    
  220.         // wait for events to happen    
  221.         int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);    
  222.         if(fds < 0){    
  223.             printf("epoll_wait error, exit\n");    
  224.             break;    
  225.         }    
  226.         for(int i = 0; i < fds; i++){    
  227.             myevent_s *ev = (struct myevent_s*)events[i].data.ptr;    
  228.             if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event    
  229.             {    
  230.                 ev->call_back(ev->fd, events[i].events, ev->arg);    
  231.             }    
  232.             if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event    
  233.             {    
  234.                 ev->call_back(ev->fd, events[i].events, ev->arg);    
  235.             }    
  236.         }    
  237.     }    
  238.     // free resource    
  239.     return 0;    
  240. }     
目录
相关文章
|
17小时前
|
存储 弹性计算 安全
阿里云服务器2核4G配置可选实例规格、收费标准及2024年优惠价格
阿里云服务器2核4G配置多少钱?可选实例规格有哪些?2024年的优惠价格是多少?根据阿里云2024年的收费标准及活动价格来看,2核4G配置轻量应用服务器的最优惠的价格是165元1年,云服务器2核4G配置的价格为199元1年。阿里云服务器2核4G配置可选的规格有二十几个,不同实例的价格有所不同,下面是2核4G配置可选实例规格详解及优惠价格表。
阿里云服务器2核4G配置可选实例规格、收费标准及2024年优惠价格
|
1天前
|
弹性计算 固态存储 调度
阿里云199元服务器ECS u1实例2核4G5M带宽性能怎么样?
阿里云199元服务器ECS u1实例2核4G5M带宽性能怎么样?阿里云服务器ECS u1实例,2核4G,5M固定带宽,80G ESSD Entry盘优惠价格199元一年,性能很不错,CPU采用Intel Xeon Platinum可扩展处理器,购买限制条件为企业客户专享,实名认证信息是企业用户即可,新老用户均可购买,并且续费续费不涨价,企业客户新购续费皆¥199.00/1年,每年可下单1次。阿里云百科整理这台2核4G5M云服务器购买条件、详细配置、优惠价格和性能参数测评
|
1天前
|
弹性计算 数据可视化 应用服务中间件
2024年阿里云服务器2核2G配置有什么优惠?可选实例规格及优惠价格参考
阿里云服务器2核2G配置多少钱?可选实例规格有哪些?2024年的优惠价格是多少?根据阿里云2024年的收费标准及活动价格来看,2核2G配置轻量应用服务器的最优惠的价格是61元1年,云服务器2核2G配置的价格为99元1年。阿里云服务器2核2G配置可选的规格有4个,不同实例的价格有所不同,下面是2核2G配置可选实例规格详解及优惠价格表。
2024年阿里云服务器2核2G配置有什么优惠?可选实例规格及优惠价格参考
|
1天前
|
存储 弹性计算 编解码
阿里云服务器五代、六代、七代、八代实例有哪些?各自在性能方面有哪些提升?
阿里云服务器的实例规格经过多次升级之后,最新一代已经升级到第八代实例,当下主售的是以七代和八代云服务器为主,有的用户由于是初次接触阿里云服务器,所以不是很清楚阿里云服务器五代、六代、七代、八代实例有哪些,它们各自在云服务器性能上有哪些提升。下面小编为大家介绍下阿里云五代、六代、七代、八代云服务器实例规格分别有哪些以及每一代云服务器在性能方面具体有哪些提升,以供大家参考和了解。
阿里云服务器五代、六代、七代、八代实例有哪些?各自在性能方面有哪些提升?
|
4天前
|
弹性计算 大数据 测试技术
2024年阿里云服务器价格购买价格表(实例配置价格+磁盘价格+网络宽带价格)
2024年阿里云服务器价格购买价格表来了!2024年阿里云服务器租用费用,轻量应用服务器和云服务器ECS优惠价格表,云服务器ECS经济型e实例2核2G、3M固定带宽99元一年、ECS u1实例2核4G、5M固定带宽、80G ESSD Entry盘优惠价格199元一年,轻量应用服务器2核2G3M带宽轻量服务器一年61元、2核4G4M带宽轻量服务器一年165元12个月、2核4G服务器30元3个月,幻兽帕鲁4核16G和8核32G服务器配置,云服务器ECS可以选择经济型e实例、通用算力u1实例、ECS计算型c7、通用型g7、c8i、g8i等企业级实例规格。今天分享阿里云服务器租用费用最新报价:
19 2
|
7天前
|
弹性计算 网络安全
阿里云OpenAPI提供了多种接口来管理ECS实例
【2月更文挑战第1天】阿里云OpenAPI提供了多种接口来管理ECS实例
17 0
|
7天前
|
存储 弹性计算 安全
带你读《从基础到应用云上安全航行指南》——九大提升ECS实例操作系统安全性的技巧(1)
带你读《从基础到应用云上安全航行指南》——九大提升ECS实例操作系统安全性的技巧(1)
188 1
|
7天前
|
存储 弹性计算 安全
带你读《从基础到应用云上安全航行指南》——九大提升ECS实例操作系统安全性的技巧(2)
带你读《从基础到应用云上安全航行指南》——九大提升ECS实例操作系统安全性的技巧(2)
289 1
带你读《从基础到应用云上安全航行指南》——九大提升ECS实例操作系统安全性的技巧(2)
|
7天前
|
弹性计算 运维 监控
带你读《从基础到应用云上安全航行指南》——九大提升ECS实例操作系统安全性的技巧(3)
带你读《从基础到应用云上安全航行指南》——九大提升ECS实例操作系统安全性的技巧(3)
174 1
|
9天前
|
存储 弹性计算 数据可视化
ECS:实例概述
ECS实例是云上的虚拟计算服务器,包含vCPU、内存、操作系统、网络、磁盘等基础组件
16 0

热门文章

最新文章

相关产品

  • 云迁移中心