备案控制台
开发者社区 开发与运维 文章 正文

服务器 libevent中epoll使用实例demo

2016-04-12 1292
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 名词解释：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. }     
文章标签：
Java
Linux
关键词：
云服务器 ECS实例
云服务器 ECSepoll
云服务器 ECSdemo
double2li
目录
相关文章
弹性计算小冉
|
13天前
|
弹性计算 大数据 数据处理
阿里云服务器实例哪些属于入门级，哪些是企业级？有何区别？
阿里云服务器的实例规格从级别上来说分为入门级和企业级，从实例规格种类上来说，又分为突发性能型、共享型、计算型、通用型、内存型、大数据型等，2024年截止目前在阿里云的活动中，可选的云服务器实例规格有轻量应用服务器、经济型e、通用算力型u1、计算型c7、计算型c7a、计算型c8a、计算型c8y、通用型g7、通用型g7a、通用型g8a、通用型g8i、通用型g8y、内存型r7、内存型r8y等，有的新手用户不是很清楚2024年阿里云活动中的云服务器实例哪些属于入门级，哪些是企业级？有何区别？下面根据官方的各种资料介绍为大家解答下这些疑问，帮助您能更清楚地了解阿里云服务器，快速找到自己对云服务器产品的需
弹性计算小冉
122 2
阿里云服务器实例哪些属于入门级，哪些是企业级？有何区别？
兮叶William
|
1月前
|
云安全 弹性计算 安全
电子好书发您分享《阿里云第八代企业级ECS实例，为企业提供更安全的云上防护》
阿里云推出第八代企业级ECS实例，强化云安全，搭载英特尔TDX技术，结合CIPU与飞天系统，提供高效且安全的云服务解决方案。[阅读详情](https://developer.aliyun.com/ebook/8303/116162?spm=a2c6h.26392459.ebook-detail.5.5c0b7e5aZhSJ9V)
兮叶William
16 2
sunrr
|
1月前
|
弹性计算 自然语言处理 Linux
部署GPT-2大语言模型到基于ECS Intel实例的过程可以分为以下步骤
部署GPT-2大语言模型到基于ECS Intel实例的过程可以分为以下步骤
sunrr
27 3
弹性计算小冉
|
1天前
|
编解码 缓存 安全
阿里云目前活动内各云服务器实例规格适用场景与价格参考
目前阿里云的活动中，云服务器有多种不同实例规格可选，实例规格定义了实例的基本属性：CPU和内存（包括CPU型号、主频等），但是不同实例规格所适用的场景是不一样的，价格也有很大差别，有的用户初次选购阿里云服务器可能并不知道这些实例规格的具体适用场景，下面是小编整理汇总的2024年截止目前阿里云的活动中云服务器实例规格适用场景与活动价格，以供参考。
弹性计算小冉
36 8
阿里云目前活动内各云服务器实例规格适用场景与价格参考
云小帮
|
9天前
|
弹性计算 供应链
阿里云服务器付费模式包年包月、按量付费、抢占式实例选择说明
阿里云ECS提供包年包月、按量付费和抢占式实例三种计费方式。选择建议：稳定需求选包年包月，动态需求选按量付费，无状态应用选抢占式实例以降低成本。可结合使用按量付费、预留实例券和节省计划以平衡灵活性和成本。需要资源保障则组合按量付费和资源保障。具体详情和规定可参考阿里云ECS官方文档
云小帮
39 7
云服务器小助手
|
9天前
|
存储 弹性计算 运维
深度解读：阿里云服务器ECS经济型e实例配置整理和性能参数表
阿里云推出经济型ECS e系列服务器，适用于个人开发者、学生和小微企业。该系列采用Intel Xeon Platinum处理器，支持多种CPU内存配比，性价比高，2核2G3M配置只需99元/年，新老用户不限量购买且续费不涨价。提供相同可用性SLA和安全标准，具备ESSD Entry云盘等企业级特性。适合中小型网站、开发测试和轻量级应用
云服务器小助手
45 0
云服务器小助手
|
10天前
|
存储 弹性计算 运维
阿里云服务器ECS经济型e实例特点、适用场景和使用常见问题解答
阿里云新推经济型e系列服务器，适用于个人开发者、学生和小微企业。该系列基于Intel Xeon Platinum处理器，提供1:1、1:2、1:4内存比选项，性价比高，不限购，续费不涨价。2核2G3M配置只需99元/年，企业用户2核4G5M服务器199元/年。具备价格优惠、品质保障、充足供应和多样化配置等特点。支持IPv4/IPv6，仅限专有网络VPC。实例规格和性能指标详表见原文，适合中小型网站、开发测试和轻量级应用。更多信息访问阿里云ECS页面。
云服务器小助手
25 3
cuicuicuic
|
11天前
|
弹性计算 运维 Serverless
Serverless 应用引擎产品使用之在阿里函数计算中，使用阿里云API或SDK从函数计算调用ECS实例的服务如何解决
阿里云Serverless 应用引擎（SAE）提供了完整的微服务应用生命周期管理能力，包括应用部署、服务治理、开发运维、资源管理等功能，并通过扩展功能支持多环境管理、API Gateway、事件驱动等高级应用场景，帮助企业快速构建、部署、运维和扩展微服务架构，实现Serverless化的应用部署与运维模式。以下是对SAE产品使用合集的概述，包括应用管理、服务治理、开发运维、资源管理等方面。
cuicuicuic
37 4
云服务器小助手
|
11天前
|
存储 弹性计算 运维
阿里云服务器ECS经济型e实例详细介绍
阿里云新推经济型e系列服务器，适用于个人开发者、学生和小微企业。该系列采用Intel Xeon Platinum处理器，支持多种CPU内存配比，性价比高，不限购，续费不涨价。2核2G3M配置仅需99元/年，企业用户2核4G5M服务器199元/年。具备价格优势、品质保障和充足供应，但性能可能不及企业级实例。支持IPv4/IPv6，仅限专有网络VPC。更多规格和性能指标可见官方文档。
云服务器小助手
34 1
阿里云服务器ECS经济型e实例详细介绍
弹性计算小冉
|
15天前
|
缓存 开发框架 .NET
阿里云服务器经济型e和通用算力型u1实例与轻量应用服务器区别及选择参考
在目前阿里云的活动中，价格比较优惠的云服务器有轻量应用服务器和经济型e和通用算力型u1实例的云服务器，尤其是轻量应用服务器2核2G3M带宽61元1年，经济型e实例2核2G3M带宽99元1年，通用算力型u1实例2核4G5M带宽199元1年，是用户关注度最高的几款云服务器。有的新手用户由于是初次使用阿里云服务器，对于轻量应用服务器和经济型e和通用算力型u1实例的相关性能并不是很清楚，本文为大家做个简单的介绍，以供参考。
弹性计算小冉
140 8
阿里云服务器经济型e和通用算力型u1实例与轻量应用服务器区别及选择参考

热门文章

最新文章

  • 1
    Linux基础与服务器架构综合小实践
  • 2
    服务器中常用的几个资源监控工具整理
  • 3
    使用阿里云 mqtt serverless 版本超低成本快速实现 webscoket 长链接服务器
  • 4
    阿里云服务器实例、CPU内存、带宽、操作系统选择参考
  • 5
    ecs服务器shell常用脚本练习（十）
  • 6
    ecs服务器shell常用脚本练习（九）
  • 7
    阿里云数据库服务器价格表，数据库创建、连接和使用教程
  • 8
    ecs服务器shell常用脚本练习（六）
  • 9
    ecs服务器shell常用脚本练习（二）
  • 10
    阿里云ECS服务器上从零开始搭建nginx服务器
  • 1
    阿里云第八代云服务器实例通用型g8i实例性能和适用场景介绍
    412
  • 2
    ECS热门应用 | 安装家用内网穿透服务
    157
  • 3
    无需公网IP联机Minecraft，我的世界服务器本地搭建教程
    360
  • 4
    如何在Linux环境搭建本地SVN服务器并结合cpolar实现公网访问
    46
  • 5
    如何搭建外网可访问的Serv-U FTP服务器，轻松远程共享文件！
    70
  • 6
    服务器Centos7 静默安装Oracle Database 12.2
    105
  • 7
    服务器数据恢复—服务器硬盘掉线，指示灯显示红色的数据恢复案例
    315
  • 8
    监控内网电脑软件设计与实现：基于Node.js的服务器端架构分析
    137
  • 9
    请解释什么是代理服务器，以及在爬虫中如何使用代理服务器？
    100
  • 10
    【Android平板编程】远程Ubuntu服务器code-server编程写代码
    62

    • 相关课程

    更多
  • 服务器硬件基础
  • Linux Web服务器Nginx搭建与配置
  • 7天玩转云服务器
  • 云服务器选型、迁云最佳实践
  • 云服务器ECS基本操作

    • 相关电子书

    更多
  • 如何运维千台以上游戏云服务器
  • 网站/服务器取证 实践与挑战
  • ECS快储存加密技术

    • 相关实验场景

    更多
  • 使用阿里云ECS监控您的特斯拉
  • 使用阿里云ECS安装家用内网穿透服务
  • ECS实例选型最佳实践
  • ECS服务保活和宕机启动
  • 云原生场景自动化响应ECS系统事件
  • 幻兽帕鲁联机服务快速部署【有ECS用户】
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）