linux网络编程epoll详解

epoll原理解析

从socket接收网络数据说起：
1、网络传输中，网卡会把接收到的数据写入内存，网卡向 CPU 发出一个中断信号，操作系统便能得知有新数据到来，再通过网卡中断程序去处理数据。
2、进程执行socket()函数创建socket，这个socket 对象包含了发送缓冲区、接收缓冲区与等待队列等成员，等待队列指向所有需要等待该 Socket 事件的进程。
3、假设上面socket进程为A，另外内核还有进程B和C，内核会分时执行运行状态的ABC进程。
4、当程序执行到 Recv 时，操作系统会将进程 A 从工作队列移动到该 Socket 的等待队列中，A进程被阻塞，不会往下执行代码，也就不会占用CPU资源，此时内核只剩B和C进程分时执行。
5、一个socket 对应着一个端口号，而网络数据包中包含了 IP 和端口的信息，内核可以通过端口号找到对应的socket。
6、当socket 接收到数据后，操作系统将该socket 等待队列上的进程重新放回到工作队列，该进程变成运行状态，继续执行代码。同时由于 socket 的接收缓冲区已经有了数据，Recv 可以返回接收到的数据。

epoll的设计思路：
服务服务器需要管理多个客户端连接，而Recv 只能监视单个socket，epoll 的诞生就是高效地监视多个socket。
epoll是select 和poll的增强版本，epoll的改进：
1、epoll将“维护等待队列”和“阻塞进程“分离，先用 epoll_create 创建一个epoll 对象 Epfd，再通过 epoll_ctl 将需要监视的socket 添加到 Epfd 中，最后调用 epoll_wait 等待数据。
2、内核维护一个“就绪列表”Rdlist ，引用收到数据的 Socket，当进程被唤醒后，只要获取 Rdlist 的内容，就能够知道哪些 Socket 收到数据。

epoll的工作流程
1、当某个进程调用 epoll_create 方法时，内核会创建一个 eventpoll 对象(Epfd)，eventpoll 对象是文件系统中的一员，有等待队列。Rdlist 是eventpoll的成员。
2、创建 Epoll 对象后，可以用 epoll_ctl 添加或删除所要监听的 Socket，内核会将 eventpoll 添加到这个 Socket 的等待队列中。当 Socket 收到数据后，中断程序会操作 eventpoll 对象，而不是直接操作进程。
3、当 Socket 收到数据后，中断程序会给 eventpoll 的就绪列表Rdlist 添加这个Socket 引用。eventpoll 对象相当于 Socket 和进程之间的中介，Socket 的数据接收并不直接影响进程，而是通过改变 eventpoll 的就绪列表来改变进程状态。当程序执行到 epoll_wait 时，如果 Rdlist 已经引用了 Socket，那么 epoll_wait 直接返回，如果 Rdlist 为空，阻塞进程。
4、假设计算机正在运行进程 A 和进程 B，在某时刻进程 A 运行到了 epoll_wait 语句。 内核会将进程 A 放入 eventpoll 的等待队列中，阻塞进程。当 Socket 接收到数据，中断程序一方面修改 Rdlist，另一方面唤醒 eventpoll 等待队列中的进程，进程 A 再次进入运行状态。因为 Rdlist 的存在，进程 A 可以知道哪些 Socket 发生了变化。

epoll数据结构
eventpoll结构体包含了 Lock、MTX、WQ(等待队列)与 Rdlist 等成员。
就绪列表Rdlist：是一种能够快速插入和删除的数据结构，Epoll 使用双向链表来实现就绪队列。
索引结构RBR：epoll使用红黑树作为索引结构来保存监听的socket列表。

epoll提供的接口

1、调用epoll_create建立epoll对象，创建一个eventpoll结构体，包括rbr（在内核cache里创建红黑树用于存储以后epoll_ctl传来的socket）和rdllist（用于存储准备就绪事件的向链表）。

//创建一个epoll实例(本质是红黑树),也占用个文件描述符，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
//返回值size，用来告诉内核这个监听的数目一共有多大，自从Linux 2.6.8开始，size参数被忽略，但是依然要大于0。
int epoll_create(int size);
struct eventpoll {
    
    
　　...
　　/*红黑树的根节点，这棵树中存储着所有添加到epoll中的事件，
　　也就是这个epoll监控的事件*/
　　struct rb_root rbr;
　　/*双向链表rdllist保存着将要通过epoll_wait返回给用户的、满足条件的事件*/
　　struct list_head rdllist;
　　...
};

2、调用epoll_ctl向epoll对象中添加或删除socket事件，所有添加到epoll中的事件都会与设备(如网卡)驱动程序建立回调关系，向内核注册回调函数，用于当中断事件来临时向准备就绪链表中插入数据。

/**
 * @brief 将监听的文件描述符添加到epoll对象中
 * @param epfd epoll_create的返回值，epoll对象
 * @param op   要执行的动作：EPOLL_CTL_ADD：注册新的fd到epfd中；
                           EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
                           EPOLL_CTL_DEL：从epfd中删除一个fd；

 * @param fd   要执行动作的fd
 * @param event告诉内核需要监听什么事件，epoll_event结构体：
 *     struct epoll_event {
            __uint32_t events; // Epoll events
            epoll_data_t data; // User data variable
        };
        events可以是以下几个宏的集合(常用的IN/OUT/ERR/ET)：
            EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
            EPOLLOUT：表示对应的文件描述符可以写；
            EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
            EPOLLERR：表示对应的文件描述符发生错误；
            EPOLLHUP：表示对应的文件描述符被挂断；
            EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
            EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里。
        epoll_data_t联合体定义如下：(注意是联合体)
            typedef union epoll_data
            {
              void *ptr;		//可以传递任意类型数据，常用来传 回调函数
              int fd;		//可以直接传递客户端的fd
              uint32_t u32;
              uint64_t u64;
            } epoll_data_t;

 * @return 返回值：成功返回0。发生错误时返回-1并设置errno
 */
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); 

3、当epoll_wait调用时，观察rdllist双向链表里有没有数据。有数据就返回，没有数据就sleep，等到timeout时间到后即使链表没数据也返回。

/**
 * @brief           等待epoll事件从epoll实例中发生
 * @param epfd      等待的监听描述符，也就是哪个池子中的内容
 * @param events    出参，指针，指向epoll_event的数组，监听描述符中的连接描述符就绪后，将会依次将信息填入
 * @param maxevents 表示每次能处理的最大事件数，告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size
 * @param timeout   等待时间，要是有连接描述符就绪，立马返回，如果没有，timeout时间后也返回，单位是ms；（超时情况下，0会立即返回，-1将不确定，也有说法说是永久阻塞）
 * @return          成功返回为请求的I / O准备就绪的文件描述符的数目，如果在请求的超时毫秒内没有文件描述符准备就绪，则返回零。发生错误时，epoll_wait（）返回-1并正确设置errno。
 */
int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout); 

epoll的触发模式

epoll的两种触发模式：
边沿触发vs水平触发
epoll事件有两种模型，边沿触发：edge-triggered (EPOLLET)， 水平触发：level-triggered (EPOLLLT)
水平触发(level-triggered),是epoll的默认模式
socket接收缓冲区不为空 有数据可读 读事件一直触发
socket发送缓冲区不满 可以继续写入数据 写事件一直触发
边沿触发(edge-triggered)
socket的接收缓冲区状态变化时触发读事件，即空的接收缓冲区刚接收到数据时触发读事件
socket的发送缓冲区状态变化时触发写事件，即满的缓冲区刚空出空间时触发读事件
边沿触发仅触发一次，水平触发会一直触发。
开源库:libevent 采用水平触发， nginx 采用边沿触发。

epoll代码示例

创建udp客户端

    int32_t fd;
    struct sockaddr_in remote_addr;
}UdpClientDef;

int32_t CreateUdpClient(UdpClientDef *udp, char *remoteIp,int32_t remotePort)
{
    
    
    if (udp == NULL)		return -1;
    udp->fd = -1;

    udp->fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if(udp->fd < 0)
    {
    
    
        printf("create socket error,udp->fd=%d\n",udp->fd);
        perror("error:");///linuxAPI,打印输出上一个函数发生的错误,"error:"会首先打印
        return -1;
    }

    udp->remote_addr.sin_family = AF_INET;
    udp->remote_addr.sin_port = htons(remotePort);
    udp->remote_addr.sin_addr.s_addr = inet_addr(remoteIp);
    return 0;
}

int32_t udp_sendData(UdpClientDef *udp, char *data, int32_t nb)
{
    
    
    if (udp == NULL  || data==NULL)
        return -1;
    return sendto(udp->fd, data, nb, 0, (struct sockaddr*) &udp->remote_addr,sizeof(struct sockaddr));
}

使用epoll线程监听udp的接收

#include <sys/epoll.h>
#include <unistd.h>

UdpClientDef *pUdpClientDef;
int epollFD;
pthread_t tid;
void* threadFunc(void *obj)
{
    
    
    MainWindow* mw = (MainWindow*)obj;
    mw->dealThread();
    return nullptr;
}

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow)
{
    
    
    ui->setupUi(this);
    epollFD = epoll_create(1);

    pUdpClientDef = new UdpClientDef;
    CreateUdpClient(pUdpClientDef,"192.168.1.22",9090);

    struct epoll_event evt;
    evt.events = EPOLLIN;
    evt.data.fd = pUdpClientDef->fd;
    epoll_ctl(epollFD,EPOLL_CTL_ADD,pUdpClientDef->fd,&evt);

    pthread_create(&tid,nullptr,threadFunc,this);

}

void MainWindow::dealThread()
{
    
    
    const int kEpollDefaultWait = 100;//超时时长，单位ms
    struct epoll_event alive_events[1024];

    while (true)
    {
    
    
        int num = epoll_wait(epollFD, alive_events, 1024, kEpollDefaultWait);

        for (int i = 0; i < num; ++i)
        {
    
    
            int fd = alive_events[i].data.fd;
            int events = alive_events[i].events;

            if ( events & EPOLLIN )
            {
    
    
                char buffer[2048] = {
    
     0 };
                socklen_t src_len = sizeof(struct sockaddr_in);
                struct sockaddr_in src;
                memset(&src, 0, src_len);
                memset(buffer, 0, 2048);
                if (recvfrom(fd, buffer, 2048, 0,	(struct sockaddr*) &src, &src_len) > 0)
                    printf("buffer=%s\n",buffer);
            }
        }
        usleep(100);
    }
}

void MainWindow::on_pushButton_clicked()
{
    
    
    std::string msg = "hello";
    udp_sendData(pUdpClientDef,(char*)msg.c_str(),msg.size());
}