IO模型笔记

已于 2023-02-12 17:00:36 修改
阅读量101 收藏
点赞数 2
文章标签： 网络 linux
于 2023-02-02 19:11:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ahhhhhhhhhhghhh/article/details/128855630
版权
本文介绍了不同类型的IO模型，包括阻塞IO、非阻塞IO、信号驱动IO以及IO多路复用的实现方式，如select、poll和epoll。重点讨论了它们的特点、使用场景和效率问题，特别是多路复用在处理多路IO时的优势和不同实现的优缺点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

阻塞IO

非阻塞IO

信号驱动IO

IO多路复用

 select实现多路复用

 poll实现多路复用

epoll实现多路复用

阻塞IO

特点：最简单、最常用、效率低

相关函数如下：
        读操作中的read、recv、recvfrom
                读阻塞--》需要读缓冲区中有数据可读，读阻塞解除
        写操作中的write、send
                写阻塞--》阻塞情况比较少，主要发生在写入的缓冲区的大小小于要写入的数据量的情况下，写操作不进行任何拷贝工作，将发生阻塞，一旦缓冲区有足够的空间，内核将唤醒进程，将数据从用户缓冲区拷贝到相应的发送数据缓冲区。
            其他操作：accept、connect

非阻塞IO

特点：可以处理多路IO；需要轮询，浪费CPU资源

设置非阻塞IO：

        1、通过函数参数设置
                Recv函数最后一个参数写为0，为阻塞，写为MSG_DONTWAIT：表示非阻塞。
                非阻塞，循环检测，是否有数据发过来，轮询消耗CPU资源。
        2.通过fcntl函数设置文件描述符属性
                 1.获取原属性        int  flag = fcntl(0, F_GETFL);
                 2.添加新属性        flag |= O_NONBLOCK;
                 3.将属性返回        fcntl(0, F_SETFL, flag);

信号驱动IO

特点：异步通知模式，需要底层驱动的支持

步骤：

        1.设置将APP进程号提交给内核驱动        fcntl(fd,F_SETOWN,getpid());

        2.设置异步，O_ASYNC                   

                   flags = fcntl(fd, F_GETFL);       

                   flags |= O_ASYNC; 

                   fcntl(fd, F_SETFL, flags);

        3.捕捉信号          signal(SIGIO,handler)

IO多路复用

基本流程：

        1. 先构造一张有关文件描述符的表(集合、数组); 
        2. 将你关心的文件描述符加入到这个表中;
        3. 然后调用一个函数。 select / poll 
        4. 当这些文件描述符中的一个或多个已准备好进行I/O操作的时候该函数才返回(阻塞)。
        5. 判断是哪一个或哪些文件描述符产生了事件(IO操作);
        6. 做对应的逻辑处理;

 select实现多路复用

1.select检测1024个文件描述符，open可以打开的文件描述符也是1024 
2.在select中0~2预备存储标准输入、标准输出、标准出错（需要手动添加到表中），文件描述符存储在值对应下标中
3.事件产生，文件描述符会保留1；没有产生事件的会置0
4.表会发生改变，需要在select前备份表
5.FD_ISSET，判断后不会将位在表中清零    //socket=3，recv参数不能传socket
6.表中文件描述符close，记得使用FD_CLR释放
7. select被唤醒之后需要重新轮询一遍驱动的poll函数，效率比较低（消耗CPU资源）;
8. select每次会清空表，每次都需要拷贝用户空间的表到内核空间，效率低（一个进程0~4G，0~3G是用户态，3G~4G是内核态，拷贝是非常耗时的）;

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    //1.创建套接字 socket
    int sockfd, acceptfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    printf("socket ok %d\n", sockfd);

    //填充ipv4的通信结构体
    struct sockaddr_in serveraddr, caddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[1]));
    //serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0"); //0.0.0.0 自动获取主机ip
    // serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_addr.s_addr = INADDR_ANY;

    socklen_t len = sizeof(caddr);

    //&serveraddr -->struct sockaddr_in *

    //2.绑定套接字  bind  （绑定自己的ip和端口，便于别人找到自己）
    if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }
    printf("bind ok.\n");

    //3.listen  监听 将主动套接子变为被动等待
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    printf("listen ok.\n");

    //功能：select 服务器响应多个客户端请求且进行通信
    //1.创建表
    fd_set readfds, tempfds;
    FD_ZERO(&readfds); //清空表
    //2.添加关心的文件描述符
    FD_SET(0, &readfds);
    FD_SET(sockfd, &readfds);

    int maxfd = sockfd, ret;
    char buf[128];
    int recvbyte;
    //3.循环调用select检测 ，select阻塞等待有事件产生返回
    while (1)
    {
        tempfds = readfds;
        ret = select(maxfd + 1, &tempfds, NULL, NULL, NULL);
        if (ret < 0)
        {
            perror("select err.");
            return -1;
        }
        for (int i = 0; i <= maxfd; i++)
        {
            if (FD_ISSET(i, &tempfds))
            {
                if (i == 0)
                {
                    fgets(buf, sizeof(buf), stdin);
                    printf("key:%s\n", buf);
                    //将服务器段输入的数据作为通知的消息发送给所有链接的客户端
                    for(int j=4;j<=maxfd;j++)
                    {
                        if(FD_ISSET(j,&readfds))
                        {
                            send(j,buf,sizeof(buf),0);
                        }
                    }
                }
                else if (i == sockfd)
                {
                    //4.阻塞等待客户端链接，链接成功返回一个通信文件描述符 accept
                    acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);

                    if (acceptfd < 0)
                    {
                        perror("accept err.");
                        return -1;
                    }
                    printf("accept ok.\n");

                    //输出查看链接的客户端的ip和端口
                    printf("ip:%s ,port:%d\n",
                           inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

                    //需要将产生通信文件描述符添加到表中进行检测
                    FD_SET(acceptfd, &readfds);
                    if (maxfd < acceptfd)
                        maxfd = acceptfd;
                }
                else
                {
                    //接收消息
                    recvbyte = recv(i, buf, sizeof(buf), 0);
                    if (recvbyte < 0)
                    {
                        perror("recv err.");
                        // return -1;
                    }
                    else if (recvbyte == 0)
                    {
                        printf("%d client exit.\n",i);
                        FD_CLR(i, &readfds);
                        close(i);
                        break;
                    }
                    else
                    {
                        printf("%d buf:%s\n",i, buf);
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

 poll实现多路复用

1. 优化文件描述符个数的限制;(根据poll函数第一个函数的参数来定，如果监听的事件为1个，则结构体数组元素个数为1，如果想监听100个，那么这个结构体数组的元素个数就为100，由程序员自己来决定)
2. poll被唤醒之后需要重新轮询一遍驱动的poll函数，效率比较低
3. poll不需要重新构造文件描述符表，只需要从用户空间向内核空间拷贝一次数据即可

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
 #include <poll.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    //1.创建套接字 socket
    int sockfd, acceptfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    printf("socket ok %d\n", sockfd);

    //填充ipv4的通信结构体
    struct sockaddr_in serveraddr, caddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[1]));
    //serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0"); //0.0.0.0 自动获取主机ip
    // serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_addr.s_addr = INADDR_ANY;

    socklen_t len = sizeof(caddr);

    //&serveraddr -->struct sockaddr_in *

    //2.绑定套接字  bind  （绑定自己的ip和端口，便于别人找到自己）
    if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }
    printf("bind ok.\n");

    //3.listen  监听 将主动套接子变为被动等待
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    printf("listen ok.\n");

    //功能：poll 服务器响应多个客户端请求且进行通信
    //1.创建表 -创建一个结构体数组
     struct pollfd fds[20]={};  //大小自己确定，没有限定个数
    //2.添加关心的文件描述符
     fds[0].fd = 0;
     fds[0].events=POLLIN;//读事件

     fds[1].fd=sockfd;
     fds[1].events=POLLIN;


    int n = 2, ret;
    char buf[128];
    int recvbyte;
    //3.循环调用poll检测 ，poll阻塞等待有事件产生返回 -1
    while (1)
    {
        ret = poll(fds, n, -1);
        if (ret < 0)
        {
            perror("poll err.");
            return -1;
        }
        //处理事件
        for (int i = 0; i < n; i++)
        {
            if (fds[i].revents == POLLIN)
            {
                if (fds[i].fd == 0)
                {
                    fgets(buf, sizeof(buf), stdin);
                    printf("key:%s\n", buf);
                    //将服务器段输入的数据作为通知的消息发送给所有链接的客户端
                    for(int j=2;j<n;j++)
                    {
                        send(fds[j].fd,buf,sizeof(buf),0);
                    }
                }
                else if (fds[i].fd == sockfd)
                {
                    //4.阻塞等待客户端链接，链接成功返回一个通信文件描述符 accept
                    acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);

                    if (acceptfd < 0)
                    {
                        perror("accept err.");
                        return -1;
                    }
                    printf("accept ok.\n");

                    //输出查看链接的客户端的ip和端口
                    printf("ip:%s ,port:%d\n",
                           inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

                    //需要将产生通信文件描述符添加到表中进行检测
                    fds[n].fd=acceptfd;
                    fds[n].events=POLLIN;
                    n++;
                }
                else
                {
                    //接收消息
                    recvbyte = recv(fds[i].fd, buf, sizeof(buf), 0);
                    if (recvbyte < 0)
                    {
                        perror("recv err.");
                        // return -1;
                    }
                    else if (recvbyte == 0)
                    {
                        printf("%d client exit.\n",fds[i].fd);
                        close(fds[i].fd);
                        fds[i]=fds[n-1];
                        n--;
                        i--;              
                        break;
                    }
                    else
                    {
                        printf("%d buf:%s\n",fds[i].fd, buf);
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

epoll实现多路复用

1.监听的最大的文件描述符没有个数限制（理论上，取决与你自己的系统）
2.异步I/O，Epoll当有事件产生被唤醒之后，文件描述符主动调用callback(回调函数)函数直接拿到唤醒的文件描述符，不需要轮询，效率高
3.epoll不需要重新构造文件描述符表，只需要从用户空间向内核空间拷贝一次数据即可

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <poll.h>
 #include <sys/epoll.h>

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("please input %s <port>\n", argv[0]);
        return -1;
    }
    //1.创建套接字 socket
    int sockfd, acceptfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket err.");
        return -1;
    }
    printf("socket ok %d\n", sockfd);

    //填充ipv4的通信结构体
    struct sockaddr_in serveraddr, caddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[1]));
    //serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0"); //0.0.0.0 自动获取主机ip
    // serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_addr.s_addr = INADDR_ANY;

    socklen_t len = sizeof(caddr);

    //&serveraddr -->struct sockaddr_in *

    //2.绑定套接字  bind  （绑定自己的ip和端口，便于别人找到自己）
    if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
    {
        perror("bind err.");
        return -1;
    }
    printf("bind ok.\n");

    //3.listen  监听 将主动套接子变为被动等待
    if (listen(sockfd, 5) < 0)
    {
        perror("listen err.");
        return -1;
    }
    printf("listen ok.\n");

    //功能：epoll 服务器响应多个客户端请求且进行通信
    struct epoll_event event;       //暂时保存添加到树上的事件
    struct epoll_event revents[20]; //保存从链表中获取的产生的事件
    //1.创建表 -创建一颗树
    int epfd = epoll_create(1);

    //2.添加关心的文件描述符到树上  epoll_ctl
    event.events = EPOLLIN | EPOLLET;
    event.data.fd = 0;
    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event);

    event.events = EPOLLIN | EPOLLET;
    event.data.fd = sockfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &event);

    int n = 2, ret;
    char buf[128];
    int recvbyte;
    //3.循环调用epoll_wait检测链表中是否有事件
    while (1)
    {
        //返回值是实际从链表中拿出来事件的个数
        ret = epoll_wait(epfd, revents, 20, -1);
        if (ret < 0)
        {
            perror("poll err.");
            return -1;
        }
        //处理事件
        for (int i = 0; i < ret; i++)
        {
            if (revents[i].data.fd == 0)
            {
                fgets(buf, sizeof(buf), stdin);
                printf("key:%s\n", buf);
            }
            else if (revents[i].data.fd == sockfd)
            {
                //4.阻塞等待客户端链接，链接成功返回一个通信文件描述符 accept
                acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &len);

                if (acceptfd < 0)
                {
                    perror("accept err.");
                    return -1;
                }
                printf("accept ok.\n");

                //输出查看链接的客户端的ip和端口
                printf("ip:%s ,port:%d\n",
                       inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

                //需要将产生通信文件描述符添加到树
                event.events = EPOLLIN | EPOLLET;
                event.data.fd = acceptfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, acceptfd, &event);
            }
            else
            {
                //接收消息
                recvbyte = recv(revents[i].data.fd, buf, sizeof(buf), 0);
                if (recvbyte < 0)
                {
                    perror("recv err.");
                    // return -1;
                }
                else if (recvbyte == 0)
                {
                    printf("%d client exit.\n", revents[i].data.fd);
                    close(revents[i].data.fd);
                    epoll_ctl(epfd, EPOLL_CTL_DEL, revents[i].data.fd,NULL);
                    break;
                }
                else
                {
                    printf("%d buf:%s\n",revents[i].data.fd, buf);
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值