Linux IO 模型-优快云博客

本文链接：https://blog.youkuaiyun.com/fzc2022/article/details/148310594

1.阻塞式IO：最常见、效率低、不浪费CPU

阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O 。

学习的读写函数在调用过程中会发生阻塞，相关函数如下：

读操作中的read

读阻塞--> 需要读缓冲区中有数据可读，读阻塞解除

写操作中的write

写阻塞--> 阻塞情况比较少，主要发生在写入的缓冲区的大小小于要写入的数据量的情况下，写操作不进行任何拷贝工作，将发生阻塞，一旦缓冲区有足够的空间，内核将唤醒进程，将数据从用户缓冲区拷贝到相应的发送数据缓冲区。

2.非阻塞式IO: 轮询、耗费CPU、可以同时处理多路IO

当我们设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。
当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称做polling）。
应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。

这种模式使用中不普遍。

2.1 通过函数自带参数设置

IPC_NOWAIT：非阻塞，不管有没有消息都立即返回。所以可能会读不到消息，需要轮询读，直到读到了退出轮询。

2.2 通过设置文件描述符的属性设置非阻塞

#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ ); //file control
功能：设置文件描述符属性
参数：
   fd:文件描述符
   cmd：设置方式 - 功能选择
        F_GETFL  获取文件描述符的状态信息     第三个参数化忽略
        F_SETFL  设置文件描述符的状态信息     通过第三个参数设置
        O_NONBLOCK  非阻塞
        O_ASYNC     异步
        O_SYNC      同步
  arg:设置的值  in
返回值：
      特殊选择返回特殊值 F_GETFL  返回的状态值(int)
      其他：成功0  失败-1，更新errno
使用：0为例
  0原本：阻塞、读权限  修改或添加非阻塞
  int flags=fcntl(0,F_GETFL);//1.获取文件描述符原有的属性信息
  flags = flags | O_NONBLOCK;//2.修改添加模式为非阻塞
  fcntl(0,F_SETFL,flags);     //3.设置修改后的模式

例子：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include<string.h>

int main(int argc, char const *argv[])
{
    //1. 获取文件描述符属性
    int flag = fcntl(0, F_GETFL);

    //2. 修改文件描述符的属性为非阻塞
    flag |= O_NONBLOCK;

    //3. 设置文件描述符属性
    fcntl(0, F_SETFL, flag);

    char buf[32] = "";
    while (1)
    {
        fgets(buf, 32, stdin);
        printf("%s\n", buf);
        memset(buf, 0, sizeof(buf));
        printf("##################\n");
        sleep(2);
    }
    return 0;
}

修改回去的方法

1.关闭终端，重新打开（但不能再运行这个程序）。

2.将flag |= O_NONBLOCK修改为flag &= ~O_NONBLOCK重新运行一次程序。

3.信号驱动IO：异步通知方式，底层驱动的支持

查看鼠标是哪个文件

信号驱动I/O是一种异步I/O模型，通过操作系统向应用程序发送信号来通知数据可读或可写，从而避免轮询或阻塞等待。

异步通知：异步通知是一种非阻塞的通知机制，发送方发送通知后不需要等待接收方的响应或确认。通知发送后，发送方可以继续执行其他操作，而无需等待接收方处理通知。

通过信号方式，当内核检测到设备数据后，会主动给应用发送信号SIGIO。
应用程序收到信号后做异步处理即可。
应用程序需要把自己的进程号告诉内核，并打开异步通知机制。

//1. 设置文件描述符和进程号提交给内核驱动
//一旦fd又事件响应，则内核驱动会给进程发送一个SIGIO的信号
fcntl(fd,F_SETOWN,getpid());

//2. 设置异步通知
int flag;
flag = fcntl(fd, F_GETFL); //获取原属性
flag |= O_ASYNC;        //给flag设置异步 O_ASNC 异步
fcnl(fd,F_SETFL,flag);   //将修改的属性设置进去，此时fd为异步

//3. signal捕捉SIGIO信号
//一旦内核给进程发送SIGI信号，则执行handler
signal(SIGIO,hander);

例子：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <signal.h>
int fd;
void handler(int sig)
{
    char buf[32] = "";
    read(fd, buf, sizeof(buf));
    printf("%s\n", buf);
}

int main(int argc, char const *argv[])
{
    fd = open("/dev/input/mouse0", O_RDONLY);
    if (fd < 0)
    {
        perror("open err");
        return -1;
    }

    //1. 设置文件描述符和进程号提交给内核驱动
    //一旦fd有事件发生，则内核给进程发送一个SIGIO信号
    fcntl(fd, F_SETOWN, getpid());

    //2. 设置异步通知
    int flag;
    flag = fcntl(fd, F_GETFL); //获取原属性
    flag |= O_ASYNC;           //将flag修改为异步
    fcntl(fd, F_SETFL, flag);  //将修改属性设置进去，此时fd为异步

    //3.捕捉SIGIO信号，一旦内核发送SIGIO信号则执行handler函数
    signal(SIGIO, handler);

    while (1)
    {
        printf("玩一玩\n");
        sleep(1);
    }

    return 0;
}

4.IO多路复用: select/poll/epoll

应用程序中同时处理多路输入输出流，若采用阻塞模式，得不到预期的目的；
若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
若设置多个进程/线程，分别处理一条数据通路，将新产生进程/线程间的同步与通信问题，使程序变得更加复杂；
比较好的方法是使用I/O多路复用技术。其基本思想是：

先构造一张有关描述符的表（最大1024），然后调用一个函数。
当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。

4.1 select

4.1.1 特点

1.一个进程最多只能监听1024个文件描述符

2.select被唤醒之后需要重新轮询，效率相对较低

3.select每次都会清空未发生响应的文件描述符，每次拷贝都需要从用户空间到内核空间，效率低，开销大

4.1.2 编程步骤

1.先构造一张关于文件描述符的表

2.清空表FD_ZERO

3.将关心的文件描述符添加到表中 FD_SET

4.调用select

5.判断哪一个或者哪些文件描述符发生了事件FD_ISSET

6.做对应的逻辑处理

4.1.3 函数接口

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);
功能：
	实现IO的多路复用
参数：
	nfds：关注的最大的文件描述符+1
   readfds：关注的读表
	writefds：关注的写表 
	exceptfds：关注的异常表
	timeout：超时的设置
		NULL：一直阻塞，直到有文件描述符就绪或出错
		时间值为0：仅仅检测文件描述符集的状态，然后立即返回
		时间值不为0：在指定时间内，如果没有事件发生，则超时返回0，并清空设置的时间值

struct timeval {
    long tv_sec;		/* 秒 */
    long tv_usec;	/* 微秒 = 10^-6秒 */
};

返回值：
	成功时返回准备好的文件描述符的个数
	0：超时检测时间到并且没有文件描述符准备好	
    -1 ：失败
注意：
	select返回后，关注列表中只存在准备好的文件描述符

操作表：
void FD_CLR(int fd, fd_set *set); //清除集合中的fd位
void FD_SET(int fd, fd_set *set);//将fd放入关注列表中
int  FD_ISSET(int fd, fd_set *set);//判断fd是否产生操作 是：1 不是：0
void FD_ZERO(fd_set *set);//清空关注列表

例子：

#include <stdio.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char const *argv[])
{
    //打开鼠标文件描述符
    int fd_mouse = open("/dev/input/mouse0", O_RDONLY);
    if (fd_mouse < 0)
    {
        perror("open mouse err");
        return -1;
    }
    printf("fd_mouse: %d\n", fd_mouse);

    //1. 创建表, 后面需要利用select实现 fd_mouse:鼠标 0:键盘
    fd_set readfds;

    //循环判断是哪个文件描述符产生了IO操作然后做相应的处理
    while (1)               //注意：必须要重置表，因为select的输入的参数会被内核修改，所以每次循环要重新初始化表并添加需要关心的文件描述符。
    {
        //2. 清空表
        FD_ZERO(&readfds);

        //3. 将关心的文件描述符添加到表中
        FD_SET(fd_mouse, &readfds); //鼠标
        FD_SET(0, &readfds);        //键盘

        //4. 调用select函数进行监听描述符是否产生操作
        if (select(fd_mouse + 1, &readfds, NULL, NULL, NULL) < 0)
        {
            perror("select err");
            return -1;
        }

        //5. 判断哪个文件描述符产生了操作
        char buf[32] = "";
        if (FD_ISSET(0, &readfds))
        {
            //6. 做对应的逻辑处理
            scanf("%s", buf);      //如果没有这句则如果键盘输入内容以后则内核输入缓冲区未清空，select会持续检测到事件
            printf("keyboard: %s\n", buf);
        }

        if (FD_ISSET(fd_mouse, &readfds))
        {
            ssize_t n = read(fd_mouse, buf, sizeof(buf) - 1); //预留1个字节给'\0'
            buf[n] = '\0';                                    //手动添加'\0', 因为read不会补'\0'
            printf("mouse: %s\n", buf);
        }
    }
    close(fd_mouse);
    return 0;
}

具体过程演示：

4.1.4超时检测

1）概念

什么是网络超时检测呢，比如某些设备的规定，发送请求数据后，如果多长时间后没有收到来自设备的回复，那么需要做出一些特殊的处理

比如: 链接wifi的时候，等了好长时间也没有连接上，此时系统会发送一个消息：网络连接失败；

2）必要性

1.避免进程在没有数据时无限制的阻塞;

2.规定时间未完成语句应有的功能,则会执行相关功能

4.2 poll

int poll(struct pollfd *fds, nfds_t nfds, int timeout);
功能：同select相同实现IO的多路复用
参数：
    fds：指向一个结构体数组的指针，用于指定测试某个给定的文件描述符的条件。
    nfds：指定的第一个参数数组的元素个数。
    
    timeout：超时设置 
        -1：永远等待 
         0：立即返回 
        >0:等待指定的毫秒数
        
    struct pollfd 
    {
        int fd; // 文件描述符
        short events; // 等待的事件
        short revents; // 实际发生的事件
    };
返回值：
    成功时返回结构体中 revents 域不为 0 的文件描述符个数
    0： 超时前没有任何事件发生时，返回 0
    -1：失败并设置 errno

4.2.1特点

1.优化文件描述符的限制，文件描述符的限制取决于系统

2.poll被唤醒之后要重新轮询一遍，效率相对低

3.poll不需要重新构造表，采用结构体数组，每次都需要从用户空间拷贝到内核空间

4.2.2实现过程

1.创建一个表, 也就是一个结构体数组 struct pollfd fds[100];

2.将关心的描述符条件到表里并赋予事件

3.循环更新表 while(1) {poll(); }

4.逻辑判断: if(fds[i].revents == POLLIN) {}

例子：

#include <stdio.h>
#include <sys/poll.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char const *argv[])
{
    //打开鼠标文件描述符
    int fd_mouse = open("/dev/input/mouse0", O_RDONLY);
    if (fd_mouse < 0)
    {
        perror("open mouse err");
        return -1;
    }
    printf("fd_mouse: %d\n", fd_mouse);

    //1. 创建表
    struct pollfd fds[2];

    //2. 添加关心的文件描述符到表中也就是数组中，并且赋予事件
    fds[0].fd = 0;          //键盘
    fds[0].events = POLLIN; //监听读事件
    //fd[0].revents是实际发生的事件

    fds[1].fd = fd_mouse; //鼠标
    fds[1].events = POLLIN;

    //3. 保存一下数组最后一个元素的下标
    int last = 1;

    //4. 循环调用poll监听，然后判断是哪个文件描述符产生了IO事件
    while (1)
    {
        int t = poll(fds, last + 1, 2000);
        if (t < 0)
        {
            perror("poll err");
            return -1;
        }
        else if (t == 0)
        {
            printf("time out\n");
            continue;
        }

        //5. 判断结构体内文件描述符实际发生事件是否存在
        char buf[32] = "";
        if (fds[0].revents == POLLIN)
        {
            //6. 根据不同描述符发生不同逻辑处理
            fgets(buf, sizeof(buf), stdin);
            printf("keyborad: %s\n", buf);
        }

        if (fds[1].revents == POLLIN)
        {
            int n = read(fd_mouse, buf, sizeof(buf) - 1);
            buf[n] = '\0';
            printf("%s\n", buf);
        }
    }

    close(fd_mouse);
    return 0;
}

注意：因为有revents这个成员，表示实际发生的事件，所以对其他成员没有影响。调用poll后会把实际发生的是按放到revents中，判断它就可以了所以不用清空表。

4.3 epoll

4.3.1特点

1.监听的最大的文件描述符没有个数限制

2.异步IO，epoll当有事件产生被唤醒之后，文件描述符主动调用callback函数（回调函数）直接拿到唤醒的文件描述符，不需要轮询，效率高

3.epoll不需要重新构造文件描述符表，只需要从用户空间拷贝到内核空间一次。

4.4 总结

	select	poll	epoll
监听个数	一个进程最多监听1024个文件描述符	由程序员自己决定	百万级
方式	每次都会被唤醒，都需要重新轮询	每次都会被唤醒，都需要重新轮询	红黑树内callback自动回调，不需要轮询
效率	文件描述符数目越多，轮询越多，效率越低	文件描述符数目越多，轮询越多，效率越低	不轮询，效率高
原理	每次使用select后，都会清空表每次调用select，都需要拷贝用户空间的表到内核空间内核空间负责轮询监视表内的文件描述符，将发生事件的文件描述符拷贝到用户空间，再次调用select，如此循环	不会清空结构体数组每次调用poll，都需要拷贝用户空间的结构体到内核空间内核空间负责轮询监视结构体数组内的文件描述符，将发生事件的文件描述符拷贝到用户空间，再次调用poll，如此循环	不会清空表 epoll中每个fd只会从用户空间到内核空间只拷贝一次（上树时）通过epoll_ctl将文件描述符交给内核监管，一旦fd就绪，内核就会采用callback的回调机制来激活该fd，epoll_wait便可以收到通知（内核空间到用户空间的拷贝
特点	一个进程最多能监听1024个文件描述符 select每次被唤醒，都要重新轮询表，效率低 select每次都清空未发生相应的文件描述符，每次都要拷贝用户空间的表到内核空间	优化文件描述符的个数限制 poll每次被唤醒，都要重新轮询，效率比较低（耗费cpu） poll不需要构造文件描述符表（也不需要清空表），采用结构体数组，每次也需要从用户空间拷贝到内核空间	监听的文件描述符没有个数限制（取决于自己的系统）异步IO，epoll当有事件产生被唤醒，文件描述符会主动调用callback函数拿到唤醒的文件描述符，不需要轮询，效率高 epoll不需要构造文件描述符的表，只需要从用户空间拷贝到内核空间一次。
结构	数组	数组	红黑树+就绪链表
开发复杂度	低	低	中