Chinaunix首页 | 论坛 | 博客

03xsxmj的ChinaUnix博客

首页　| 　博文目录　| 　关于我

03xsxmj

  • 博客访问： 643587
  • 博文数量： 363
  • 博客积分： 110
  • 博客等级： 民兵
  • 技术积分： 1347
  • 用 户 组： 普通用户
  • 注册时间： 2011-06-22 16:07
文章分类

全部博文（363）

文章存档

2018年（83）

2016年（1）

2014年（2）

2013年（34）

2012年（236）

2011年（7）

我的朋友
最近访客
推荐博文
epoll使用详解及LT、ET性能剖析

分类：

2012-01-10 16:58:52

原文地址：epoll使用详解及LT、ET性能剖析 作者：kkmm0105

epoll的接口非常简单，一共就三个函数：


1. int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好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，第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下：

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 */
};

events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

 

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。


那么究竟如何来使用epoll呢？其实非常简单。
通过在包含一个头文件#include 以及几个简单的API将可以大大的提高你的网络服务器的支持人数。

首先通过create_epoll(int maxfds)来创建一个epoll的句柄，其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄，之后的所有操作将通过这个句柄来进行操作。在用完之后，记得用close()来关闭这个创建出来的epoll句柄。

之后在你的网络主循环里面，每一帧的调用epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为：
nfds = epoll_wait(kdpfd, events, maxevents, -1);
其中kdpfd为用epoll_create创建之后的句柄，events是一个epoll_event*的指针，当epoll_wait这个函数操作成功之后，epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则范围。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率。

下面是网上给出的示例：

 

  1. 1.    void setnonblocking(int sock){
  2. 2.    int opts;
  3. 3.    opts = fcntl(sock,F_GETFL);
  4. 4.    if(opts < 0){
  5. 5.    perror("fcntl(sock,GETFL)");
  6. 6.    exit(1);
  7. 7.    }
  8. 8.    opts = opts | O_NONBLOCK;
  9. 9.    if(fcntl(sock, F_SETFL, opts) < 0){
  10. 10.    perror("fcntl(sock, SETFL, opts)");
  11. 11.    exit(1);
  12. 12.    }
  13. 13.    }
  14. 14.    
  15. 15.    int main(int argc, char* argv[]){
  16. 16.    int i, maxi, listenfd, connfd, sockfd, epfd, nfds, portnumber;
  17. 17.    ssize_t n;
  18. 18.    char line[MAXLINE];
  19. 19.    socklen_t clilen;
  20. 20.    
  21. 21.    if(argc == 2){
  22. 22.    if((portnumber = atoi(argv[1])) < 0){
  23. 23.    fprintf(stderr, "Usage:%s portnumber/a/n", argv[0]);
  24. 24.    return 1;
  25. 25.    }
  26. 26.    }
  27. 27.    else{
  28. 28.    fprintf(stderr, "Usage:%s portnumber/a/n", argv[0]);
  29. 29.    return 1;
  30. 30.    }
  31. 31.    struct sockaddr_in serveraddr, clientaddr;
  32. 32.    memset(&serveraddr, 0, sizeof(serveraddr));
  33. 33.    memset(&clientaddr, 0, sizeof(clientaddr));
  34. 34.    serveraddr.sin_family = AF_INET;
  35. 35.    serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  36. 36.    serveraddr.sin_port = htons(portnumber);
  37. 37.    
  38. 38.    listenfd = socket(AF_INET, SOCK_STREAM, 0);
  39. 39.    bind(listenfd, (sockaddr *)&serveraddr, sizeof(serveraddr));
  40. 40.    listen(listenfd, LISTENQ);
  41. 41.    
  42. 42.    //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
  43. 43.    struct epoll_event ev;
  44. 44.    struct epool_event events[20];
  45. 45.    
  46. 46.    //生成用于处理accept的epoll专用的文件描述符
  47. 47.    epfd = epoll_create(256);
  48. 48.    
  49. 49.    //把socket设置为非阻塞方式，影响accept()的返回时机
  50. 50.    setnonblocking(listenfd);
  51. 51.    
  52. 52.    //设置与要处理的事件相关的文件描述符
  53. 53.    ev.data.fd = listenfd;
  54. 54.    
  55. 55.    //设置要处理的事件类型：监听套接字变为可读
  56. 56.    ev.events = EPOLLIN | EPOLLET;
  57. 57.    
  58. 58.    //注册epoll事件
  59. 59.    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
  60. 60.    for ( ; ; ) {
  61. 61.    //等待epoll事件的发生
  62. 62.    nfds = epoll_wait(epfd, events, 20, 500);
  63. 63.    
  64. 64.    //处理所发生的所有事件
  65. 65.    for(i = 0; i < nfds; i++){
  66. 66.    //如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
  67. 67.    if(events[i].data.fd == listenfd)
  68. 68.    {
  69. 69.    int clilen = sizeof(clientaddr);
  70. 70.    connfd = accept(listenfd, (struct sockaddr *)&clientaddr, &clilen);
  71. 71.    if(connfd < 0){
  72. 72.    perror("accept()");
  73. 73.    exit(1);
  74. 74.    }
  75. 75.    setnonblocking(connfd);
  76. 76.    printf("accept a connection from %s.", inet_ntoa(clientaddr.sin_addr));
  77. 77.    //设置用于读操作的文件描述符，准备接受客户端请求
  78. 78.    ev.data.fd = connfd;
  79. 79.    
  80. 80.    //设置用于注测的读操作事件
  81. 81.    ev.events = EPOLLIN | EPOLLET;
  82. 82.    
  83. 83.    //注册ev
  84. 84.    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
  85. 85.    }
  86. 86.    else if(events[i].events & EPOLLIN){//如果是已经连接的用户，并且收到数据，那么进行读入。
  87. 87.    if((sockfd = events[i].data.fd) < 0){
  88. 88.    continue;
  89. 89.    }
  90. 90.    if((n = read(sockfd, line, MAXLINE)) < 0){
  91. 91.    if (errno == ECONNRESET){
  92. 92.    close(sockfd);
  93. 93.    events[i].data.fd = -1;
  94. 94.    }
  95. 95.    else{
  96. 96.    printf("read() error\n");
  97. 97.    }
  98. 98.    }
  99. 99.    else if(n == 0){
  100. 100.    close(sockfd);
  101. 101.    events[i].data.fd = -1;
  102. 102.    }
  103. 103.    line[n] = '\0';
  104. 104.    printf("%s\n", line);
  105. 105.    //设置用于写操作的文件描述符
  106. 106.    ev.data.fd = sockfd;
  107. 107.    
  108. 108.    //设置用于注册的写操作事件
  109. 109.    ev.events = EPOLLOUT | EPOLLET;
  110. 110.    
  111. 111.    //修改sockfd上要处理的事件为EPOLLOUT
  112. 112.    epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
  113. 113.    }
  114. 114.    else if(events[i].events & EPOLLOUT){//如果被通知可写
  115. 115.    sockfd = events[i].data.fd;
  116. 116.    write(sockfd, line, n);
  117. 117.    
  118. 118.    //设置用于读操作的文件描述符
  119. 119.    ev.data.fd = sockfd;
  120. 120.    
  121. 121.    //设置用于注册的读操作事件
  122. 122.    ev.events = EPOLLIN | EPOLLET;
  123. 123.    
  124. 124.    //修改sockfd上要处理的事件为EPOLIN
  125. 125.    epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
  126. 126.    }
  127. 127.    }
  128. 128.    }
  129. 129.    return 0;
  130. 130.    }

 

理解后自己写了一个简单的回显服务器：

 

  1. 1.    #include <stdio.h>
  2. 2.    #include <stdio.h>
  3. 3.    #include <stdlib.h>
  4. 4.    #include <string.h>
  5. 5.    #include <sys/socket.h>
  6. 6.    #include <sys/types.h>
  7. 7.    #include <netinet/in.h>
  8. 8.    #include <netdb.h>
  9. 9.    #include <sys/epoll.h>
  10. 10.    #include <fcntl.h>
  11. 11.    
  12. 12.    typedef struct mydata{
  13. 13.    int fd;
  14. 14.    char *ptr;
  15. 15.    }mydata_t;
  16. 16.    
  17. 17.    int main(){
  18. 18.    int listenfd, connfd;
  19. 19.    struct sockaddr_in server;
  20. 20.    memset(&server, 0, sizeof(server));
  21. 21.    server.sin_family = AF_INET;
  22. 22.    server.sin_addr.s_addr = htonl(INADDR_ANY);
  23. 23.    server.sin_port = htons(5000);
  24. 24.    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
  25. 25.    perror("socket()");
  26. 26.    exit(1);
  27. 27.    }
  28. 28.    int on = 1;
  29. 29.    if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0){
  30. 30.    perror("setsockopt()");
  31. 31.    exit(1);
  32. 32.    }
  33. 33.    if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) < 0){
  34. 34.    perror("bind()");
  35. 35.    exit(1);
  36. 36.    }
  37. 37.    if(listen(listenfd, 5) < 0){
  38. 38.    perror("listen()");
  39. 39.    exit(1);
  40. 40.    }
  41. 41.    int epfd = epoll_create(1024);
  42. 42.    struct epoll_event ev;
  43. 43.    struct epoll_event ev_r[20];
  44. 44.    int nfds, i, n;
  45. 45.    //一定注意，ev.data是union类型，而不是struct类型！
  46. 46.    //data就是8字节的用户数据，对于epoll_wait而言是透明的，即epoll只负责在内核和用户区之间传递这8字节的数据，不修改内容
  47. 47.    ev.data.fd = listenfd;
  48. 48.    ev.events = EPOLLIN;
  49. 49.    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
  50. 50.    
  51. 51.    while(1){
  52. 52.    nfds = epoll_wait(epfd, ev_r, 20, -1);
  53. 53.    for(i = 0; i < nfds; i++){
  54. 54.    int fd = ev_r[i].data.fd;
  55. 55.    //有新连接待处理
  56. 56.    if(fd == listenfd){
  57. 57.    if((connfd = accept(listenfd, NULL, NULL)) < 0){
  58. 58.    perror("accept()");
  59. 59.    exit(1);
  60. 60.    }
  61. 61.    //为新连接的描述符分配缓冲区
  62. 62.    mydata_t md;
  63. 63.    md.fd = connfd;
  64. 64.    md.ptr = (char *)malloc(1025);
  65. 65.    //构造用户数据内容
  66. 66.    memcpy(&ev.data, &md, sizeof(md));
  67. 67.    ev.events = EPOLLIN;
  68. 68.    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
  69. 69.    continue;
  70. 70.    }
  71. 71.    //普通连接
  72. 72.    //提取用户数据
  73. 73.    mydata_t m;
  74. 74.    memcpy(&m, &ev_r[i].data, sizeof(m));
  75. 75.    // char *buf = *((char **)((char *)&ev_r[i].data + 4));
  76. 76.    if(ev_r[i].events & EPOLLIN){
  77. 77.    n = read(fd, m.ptr, 1024);
  78. 78.    if(n < 0){
  79. 79.    perror("read()");
  80. 80.    free(m.ptr);
  81. 81.    close(fd);
  82. 82.    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
  83. 83.    continue;
  84. 84.    }
  85. 85.    if(n == 0){
  86. 86.    close(fd);
  87. 87.    free(m.ptr);
  88. 88.    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
  89. 89.    }
  90. 90.    else{
  91. 91.    m.ptr[n] = '\0';
  92. 92.    printf("%s\n", m.ptr);
  93. 93.    memcpy(&ev.data, &m, sizeof(m));
  94. 94.    ev.events = EPOLLOUT;
  95. 95.    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
  96. 96.    }
  97. 97.    }
  98. 98.    else if(ev_r[i].events & EPOLLOUT){
  99. 99.    write(fd, m.ptr, strlen(m.ptr));
  100. 100.    memcpy(&ev.data, &m, sizeof(m));
  101. 101.    ev.events = EPOLLIN;
  102. 102.    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
  103. 103.    }
  104. 104.    }
  105. 105.    }
  106. 106.    close(epfd);
  107. 107.    close(connfd);
  108. 108.    close(listenfd);
  109. 109.    return 0;
  110. 110.    }

 

 

阅读(556) | 评论(0) | 转发(0) |
0

上一篇：深入理解C语言中的指向函数的指针和返回指针的函数

下一篇：poll, select & epoll 原理比较分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6