Linux epoll模型

定义：

　　epoll是Linux内核为处理大批句柄而作改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著的减少程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。因为它会复用文件描述符集合来传递结果而不是迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一个原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。epoll除了提供select\poll那种IO事件的电平触发(Level
Triggered)外，还提供了边沿触发(Edge
Triggered)，这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提供应用程序的效率。

工作方式：

　　LT(level triggered)：水平触发，缺省方式，同时支持block和no-block
socket，在这种做法中，内核告诉我们一个文件描述符是否被就绪了，如果就绪了，你就可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错的可能性较小。传统的select\poll都是这种模型的代表。

　　ET(edge-triggered)：边沿触发，高速工作方式，只支持no-block
socket。在这种模式下，当描述符从未就绪变为就绪状态时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如：你在发送、接受或者接受请求，或者发送接受的数据少于一定量时导致了一个EWOULDBLOCK错误)。但是请注意，如果一直不对这个fs做IO操作(从而导致它再次变成未就绪状态)，内核不会发送更多的通知。

　　区别：LT事件不会丢弃，而是只要读buffer里面有数据可以让用户读取，则不断的通知你。而ET则只在事件发生之时通知。

使用方式：

　　1、int epoll_create(int size)  //int epoll_create1(int
flag) http://cpp.ezbty.org/import_doc/linux_manpage/epoll_create1.2.html

创建一个epoll句柄，参数size用来告诉内核监听的数目。

　　2、int epoll_ctl(int epfd, int op, int fd, struct epoll_event
*event)

epoll事件注册函数，

　　参数epfd为epoll的句柄；

　　参数op表示动作，用3个宏来表示：EPOLL_CTL_ADD(注册新的fd到epfd)，EPOLL_CTL_MOD(修改已经注册的fd的监听事件)，EPOLL_CTL_DEL(从epfd删除一个fd)；

　　参数fd为需要监听的标示符；

　　参数event告诉内核需要监听的事件，event的结构如下：

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表示已超时。

应用举例：

　　下面，我引用google code中别人写的一个简单程序来进行说明。svn路径：http://sechat.googlecode.com/svn/trunk/

　　该程序一个简单的聊天室程序，用Linux
C++写的，服务器主要是用epoll模型实现，支持高并发，我测试在有10000个客户端连接服务器的时候，server处理时间不到1秒，当然客户端只是与服务器连接之后，接受服务器的欢迎消息而已，并没有做其他的通信。虽然程序比较简单，但是在我们考虑服务器高并发时也提供了一个思路。在这个程序中，我已经把所有的调试信息和一些与epoll无关的信息干掉，并添加必要的注释，应该很容易理解。

　　程序共包含2个头文件和3个cpp文件。其中3个cpp文件中，每一个cpp文件都是一个应用程序，server.cpp：服务器程序，client.cpp：单个客户端程序，tester.cpp：模拟高并发，开启10000个客户端去连服务器。

　　utils.h头文件，就包含一个设置socket为不阻塞函数，如下：

int setnonblocking(int sockfd)

{

    CHK(fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK));

    return 0;

}

　　local.h头文件，一些常量的定义和函数的声明，如下：


#define BUF_SIZE 1024                 //默认缓冲区

#define SERVER_PORT 44444             //监听端口

#define SERVER_HOST "192.168.34.15"   //服务器IP地址

#define EPOLL_RUN_TIMEOUT -1          //epoll的超时时间

#define EPOLL_SIZE 10000              //epoll监听的客户端的最大数目


#define STR_WELCOME "Welcome to seChat! You ID is: Client #%d"

#define STR_MESSAGE "Client #%d>> %s"

#define STR_NOONE_CONNECTED "Noone connected to server except you!"

#define CMD_EXIT "EXIT"


//两个有用的宏定义：检查和赋值并且检测

#define CHK(eval) if(eval < 0){perror("eval"); exit(-1);}

#define CHK2(res, eval) if((res = eval) < 0){perror("eval"); exit(-1);}


//================================================================================================

//函数名：                  setnonblocking

//函数描述：                设置socket为不阻塞

//输入：                    [in] sockfd socket标示符

//输出：                    无

//返回：                    0

//================================================================================================

int setnonblocking(int sockfd);
//================================================================================================

//函数名：                  handle_message

//函数描述：                处理每个客户端socket

//输入：                    [in] new_fd socket标示符

//输出：                    无

//返回：                    返回从客户端接受的数据的长度

//================================================================================================

int handle_message(int new_fd);

　　server.cpp文件，epoll模型就在这里实现，如下：


#include "local.h"

#include "utils.h"


using namespace std;


// 存放客户端socket描述符的list

list<int> clients_list;


int main(int argc, char *argv[])

{

    int listener;   //监听socket

    struct sockaddr_in addr, their_addr;

    addr.sin_family = PF_INET;

    addr.sin_port = htons(SERVER_PORT);

    addr.sin_addr.s_addr = inet_addr(SERVER_HOST);

    socklen_t socklen;

    socklen = sizeof(struct sockaddr_in);


static struct epoll_event ev, events[EPOLL_SIZE];

    ev.events = EPOLLIN | EPOLLET;     //对读感兴趣，边沿触发


char message[BUF_SIZE];


int epfd;  //epoll描述符

    clock_t tStart;  //计算程序运行时间


int client, res, epoll_events_count;


CHK2(listener, socket(PF_INET, SOCK_STREAM, 0));             //初始化监听socket

    setnonblocking(listener);                                    //设置监听socket为不阻塞

    CHK(bind(listener, (struct sockaddr *)&addr, sizeof(addr))); //绑定监听socket

    CHK(listen(listener, 1));                                    //设置监听


CHK2(epfd,epoll_create(EPOLL_SIZE));                         //创建一个epoll描述符，并将监听socket加入epoll

    ev.data.fd = listener;

    CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, listener, &ev));


while(1)

    {

        CHK2(epoll_events_count,epoll_wait(epfd, events, EPOLL_SIZE, EPOLL_RUN_TIMEOUT));

        tStart = clock();

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

        {

            if(events[i].data.fd == listener)                    //新的连接到来，将连接添加到epoll中，并发送欢迎消息

            {

                CHK2(client,accept(listener, (struct sockaddr *) &their_addr, &socklen));

                setnonblocking(client);

                ev.data.fd = client;

                CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, client, &ev));


clients_list.push_back(client);                  // 添加新的客户端到list

                bzero(message, BUF_SIZE);

                res = sprintf(message, STR_WELCOME, client);

                CHK2(res, send(client, message, BUF_SIZE, 0));


}else

            {

                CHK2(res,handle_message(events[i].data.fd)); //注意：这里并没有调用epoll_ctl重新设置socket的事件类型，但还是可以继续收到客户端发送过来的信息

            }

        }

        printf("Statistics: %d events handled at: %.2f second(s)\n", epoll_events_count, (double)(clock() - tStart)/CLOCKS_PER_SEC);

    }


close(listener);

    close(epfd);


return 0;

}


int handle_message(int client)

{

    char buf[BUF_SIZE], message[BUF_SIZE];

    bzero(buf, BUF_SIZE);

    bzero(message, BUF_SIZE);


int len;


CHK2(len,recv(client, buf, BUF_SIZE, 0));  //接受客户端信息


if(len == 0)   //客户端关闭或出错，关闭socket，并从list移除socket

    {

        CHK(close(client));

        clients_list.remove(client);

    }

    else          //向客户端发送信息

    {

        if(clients_list.size() == 1)

        {

            CHK(send(client, STR_NOONE_CONNECTED, strlen(STR_NOONE_CONNECTED), 0));

                return len;

        }


sprintf(message, STR_MESSAGE, client, buf);

        list<int>::iterator it;

        for(it = clients_list.begin(); it != clients_list.end(); it++)

        {

           if(*it != client)

           {

                CHK(send(*it, message, BUF_SIZE, 0));

           }

        }

    }


return len;

}

　　tester.cpp文件，模拟服务器的高并发，开启10000个客户端去连接服务器，如下：


#include "local.h"

#include "utils.h"


using namespace std;


char message[BUF_SIZE];     //接受服务器信息

list<int> list_of_clients;  //存放所有客户端

int res;

clock_t tStart;


int main(int argc, char *argv[])

{

    int sock;

    struct sockaddr_in addr;

    addr.sin_family = PF_INET;

    addr.sin_port = htons(SERVER_PORT);

    addr.sin_addr.s_addr = inet_addr(SERVER_HOST);


tStart = clock();


for(int i=0 ; i<EPOLL_SIZE; i++)  //生成EPOLL_SIZE个客户端，这里是10000个，模拟高并发

    {

       CHK2(sock,socket(PF_INET, SOCK_STREAM, 0));

       CHK(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0);

       list_of_clients.push_back(sock);


bzero(&message, BUF_SIZE);

       CHK2(res,recv(sock, message, BUF_SIZE, 0));

       printf("%s\n", message);

    }


list<int>::iterator it;          //移除所有客户端

    for(it = list_of_clients.begin(); it != list_of_clients.end() ; it++)

       close(*it);


printf("Test passed at: %.2f second(s)\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);

    printf("Total server connections was: %d\n", EPOLL_SIZE);


return 0;

}

　　我就不给出程序的执行结果的截图了，不过下面这张截图是代码作者自己测试的，可以看出，并发10000无压力呀

　　单个客户端去连接服务器，client.cpp文件，如下：


#include "local.h"

#include "utils.h"


using namespace std;


char message[BUF_SIZE];


/*

    流程：

        调用fork产生两个进程，两个进程通过管道进行通信

        子进程：等待客户输入，并将客户输入的信息通过管道写给父进程

        父进程：接受服务器的信息并显示，将从子进程接受到的信息发送给服务器

*/

int main(int argc, char *argv[])

{

    int sock, pid, pipe_fd[2], epfd;


struct sockaddr_in addr;

    addr.sin_family = PF_INET;

    addr.sin_port = htons(SERVER_PORT);

    addr.sin_addr.s_addr = inet_addr(SERVER_HOST);


static struct epoll_event ev, events[2];

    ev.events = EPOLLIN | EPOLLET;


//退出标志

    int continue_to_work = 1;


CHK2(sock,socket(PF_INET, SOCK_STREAM, 0));

    CHK(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0);


CHK(pipe(pipe_fd));


CHK2(epfd,epoll_create(EPOLL_SIZE));


ev.data.fd = sock;

    CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ev));


ev.data.fd = pipe_fd[0];

    CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, pipe_fd[0], &ev));


// 调用fork产生两个进程

    CHK2(pid,fork());

    switch(pid)

    {

        case 0:                   // 子进程

            close(pipe_fd[0]);    // 关闭读端

            printf("Enter ‘exit‘ to exit\n");

            while(continue_to_work)

            {

                bzero(&message, BUF_SIZE);

                fgets(message, BUF_SIZE, stdin);


// 当收到exit命令时，退出

                if(strncasecmp(message, CMD_EXIT, strlen(CMD_EXIT)) == 0)

                {

                    continue_to_work = 0;

                }

                else

                {

                    CHK(write(pipe_fd[1], message, strlen(message) - 1));

                }

            }

            break;

        default:                 // 父进程

            close(pipe_fd[1]);   // 关闭写端

            int epoll_events_count, res;

            while(continue_to_work)

            {

                CHK2(epoll_events_count,epoll_wait(epfd, events, 2, EPOLL_RUN_TIMEOUT));


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

                {

                    bzero(&message, BUF_SIZE);

                    if(events[i].data.fd == sock)   //从服务器接受信息

                    {

                        CHK2(res,recv(sock, message, BUF_SIZE, 0));

                        if(res == 0)               //服务器已关闭

                        {

                            CHK(close(sock));

                            continue_to_work = 0;

                        }

                        else

                        {

                            printf("%s\n", message);

                        }

                    }

                    else        //从子进程接受信息

                    {

                        CHK2(res, read(events[i].data.fd, message, BUF_SIZE));

                        if(res == 0)

                        {

                            continue_to_work = 0;

                        }

                        else

                        {

                            CHK(send(sock, message, BUF_SIZE, 0));

                        }

                    }

                }

            }

    }

    if(pid)

    {

        close(pipe_fd[0]);

        close(sock);

    }else

    {

        close(pipe_fd[1]);

    }


return 0;

}

Linux epoll模型

时间： 2024-10-05 09:59:50

Linux epoll模型的相关文章

(OK) Linux epoll模型—socket epoll server client chat

http://www.cnblogs.com/venow/archive/2012/11/30/2790031.html http://blog.csdn.net/denkensk/article/details/41978015 定义: epoll是Linux内核为处理大批句柄而作改进的poll,是Linux下多路复用IO接口select/poll的增强版本,它能显著的减少程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率.因为它会复用文件描述符集合来传递结果而不是迫使开发者每次等待事

(OK) Linux epoll模型—socket epoll server client chat—pthread

http://www.cnblogs.com/venow/archive/2012/11/30/2790031.html http://blog.csdn.net/denkensk/article/details/41978015 定义: epoll是Linux内核为处理大批句柄而作改进的poll,是Linux下多路复用IO接口select/poll的增强版本,它能显著的减少程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率.因为它会复用文件描述符集合来传递结果而不是迫使开发者每次等待事

Linux Epoll模型(1) --理论与实践

引言: 相比于select,Epoll最大的好处在于它不会随着监听fd数目的增长而降低效率.因为在内核中的select实现中,它是采用轮询来处理的,轮询的fd数目越多,自然耗时越多.并且,在linux/posix_types.h头文件有这样的声明: #define __FD_SETSIZE    1024 表示select最多同时监听1024个fd,当然,可以通过修改头文件再重编译内核来扩大这个数目,但这似乎治标不治本. 常用模型的特点 Linux 下设计并发网络程序,有典型的Apache模型(

2020.04.10 线上性能优化以及Linux下NIO/Epoll模型全解--实战

1.支付宝模拟线上优化实战 2.手写JUC工具与提升tomcat吞吐量 3.网络通信BIO设计与缺陷   -- accept()  和 read()阻塞 4.单线程解决高并发NIO精髓解读 5.OS内核下Epoll与Selete源码解读 第一部分: 性能优化 问题:如何在高并发场景下实现支付宝用户登录页面的信息获取?如用户信息,金额,积分等 浏览器  ---- Spring MVC ---- controller ----- service ---- 用户模块.余额模块.积分模块等 -- 调用多

Linux Epoll介绍和程序实例

1. Epoll是何方神圣? Epoll但是当前在Linux下开发大规模并发网络程序的热门人选,Epoll 在Linux2.6内核中正式引入,和select类似,事实上都I/O多路复用技术而已,并没有什么神奇的. 事实上在Linux下设计并发网络程序,向来不缺少方法,比方典型的Apache模型(Process Per Connection,简称PPC),TPC(Thread PerConnection)模型,以及select模型和poll模型,那为何还要再引入Epoll这个东东呢?那还是有得说说

Apache select和Nginx epoll模型区别

部分内容摘自跟老男孩学Linux运维:Web集群实战(运维人员必备书籍) http://oldboy.blog.51cto.com/2561410/1752270 1.select 和epoll模型区别 1.1.网络IO模型概述 通常来说,网络IO可以抽象成用户态和内核态之间的数据交换.一次网络数据读取操作(read),可以拆分成两个步骤:1)网卡驱动等待数据准备好(内核态)2)将数据从内核空间拷贝到进程空间(用户态).根据这两个步骤处理方式不一样,我们通常把网络IO划分成阻塞IO和非阻塞IO.

Windows完成端口与Linux epoll技术简介

收藏自:http://www.cnblogs.com/cr0-3/archive/2011/09/09/2172280.html WINDOWS完成端口编程1.基本概念2.WINDOWS完成端口的特点3.完成端口(Completion Ports )相关数据结构和创建4.完成端口线程的工作原理5.Windows完成端口的实例代码Linux的EPoll模型1.为什么select落后2.内核中提高I/O性能的新方法epoll3.epoll的优点4.epoll的工作模式 5.epoll的使用方法6.L

0729------Linux网络编程----------使用 select 、poll 和 epoll 模型 编写客户端程序

1.select 模型 1.1 select 函数原型如下,其中 nfds 表示的描述符的最大值加1(因为这里是左闭右开区间),中间三个参数分别表示要监听的不同类型描述符的集合,timeout用来表示轮询的时间间隔,这里用NULL表示无限等待. 1.2 使用 select函数编写客户端程序的一般步骤: a)初始化参数,包括初始化监听集合read_set并添加fd,以及初始化监听的最大描述符 maxfd 和select的返回值 nready: b)将read_set 赋值给 ready_set,因

epoll模型实例

一.epoll概述 epoll是linux下的一个系统调用,用来监听大量文件描述符并对其上的触发事件进行处理.它是select/poll的增强版本,也是linux下多路复用io最常用的接口.要理解epoll是什么,首先得清楚什么是多路复用io.用户进行io操作需要经过内核,而如果所请求的io目前不满足条件(如需要从标准输入读取数据,而用户还未输入),这个时候内核就会让应用程序陷入等待,即阻塞状态.个人理解,io复用技术就是通过特定接口,将这种阻塞进行了转移,转嫁到了如select/poll/ep