linux之epoll

1. epoll简介

　　epoll 是Linux内核中的一种可扩展IO事件处理机制，最早在 Linux 2.5.44内核中引入，可被用于代替POSIX select 和 poll 系统调用，并且在具有大量应用程序请求时能够获得较好的性能（ 此时被监视的文件描述符数目非常大，与旧的 select 和 poll 系统调用完成操作所需 O(n) 不同， epoll能在O(1)时间内完成操作，所以性能相当高），epoll 与 FreeBSD的kqueue类似，都向用户空间提供了自己的文件描述符来进行操作。

2. seletc和pool

　　在linux 没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在大数据、高并发、集群等一些名词唱得火热之年代，select和poll的用武之地越来越有限，风头已经被epoll占尽。

select的缺点：

（1）单个进程能够监视的文件描述符的数量存在最大限制，通常是1024，当然可以更改数量，但由于select采用轮询的方式扫描文件描述符，文件描述符数量越多，性能越差；(在linux内核头文件中，有这样的定义：#define __FD_SETSIZE    1024)

（2）内核 / 用户空间内存拷贝问题，select需要复制大量的句柄数据结构，产生巨大的开销；

（3）select返回的是含有整个句柄的数组，应用程序需要遍历整个数组才能发现哪些句柄发生了事件；

（4）select的触发方式是水平触发，应用程序如果没有完成对一个已经就绪的文件描述符进行IO操作，那么之后每次select调用还是会将这些文件描述符通知进程。

　　相比select模型，poll使用链表保存文件描述符，因此没有了监视文件数量的限制，但其他三个缺点依然存在。拿select模型为例，假设我们的服务器需要支持100万的并发连接，则在__FD_SETSIZE 为1024的情况下，则我们至少需要开辟1k个进程才能实现100万的并发连接。除了进程间上下文切换的时间消耗外，从内核/用户空间大量的无脑内存拷贝、数组轮询等，是系统难以承受的。因此，基于select模型的服务器程序，要达到10万级别的并发访问，是一个很难完成的任务。因此，该epoll上场了。

3. epoll重要实现

int epoll_create(int size);

创建一个epoll的句柄，size用来告诉内核需要监听的数目一共有多大。当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close() 关闭，否则可能导致fd被耗尽。

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

epoll的事件注册函数，第一个参数是 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队列里。

当对方关闭连接(FIN), EPOLLERR，都可以认为是一种EPOLLIN事件，在read的时候分别有0，-1两个返回值。

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

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

EPOLL事件有两种模型 Level Triggered (LT) 和 Edge Triggered (ET)：

LT(level triggered，水平触发模式)是缺省的工作方式，并且同时支持 block 和 non-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。

ET(edge-triggered，边缘触发模式)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，等到下次有新的数据进来的时候才会再次出发就绪事件。

4. epoll实现服务器和客户端通信

/*主要包含重要的头文件*/

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#include<fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>

#include <iostream>
#include <string.h>
#include <exception>

#include <sys/socket.h>
#include <netinet/in.h>     // sockaddr_in, "man 7 ip" ,htons
#include <poll.h>             //poll,pollfd
#include <arpa/inet.h>   //inet_addr,inet_aton
#include <unistd.h>        //read,write
#include <netdb.h>         //gethostbyname

#include <sys/epoll.h>

using namespace std;

intf.h

#include "intf.h"

#include "socket.h"
#include <algorithm>
#define MAXEVENTS 64

struct MSG
{
    string strBuff;
    SOCKET s;
};

// 采用epoll异步机制实现服务器
int main()
{
    // 创建socket
    string ip = "192.168.176.131";
    int port = ;
    TcpSocket tcp(AF_INET, SOCK_STREAM);
    tcp.Bind(ip, port);
    tcp.Listen(MAXEVENTS);

    // 设置socket为O_NONBLOCK
    int flags = fcntl(tcp.m_Sock, F_GETFL, );
    if(!(flags & O_NONBLOCK))
    {
        flags |= O_NONBLOCK;
    }
    int exflags = fcntl(tcp.m_Sock, F_SETFL, );
    if(exflags == -)
    {
        cout << "fcntl F_SETFL o_NONBLOCK faild" << endl;
        return -;
    }
    // 创建epoll,该参数在新版本的linux中已经没有作用了
    int epollftd = epoll_create(MAXEVENTS);
    if(epollftd == -)
    {
        cout << "epoll create faild" << endl;
        return -;
    }
    // 将服务区socket描述符添加到epoll
    epoll_event event;
    event.events = EPOLLIN | EPOLLET;
    event.data.fd = tcp.m_Sock;

    int ret = epoll_ctl(epollftd, EPOLL_CTL_ADD, tcp.m_Sock, &event);
    if(ret == -)
    {
        cout << "epoll_ctrl EPOLL_CTL_ADD faild" << endl;
        return -;
    }

    epoll_event *pEvents = (epoll_event *)calloc(MAXEVENTS, sizeof(epoll_event));
    if(!pEvents)
    {
        cout << "calloc epoll events faild" << endl;
        return -;
    }
    // 事件处理
    while()
    {
        int nEventNum = epoll_wait(epollftd, pEvents, MAXEVENTS, );
        for(int i = ; i < nEventNum; i ++)
        {
            // 新连接到来
            if(pEvents[i].data.fd == tcp.m_Sock)
            {
                cout << "准备接收客户端的连接" << endl;
                SOCKET client = tcp.Accept();
                cout << "有客户端连接" << endl;
                // 添加到队列中
                epoll_event ev;
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = client;
                epoll_ctl(epollftd, EPOLL_CTL_ADD, client, &ev);
            }
            else if(pEvents[i].events & EPOLLIN)
            {
                string strBuff = tcp.Recv(pEvents[i].data.fd);
                cout << "接收到客户端数据：" << strBuff << endl;
                if(strBuff == "EOF")
                {
                    cout << "客户端：" << pEvents[i].data.fd << "请求断开连接" << endl;
                } 

                string strSend = "";
                transform(strBuff.begin(), strBuff.end(), back_inserter(strSend), ::toupper);

                MSG msg;
                msg.strBuff = strSend;
                msg.s = pEvents[i].data.fd;

                epoll_event ev;
                ev.data.fd = pEvents[i].data.fd;
                ev.events = EPOLLOUT | EPOLLET;
                ev.data.ptr = (void *)&msg;
                epoll_ctl(epollftd, EPOLL_CTL_MOD, pEvents[i].data.fd, &ev);
            }
            else if(pEvents[i].events & EPOLLOUT)
            {
                MSG *pMsg = (MSG*)pEvents[i].data.ptr;
                cout << "向客户端输出信息:" << pMsg->strBuff << endl;
                int ret = tcp.Send(pMsg->s, pMsg->strBuff);
                event.data.fd = pMsg->s;
                event.events = EPOLLIN | EPOLLET;
                epoll_ctl(epollftd, EPOLL_CTL_MOD, pMsg->s, &event);
            }
            else
            {
                cout << "其它的处理" << endl;
            }
        }
    }

    return ;
} 

epollserver.cpp

#include "intf.h"

#include "socket.h"

#define MAXEVENTS 64

struct MSG
{
    string strBuff;
    SOCKET s;
};

// 采用epoll异步机制实现客户端
int main()
{
    // 创建socket
    string ip = "192.168.176.131";
    int port = ;
    TcpSocket tcp(AF_INET, SOCK_STREAM);
    tcp.ConnectSocket(ip, port, SOCK_CLIENT);
    int pid = fork();
    if(pid < )
    {
        cout << "创建子进程失败" << endl;
    }
    else if(pid == )
    {
        cout << "子进程创建成功，负责向服务器发送消息" << endl;
        string strBuff = "";
        while(getline(cin, strBuff))
        {
            tcp.Send(tcp.m_Sock, strBuff);
            cout << "客户端发送消息：" << strBuff << endl;
            if(strBuff == "EOF")
            {
                cout << "子进程请求断开连接" << endl;
                break;
            }
        }
        cout << "子进程断开连接" << endl;
        exit();
    }
    else{
        cout << "父进程负责接收服务器信息" << endl;
        while()
        {
            string strBuff = tcp.Recv(tcp.m_Sock);
            if(strBuff.length() > )
            {
                cout << "客户端接收到信息：" << strBuff << endl;

                if(strBuff == "EOF")
                {
                    cout << "服务器请求断开连接" << endl;
                    break;
                }
            }
        }

        wait(NULL);
    }

    return ;
} 

client.cpp

要了解epoll的具体实现机制可以参考：https://blog.csdn.net/shenya1314/article/details/73691088