I/O复用技术—select函数和epoll函数分析

1 I/O复用技术概念

将套接字进行捆绑，利用最少限度的资源收发最多的数据

2 select函数

2.1 原型

int select(int maxfd, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, struct timeval * timeout);

    2.1.1 参数解析

maxfd：所监视对象文件描述符的总数

readfds：记录所有"是否存在待读取数据"的套接字文件描述符

writefds：记录所有"是否存在无阻塞传输数据"的套接字文件描述符

exceptfds：记录所有"是否发生异常"的套接字文件描述符

timeout：设置超时监听的时间

       返回值类型：发生错误------返回-1；时间超时------返回0；正常执行-----返回大于0的文件描述符

   2.1.2 结构体解析

typedef struct fd_set {
    u_int fd_count;  //无符号整形，监视的文件描述符的范围
　  socket fd_array[FD_SETSIZE]; //存储文件描述符的数组
} fd_set;

typedef struct timeval {
    long tv_set;  //秒
    long tv_usec; //毫秒
}

2.2 函数执行流程

2.3 fd_set结构体位的设置

FD_ZERO(fd_set *fdset); //将fdset参数初始化为0
FD_SET(int fd, fd_set* fdset); //在参数fdset中注册文件描述符fd信息
FD_CLR(int fd, fd_set* fdset); //在参数fdset中清除注册文件描述符fd信息
FD_ISSET(int fd, fd_set *fdset); //检测参数fdset中是否注册文件描述符fd信息

2.4 I/O复用具体使用

#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/select.h>
#define BUF_SIZE 30

int main(int argc, char* argv[])
{
    fd_set reads, temps;
    int result, str_len; 
    char buf[BUF_SIZE];
    struct timeval timeout;
    FD_ZERO(&reads); //步骤一,初始化监视范围
    FD_SET(0, &reads); //第1个位置是监听标准的输入流

    while (1){
        temps = reads;
        timeout.tv_sec = 5;
        timeout.tv_usec = 0;
        result = select(1, &temps, 0, 0, &timeout); //步骤二，开始监听文件描述符
        if (result == -1){ //发生异常
            puts("select() error!");
            break;
        }
        else if (result == 0){ //超时
            puts("Time-out!");
        }
        else{
            if (FD_ISSET(0, &temps)){ //存在输入流,读取输出缓冲数据
                str_len = read(0, buf, BUF_SIZE);
                buf[str_len] = 0;
                printf("message from console: %s", buf);
            }
        }
    }

    return 0;
}

3 epoll函数

3.1 epoll_create

3.1.1 函数原型

int epoll_create(int size); //创建epoll例程

3.1.2 参数解析

      size：创建例程的数量，只作为操作系统参考的数值，最终创建例程的数量取决于操作系统

      返回值：创建成功-----返回epoll例程的文件描述符; 失败------返回-1

3.2 epoll_ctl

3.2.1 函数原型

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); //epfd例程对文件描述符进行操作

3.2.2 参数解析

      epfd：注册监视epoll例程的文件描述符，即epoll_create的返回值

      op：监视对象的增加、删除或更改等操作

EPOLL_CTL_ADD   //将文件描述符注册到epoll例程
EPOLL_CTL_DEL   //从例程中删除文件描述符
EPOLL_CTL_MOD   //更改注册的文件描述符

      fd：需要注册的套接字文件描述符

      event：监视对象的事件类型

struct epoll_event { 
    uint32_t events; //注册监听事件的类型 EPOLLIN--读取数据   EPOLLET--边缘触发得到事件通知
    epoll_data_t data; //存储监听文件描述符的相关信息
}; 

typedef union epoll_data { 
    void *ptr; 
    int fd; //套接字文件描述符
    uint32_t u32; 
    uint64_t u64; 
} epoll_data_t;

3.3  epooll_wait

3.3.1 函数原型

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

3.3.2 参数解析

epfd：创建例程的文件描述符

events：保存发生事件的文件描述符集合的地址，跟epoll_ctl函数的参数event不是一个值

maxevents：保存最大事件数

timeout：毫秒为单位，传递-1代表一直等待注册事件的发生

返回值：成功----返回0; 失败---返回0

3.4 I/O复用模型epoll执行流程

创建例程create_poll——>在例程中注册套接字文件描述符的操作epoll_ctl——>等待监听事件的发生epoll_wait

3.5 实例

3.5.1 条件触发

        概念：只要输入缓存有数据就会一直通知该事件

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/epoll.h>
#define BUF_SIZE 30
#define EPOLL_SIZE 10

int main(int argc, char* argv[])
{
    int str_len;
    char buf[BUF_SIZE];
    struct epoll_event* ep_events;
    struct epoll_event event;
    int epfd, event_cnt;

    epfd = epoll_create(EPOLL_SIZE); //创建例程
    ep_events = malloc(sizeof(struct epoll_event)*EPOLL_SIZE);
    event.events = EPOLLIN;
    event.data.fd = 0; 
    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event); //在例程中注册标准输入的文件描述符

    while (1){
        event_cnt = epoll_wait(epfd, ep_events, EPOLL_SIZE, -1); //监听输入
        if (event_cnt == -1){ //失败，退出
            puts("epoll_wait() error");
            break;
        }
        str_len = read(0, buf, BUF_SIZE); 
        buf[str_len] = 0;
        printf("message from console: %s", buf);
    }
    return 0;
}

3.5.2 边缘触发

        概念：仅注册一次事件，即输入缓存还有数据，也不会再次通知

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/epoll.h>
#define BUF_SIZE 4
#define EPOLL_SIZE 10

void setnonblockingmode(int fd)
{
    int flag = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flag|O_NONBLOCK);
}

int main(int argc, char* argv[])
{
    int str_len;
    char buf[BUF_SIZE];
    struct epoll_event* ep_events;
    struct epoll_event event;
    int epfd, event_cnt;

    epfd = epoll_create(EPOLL_SIZE);
    ep_events = malloc(sizeof(struct epoll_event)*EPOLL_SIZE);
    setnonblockingmode(0); //无阻塞
    event.events = EPOLLIN | EPOLLET; //边缘触发
    event.data.fd = 0; 
    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event);  

    while (1){
        event_cnt = epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
        if (event_cnt == -1){
            puts("epoll_wait() error");
            break;
        }
        char msg[100] = "";
        int len = 0;
        while (1){ //读取所有缓存区的内存
            str_len = read(0, buf, BUF_SIZE);
            if (str_len < 0 && errno == EAGAIN) break; //防止等待消息，发生错误
            strcat(msg, buf);
            len += str_len;        
        }     
        msg[len] = 0;
        printf("message from console: %s", msg);
    }
    return 0;
}

4 select和epoll对比和分析

[1]https://blog.csdn.net/guozhiyingguo/article/details/52912298

[2]《TCP/IP网络编程》—尹圣雨