epoll 函数

epoll是Linux特有的I/O复用函数。它在现实和使用上与select,poll由很大的差异。首先,epoll使用一组函数来完成任务,而不是单个函数。其次,epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中,从而无须像select和poll那样每次调用都要重复传入文件描述符集或事件集。但epoll需要使用一个额外的文件描述符,来唯一标识内核中的这个事件表,这个文件描述符使用使用如下epoll_create函数来创建:

#inlcude<sys/epoll.h>

int epoll_create(int size)

size参数提示内核事件表需要多大。该函数返回的文件描述符将用作其他所有epoll系统调用的第一个参数,以指定要访问的内核事件表。


#include<sys/epoll.h>

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

fd参数是要操作的文件描述符,op参数则指定操作类型。操作类型有:

EPOLL_CTL_ADD, 往事件表中注册fd上的事件。

EPOLL_CTL_MOD, 修改fd上的注册事件。

EPOLL_CTL_DEL, 删除fd上的注册事件。


event参数指定事件,他是epoll_event结构指针类型。epoll_event的定义如下:

struct epoll_event

{

__unit32_t events;   //epoll事件

epoll_data_t data; //用户数据

};



#include<sys/epoll.h>

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

timeout参数与poll函数的timeout参数相同。

maxevents参数指定最多监听多少个事件,它必须大于0.

epoll_wait函数如果检测到事件,就将所有就绪的事件从内核事件表(由epfd参数指定)中复制到他的第二个参数events指向的数组中。这个数组值输出epoll_wait检测到的就绪事件。


epoll对文件描述符由两种模式为LT模式和ET模式。LT模式是默认的工作模式,在此模式下epoll相当与高效的poll。而当往内核事件表中注册一个文件描述符上的EPOLLET事件时,epoll将以ET模式来操作该文件描述符。

eg:

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10

int setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd, int  enable_et)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;
    if (enable_et)
    {
        event.events |= EPOLLET;
    }
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

void lt(struct epoll_event *events, int number, int epollfd, int listenfd)
{
    char buf[BUFFER_SIZE];
    for (int i = 0; i < number; i++)
    {
        int sockfd = events[i].data.fd;
        if (listenfd == sockfd)
        {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof(client_address);
            int connfd = accept(listenfd, (struct sockaddr *) &client_address, &client_addrlength);
            addfd(epollfd, connfd, 0);
        }
        else if (events[i].events & EPOLLIN)
        {
            printf("event trigger once\n");
            memset(buf, '\0', BUFFER_SIZE);
            int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
            if (ret <= 0)
            {
                close(sockfd);
                continue;
            }
            printf("get %d bytes of content: %s\n", ret, buf);
        }
        else 
        {
            printf("something else happened \n");
        }
    }
}

void et(struct epoll_event *events, int number, int epollfd, int listenfd)
{
    char buf[BUFFER_SIZE];
    for (int i = 0; i < number; i++)
    {
        int sockfd = events[i].data.fd;
        if (sockfd == listenfd)
        {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof(client_address);
            int connfd = accept(listenfd, (struct sockaddr *) &client_address, &client_addrlength);
            addfd(epollfd, connfd, 1);
        }
        else if(events[i].events & EPOLLIN)
        {
            printf("event trigger once\n");
            while(1)
            {
                memset(buf, '\0', BUFFER_SIZE);
                int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
                if (ret < 0)
                {
                    if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
                    {
                        printf("read later\n");
                        break;
                    }
                    close(sockfd);
                    break;
                }
                else if(ret == 0)
                {
                    close(sockfd);
                }
                else
                {
                    printf("get %d bytes of content: %s\n", ret, buf);
                }
            }
        }
        else 
        {
            printf("something else happened\n");
        }
    }
}

int main(int argc, char **argv)
{
    if (argc <= 2)
    {
        printf("usage: %s ip_address port_number\n", argv[0]);
        return 1;
    }

    const char *ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    assert(ret != -1);

    ret = bind(listenfd, (struct sockaddr *) &address, sizeof(address));
    assert(ret != -1);

    ret = listen(listenfd, 5);
    assert(ret != -1);

    struct epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd, listenfd, 1);

    while (1)
    {
        int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if(ret < 0)
        {
            printf("epoll failure!\n");
            break;
        }

        lt(events, ret, epollfd, listenfd);
        // et(events, ret, epolfd, listenfd);
    }
    close(listenfd);
    return 0;

}



2.eg:

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10

struct fds
{
    int epollfd;
    int sockfd;
};

int setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd, int oneshot)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    if (oneshot)
    {
        event.events |= EPOLLONESHOT;
    }
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

void reset_oneshot(int epollfd, int fd)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
}

void* worker(void *arg)
{
    int sockfd = ((struct fds *)arg)->sockfd;
    int epollfd = ((struct fds *)arg)->epollfd;
    printf("start new thread to receive data on fd: %d\n", sockfd);
    char buf[BUFFER_SIZE];
    memset(buf, '\0', BUFFER_SIZE);

    while(1)
    {
        int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
        if (ret == 0)
        {
            close(sockfd);
            printf("foreiner closed the connection\n");
            break;
        }
        else if (ret < 0)
        {
            if (errno == EAGAIN)
            {
                reset_oneshot(epollfd, sockfd);
                printf("read later\n");
                break;
            }
        }
        else 
        {
            printf("get content: %s\n", buf);
            sleep(5);
        }
    }
    printf("end thread recviving data on fd: %d\n", sockfd);
}

int main(int argc, char **argv)
{
    if (argc <= 2)
    {
        printf("usage: %s ip_address port_number\n", argv[0]);
        return -1;
    }

    const char *ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    assert( listenfd >= 0 );

    ret = bind(listenfd, (struct sockaddr *) &address, sizeof(address));
    assert( ret != -1 );

    ret = listen(listenfd, 5);
    assert( ret != -1 );

    struct epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert( epollfd != -1 );
    addfd( epollfd, listenfd, 0 );

    while (1)
    {
        int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if (ret < 0)
        {
            printf("epoll failure\n");
            break;
        }

        for(int i = 0; i < ret; i++)
        {
            int sockfd = events[i].data.fd;
            if (sockfd == listenfd)
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(client_address);
                int connfd = accept(listenfd, (struct sockaddr *) &client_address, &client_addrlength);
                addfd(epollfd, connfd, 1);
            }
            else if (events[i].events & EPOLLIN)
            {
                pthread_t thread;
                struct fds fds_for_new_worker;
                fds_for_new_worker.epollfd = epollfd;
                fds_for_new_worker.sockfd = sockfd;
                pthread_create(&thread, NULL, worker, (void *) &fds_for_new_worker);
            }
            else 
            {
                printf("something else happened \n");
            }
        }
    }
    close(listenfd);
    return 0;
}

<think>我们正在讨论Linux中的epoll函数。用户要求了解epoll的使用方法、原理以及详细解释。根据提供的引用,我们可以总结如下:epoll是Linux中用于I/O多路复用的机制,与select和poll相比,它在处理大量文件描述符时具有更高的效率。epoll通过三个系统调用实现:`epoll_create`、`epoll_ctl`和`epoll_wait`。 1. **`epoll_create`**:创建一个epoll实例,返回一个文件描述符。参数`size`在较新的内核中已忽略,但必须大于0(为了兼容性)。 2. **`epoll_ctl`**:用于向epoll实例中添加、修改或删除要监视的文件描述符及其事件。参数包括:- `epfd`: `epoll_create`返回的文件描述符。- `op`:操作类型(添加、修改、删除),分别对应`EPOLL_CTL_ADD`、`EPOLL_CTL_MOD`、`EPOLL_CTL_DEL`。- `fd`:要操作的文件描述符(如要监视的socket)。- `event`:指向`epoll_event`结构的指针,指定要监视的事件和关联的数据。 3. **`epoll_wait`**:等待事件的发生。参数包括:- `epfd`: epoll实例的文件描述符。-`events`:用于返回发生事件的数组。-`maxevents`:数组的最大长度(一次最多返回的事件数)。-`timeout`:超时时间(毫秒),-1表示阻塞,0表示立即返回,>0表示超时时间。 epoll的原理: -使用红黑树来存储要监视的文件描述符,这样在添加、删除和查找操作时效率较高(O(log n))。-使用就绪链表来存储已经就绪的事件,当调用`epoll_wait`时,只需检查这个链表是否为空即可,而不需要遍历所有文件描述符。-当有事件发生时,内核会通过回调函数将对应的文件描述符加入到就绪链表中,因此`epoll_wait`返回时只需要将链表中的事件复制到用户空间即可。epoll有两种工作模式:- **水平触发(LT)**:默认模式。只要文件描述符处于就绪状态(如读缓冲区非空,写缓冲区有空位),`epoll_wait`就会返回该事件。如果用户没有处理完数据,下次调用`epoll_wait`时还会再次通知。- **边缘触发(ET)**:只有状态变化时才会通知。用户必须一次处理完所有数据,因为后续不会再通知,直到有新的状态变化。ET模式效率更高,但需要非阻塞I/O并循环读取直到EAGAIN错误。根据引用[4],epoll反应堆模型是一种更高级的使用方式,它通过回调机制将事件处理逻辑与事件监视分离,提高程序的可扩展性。 接下来,我们将按照用户要求详细解释epoll的使用方法、原理,并给出示例代码。注意:在回答中,我们会引用提供的引用内容,并在引用段落末尾添加引用标识。</think>### Linux epoll 函数详解 #### 一、epoll 核心原理 epoll 是 Linux 高效 I/O 多路复用机制,其核心优势在于: 1. **红黑树管理描述符** - 使用红黑树存储监控的 fd($O(\log n)$ 时间复杂度) - 突破 select/poll 的 fd 数量限制(默认上限约 10 万)[^1][^3] 2. **就绪链表机制** - 内核通过回调函数将就绪 fd 加入链表 - `epoll_wait` 直接获取就绪链表,无需遍历所有 fd[^4] 3. **内存共享** - 内核与用户空间共享内存区域,避免数据拷贝[^2] #### 二、核心函数详解 ```c #include <sys/epoll.h> ``` 1. **`epoll_create(int size)`** - 创建 epoll 实例,返回 epoll 文件描述符 - `size`:内核事件表初始大小(Linux 2.6.8 后自动调整) - 示例:`int epfd = epoll_create(1);` 2. **`epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)`** - 操作事件监听表: | 操作类型 | 宏定义 | 功能 | |------------------|---------------------|--------------------------| | 添加事件 | `EPOLL_CTL_ADD` | 注册新 fd 到红黑树 | | 修改事件 | `EPOLL_CTL_MOD` | 修改已注册 fd 的监听事件 | | 删除事件 | `EPOLL_CTL_DEL` | 从红黑树中删除 fd | - `epoll_event` 结构: ```c typedef union epoll_data { void *ptr; int fd; // 目标文件描述符 uint32_t u32; uint64_t u64; } epoll_data_t; struct epoll_event { uint32_t events; // 监听事件集合 epoll_data_t data; // 用户数据 }; ``` - 事件标志: - `EPOLLIN`:数据可读 - `EPOLLOUT`:数据可写 - `EPOLLET`:边缘触发模式(默认水平触发) 3. **`epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)`** - 等待事件就绪: - `events`:输出参数,存储就绪事件数组 - `maxevents`:数组最大容量 - `timeout`:-1(阻塞)/0(非阻塞)/>0(超时毫秒) - 返回值:就绪 fd 数量 #### 三、工作模式对比 | 特性 | 水平触发(LT) | 边缘触发(ET) | |-----------------|-----------------------------------|-------------------------------------| | 触发条件 | 缓冲区有数据即触发 | 仅当 fd 状态变化时触发 | | 事件处理 | 可分批处理数据 | 必须一次性处理完所有数据 | | 代码复杂度 | 较低 | 需非阻塞 I/O + 循环读取 | | 性能 | 一般 | 更高(减少 epoll_wait 调用次数) | | 默认模式 | ✓ | 需显式设置 `EPOLLET` | **ET 模式关键代码**: ```c // 非阻塞读取直到 EAGAIN while((n = read(fd, buf, BUF_SIZE)) > 0) { process_data(buf, n); } if (n == -1 && errno == EAGAIN) { // 数据已读完 } ``` #### 四、epoll 反应堆模型 高级用法将事件处理抽象为: 1. 事件监听与回调分离 2. 事件触发时自动调用预设回调函数 3. 通过 `epoll_data.ptr` 携带处理上下文[^4] ```c struct event_handler { int fd; void (*callback)(int fd, void* arg); }; // 注册回调 event_handler* h = malloc(sizeof(event_handler)); h->fd = sockfd; h->callback = &read_callback; ev.data.ptr = h; epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev); ``` #### 五、性能对比 $$ \text{时间复杂度} = \begin{cases} O(n) & \text{select/poll} \\ O(1) & \text{epoll(就绪 fd 比例恒定时)} \end{cases} $$ 当活跃连接数占比 $k$ 时,epoll 时间复杂度为 $O(k \cdot \log n)$,在 $k \ll n$ 时优势显著[^1][^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值