IO多路复用技术(一)

已于 2023-10-25 16:01:34 修改
阅读量397 收藏 2
点赞数 2
分类专栏： 网络编程 文章标签： 网络编程 IO多路复用
于 2023-10-23 20:38:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74396439/article/details/133993804
版权

IO多路复用

一、概念

IO多路复用技术 是一种 网络通信 的方式，通过这种方式可以同时检测多个 文件描述符（这个过程是阻塞的），一旦检测到某一个文件描述符（状态是 可读 或者 可写 的）是就绪的，那么就会解除阻塞，然后我们就可以基于这些已经就绪的文件描述符进行网络通信了。

通过这种方式，服务端即使是在 单线程/进程 的情况下也能实现并发，支持多个连接。

常用的 IO多路复用 的方式有 : select 、 poll 、epoll。

二、IO多路复用 与 传统的多线程/进程方式 对比

传统的 多线程/进程 并发

主线程 / 父进程 调用 accept() 监测是否有客户端的连接到来：

  • 如果没有客户端连接请求到来，那么当前 线程/进程 就会阻塞在这里；
  • 如果有客户端连接请求到来，那么就先解除阻塞，建立新连接；

子线程 / 子进程 调用 send() / write() , read() / recv() 和客户端建立的连接通信 :

  • 调用 read() / recv() 接收客户端发送过来的通信数据，如果 读缓冲区 中没有数据，那么当前 线程/进程 会阻塞，直到 读缓冲区 中有了数据，阻塞就会自动解除；
  • 调用 send() / write() 向客户端发送数据，如果 写缓冲区 的容量已经满了，那么当前 线程/进程 会阻塞，直到 写缓冲区 有了空间，阻塞就会自动解除；

IO多路复用并发

使用 IO多路复用函数 会 委托内核 检测所有客户端的文件描述符 （主要是用于 监听 和 通信 的两类），这个过程会导致 进程/线程 的阻塞；如果内核检测到有就绪的文件描述符就会解除阻塞，然后将这些已经就绪的文件描述符传出去。

然后根据被传出的文件描述符的类型不同，做不同的处理：

1.用于监听的文件描述符 lfd ：用于和客户端建立连接

  • 此时再调用 accept() 和客户端建立新连接是不会阻塞的，因为此时用于监听的文件描述符 lfd 是就绪的，也就是它对应的 读缓冲区 中有连接请求；

2.用于通信的文件描述符 cfd ：调用通信函数 和 已经建立连接的客户端进行通信

  • 调用 read() / recv() 不会阻塞，因为此时用于通信的文件描述符 cfd 是就绪的，它对应的 读缓冲区 中有数据；
  • 调用 send() / write() 不会阻塞，因为此时用于通信的文件描述符 cfd 是就绪的，它对应的 写缓冲区 中有多余的容量；

3.对这些文件描述符继续进行下一轮检测，一直循环下去…

与 多线程/进程 技术相比，IO多路复用的优势在与不用频繁的进行 线程/进程的创建和销毁，不用管理 线程/进程，极大的减少了资源的消耗。

三、三种IO多路复用的方式

1.select

select 是跨平台的，同时支持 Linux 、 Windows 、MacOS 。我们通过调用 select() 这个函数就可以委托内核帮助我们检测 文件描述符 的状态，也就是检测这些文件描述符对应的 读写缓冲区 的状态：

  • 读缓冲区： 检测里面有没有数据，如果有的话，说明其对应的文件描述符已经就绪了；
  • 写缓冲区： 检测 写缓冲区 有没有多余的容量可以写，如果有就说明这个 写缓冲区 对应的文件描述符已经就绪了；
  • 读写异常： 检测 读写缓冲区 是否有异常，如果有的话说明该缓冲区对应的文件描述符已经就绪了；

内核检测完毕文件描述符的状态之后，已经就绪的文件描述符会通过 select() 的三个参数传出，这三个参数都是一个 集合，我们得到之后就能对其进行处理。

1.函数原型
#include <sys/select.h>
struct timeval {
    time_t      tv_sec;         /* seconds */
    suseconds_t tv_usec;        /* microseconds */
};

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

nfds ： 委托内核检测的这三个集合中 最大的文件描述符 + 1

  • 内核需要遍历集合这三个集合中的文件描述符，这个值就是循环结束的条件；
  • 在 Windows 中这个参数是无效的，直接指定为 − 1 -1 −1 即可；

readfds：文件描述符的集合，内核只检测这个集合中的文件描述符对应的 读缓冲区

  • 这是一个传入传出参数，读集合一般情况下都是需要检测的，这样才知道是通过那个文件描述符接收数据；

wtitedfs：文件描述符的集合，内核只检测这个集合中的文件描述符对应的 写缓冲区

  • 这是一个传入传出参数，如果不需要这个参数可以指定为 NULL；

exceptdfs：文件描述符的集合，内核只检测这个集合中的文件描述符是否有异常状态

  • 这是一个传入传出参数，如果不需要这个参数可以指定为 NULL；

timeout ：超时时长，用来强制解除 select() 的阻塞的

  • 如果指定为 NULL 的话，select() 检测不到就绪的文件描述符就会一直阻塞；
  • 等待固定时长：select() 检测不到就绪的文件描述符，在指定时长之后强制解除阻塞，返回 0 0 0；
  • 不等待：直接将该参数的结构体指定为 0 0 0 ，select() 函数就不会阻塞；

返回值：

  • 大于 0 0 0 ，成功。直接返回集合中已经就绪的文件描述符的总个数；
  • 等于 − 1 -1 −1，失败；
  • 等于 0 0 0，超时。没有检测到就绪的文件描述符；

需要使用到的一些函数：

// 将文件描述符fd从set集合中删除 == 将fd对应的标志位设置为0        
void FD_CLR(int fd, fd_set *set);
// 判断文件描述符fd是否在set集合中 == 读一下fd对应的标志位到底是0还是1
int  FD_ISSET(int fd, fd_set *set);
// 将文件描述符fd添加到set集合中 == 将fd对应的标志位设置为1
void FD_SET(int fd, fd_set *set);
// 将set集合中, 所有文件文件描述符对应的标志位设置为0, 集合中没有添加任何文件描述符
void FD_ZERO(fd_set *set);
2.实现细节

在 select() 函数中第2、3、4个参数都是 fd_set 类型，它表示一个文件描述符的集合，这个类型的数据有 128 128 128 个字节，也就是 1024 1024 1024 个标志位，和内核中文件描述符表中的文件描述符个数是一样的。

sizeof(fd_set) = 128 字节 * 8 = 1024 bit      // int [32]

这块内存中的每一个bit 和 文件描述符表中的每一个文件描述符是一一对应的关系，这样就可以使用最小的存储空间将要表达的意思描述出来了。

下图中的 fd_set 存储了要委托内核要检测的 读缓冲区的文件描述符集合。

  • 如果集合中的 标志位为 0 0 0 ，代表 不检测 这个文件描述符的状态；
  • 如果集合中的 标志位为 1 1 1 ，代表 检测 这个文件描述符的状态；

在这里插入图片描述
内核在遍历这个 读集合 的过程中，如果被检测的文件描述符对应的读缓冲区中 没有数据，内核将修改这个文件描述符在读集合 fd_set 中对应的标志位，改为 0 0 0，如果有数据那么这个标志位的值不变，还是 1 1 1。

在这里插入图片描述
当 select() 函数解除阻塞之后，被内核修改过的 读集合 通过参数传出，此时集合中只要标志位的值为 1 1 1，那么它对应的文件描述符肯定是就绪的，我们就可以基于这个文件描述符和客户端建立新连接或者通信了。

3.处理流程

1.创建监听的套接字 lfd = socket() ；
2.将 监听的套接字 和 本地的 ip 和 端口 绑定 bind()；
3.给监听的套接字设置监听 listen()；
4.创建一个文件描述符集合 fd_set，用于存储需要检测读事件的所有的文件描述符
通过 FD_ZERO() 初始化；

  • 通过 FD_SET() 将监听的文件描述符放入检测的读集合中
  • 循环调用 select() ，周期性的对所有的文件描述符进行检测

5.select() 解除阻塞返回，得到内核传出的满足条件的就绪的文件描述符集合
6.通过 FD_ISSET() 判断集合中的标志位是否为 1 1 1

  • 如果这个文件描述符是 监听的文件描述符，调用 accept() 和客户端建立连接。将得到的新的通信的文件描述符，通过 FD_SET() 放入到检测集合中
  • 如果这个文件描述符是通信的文件描述符，调用通信函数和客户端通信
    • 如果客户端和服务器断开了连接，使用 FD_CLR() 将这个文件描述符从检测集合中删除
    • 如果没有断开连接，正常通信即可

7.重复第6步

在这里插入图片描述

4.实现

客户端代码：

#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>

int main(){

    //1.创建用于通信的文件描述符 cfd
    int cfd = socket(AF_INET,SOCK_STREAM,0);
    if(cfd == -1){
        perror("socket");
        return -1;
    }

    printf("1.成功创建了用于通信的文件描述符 : %d\n",cfd);

    //2.连接服务器
    unsigned short port = 10000;
    
    //你自己的服务器 或者 虚拟机的 ip地址
    const char* ip = "10.0.8.14";

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET,ip,&addr.sin_addr.s_addr);

    int ret = connect(cfd,(struct sockaddr*)&addr,sizeof(addr));
    if(ret == -1){
        perror("connet");
        return -1;
    }
    printf("2.成功连接了服务器 , ip : %s , port : %d\n",ip,port);

    //3.开始通信
    char send_buf[1024];
    char recv_buf[1024];

    int cnt = 0;

    while(1){
        memset(send_buf,0,sizeof send_buf);
        memset(recv_buf,0,sizeof recv_buf);

        sprintf(send_buf,"hello i love you : %d",cnt++);

        //发送数据
        send(cfd,send_buf,strlen(send_buf) + 1,0);
        //接收数据
        int len = recv(cfd,recv_buf,sizeof(recv_buf),0);

        if(len > 0){
            printf("服务端 : %s\n",recv_buf);
        }
        else if(len == 0){
            printf("服务端已经断开了连接...\n");
            break;
        }
        else{
            perror("recv");
            break;
        }

        sleep(1);
    }

    close(cfd);

    return 0;
}
1.服务端基础版本
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include <strings.h>
#include <string.h>
#include <sys/select.h>



int main()
{

    // 1.创建用于监听的文件描述符
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1)
    {
        perror("socket");
        return -1;
    }

    // 2.绑定 ip 和 端口号
    unsigned short port = 10000;

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(port);
    saddr.sin_addr.s_addr = INADDR_ANY;

    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (ret == -1)
    {
        perror("bind");
        return -1;
    }

    // 3.设置监听
    ret = listen(lfd, 128);
    if (ret == -1)
    {
        perror("listen");
        return -1;
    }
    printf("设置监听成功...\n");

    // 4.获取连接
    fd_set readset ,temp;
    FD_ZERO(&readset);


    //把用于监听的文件描述符 lfd ， 加入到 readset 读集合中
    FD_SET(lfd,&readset);
    int addr_len = sizeof(struct sockaddr_in);
    int maxfd = lfd;

    
    char buf[1024];
    char* str = "ok";

    while(1){
         temp = readset;

        int ret = select(maxfd + 1,&temp,NULL,NULL,NULL);

        //检测 用于监听的文件描述符 lfd 读缓冲区是否有数据 ， 也就是是否有新的连接到来
        if(FD_ISSET(lfd,&temp)){

            struct sockaddr_in addr;
            int cfd = accept(lfd,(struct sockaddr*)&addr,&addr_len);

            //将用于通信文件描述符 cfd 也加入到 读集合中
            FD_SET(cfd,&readset);

            //更新 maxfd
            maxfd = cfd > maxfd ? cfd : maxfd;
            printf("获取连接成功 , 客户端 ip : %s  , port : %d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
        }

        for(int i = 0;i <= maxfd;i++){
            //用于通信的文件描述符 cfd 的读缓冲区有数据了 , 也就是有客户端发消息过来了
            if(i != lfd && FD_ISSET(i,&temp)){
                
                memset(buf,0,sizeof buf);
                int len = read(i,buf,sizeof buf);
                printf("客户端 : %s\n",buf);

                if(len > 0){
                    write(i,str,strlen(str) + 1);
                }
                else if(len == 0){
                    //客户端已经关闭了连接
                    printf("客户端已经关闭了连接...\n");
                    FD_CLR(i,&readset);
                    close(i);
                }
                else{
                    perror("read");
                }
            }
        }
    }



    close(lfd);

    return 0;
}
2.服务端多线程版本
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <sys/select.h>
#include <pthread.h>
#include <ctype.h>

pthread_mutex_t mutex;

char buf[1024];

typedef struct fdinfo
{
    int fd;
    int *maxfd;
    fd_set *readset;

} FdInfo;

void *acceptConnection(void *arg)
{
    printf("子线程的线程id为 : %ld\n", pthread_self());

    FdInfo *info = (FdInfo *)(arg);
    int lfd = info->fd;

    struct sockaddr_in addr;
    int addr_len = sizeof(addr);

    int cfd = accept(lfd, (struct sockaddr *)&addr, &addr_len);

    pthread_mutex_lock(&mutex);

    // 将用于通信文件描述符 cfd 也加入到 读集合中
    FD_SET(cfd, info->readset);

    // 更新 maxfd
    *info->maxfd = cfd > *info->maxfd ? cfd : *info->maxfd;

    pthread_mutex_unlock(&mutex);

    printf("获取连接成功 , 客户端 ip : %s  , port : %d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

    free(info);

    return NULL;
}

void *communicate(void *arg)
{
    printf("子线程的线程id为 : %ld\n", pthread_self());

    FdInfo *info = (FdInfo *)(arg);
    int cfd = info->fd;

    memset(buf, 0, sizeof buf);
    int len = read(cfd, buf, sizeof buf);
    printf("客户端 : %s\n", buf);

    if (len < 0)
    {
        perror("read");
        free(info);
        return NULL;
    }
    else if(len == 0){
        
        // 客户端已经关闭了连接
        printf("客户端已经关闭了连接...\n");

        pthread_mutex_lock(&mutex);

        FD_CLR(cfd, info->readset);

        pthread_mutex_unlock(&mutex);

        close(cfd);

        free(info);
        
        return NULL;
    }

    int str_len = strlen(buf);
    for(int i = 0;i < str_len;i++) buf[i] = toupper(buf[i]);

    write(cfd,buf,len);

    free(info);
    return NULL;
}

int main()
{

    // 初始化 mutex
    pthread_mutex_init(&mutex, NULL);

    // 1.创建用于监听的文件描述符
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1)
    {
        perror("socket");
        return -1;
    }

    // 2.绑定 ip 和 端口号
    unsigned short port = 10000;

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(port);
    saddr.sin_addr.s_addr = INADDR_ANY;

    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (ret == -1)
    {
        perror("bind");
        return -1;
    }

    // 3.设置监听
    ret = listen(lfd, 128);
    if (ret == -1)
    {
        perror("listen");
        return -1;
    }
    printf("设置监听成功...\n");

    // 4.获取连接
    fd_set readset, temp;
    FD_ZERO(&readset);

    // 把用于监听的文件描述符 lfd ， 加入到 readset 读集合中
    FD_SET(lfd, &readset);
    int addr_len = sizeof(struct sockaddr_in);
    int maxfd = lfd;

    while (1)
    {
        pthread_mutex_lock(&mutex);

        temp = readset;

        pthread_mutex_unlock(&mutex);

        int ret = select(maxfd + 1, &temp, NULL, NULL, NULL);

        // 检测 用于监听的文件描述符 lfd 读缓冲区是否有数据 ， 也就是是否有新的连接到来
        if (FD_ISSET(lfd, &temp))
        {
            FdInfo *info = (FdInfo *)malloc(sizeof(FdInfo));
            info->fd = lfd;
            info->maxfd = &maxfd;
            info->readset = &readset;

            pthread_t tid;
            pthread_create(&tid, NULL, acceptConnection, info);
            pthread_detach(tid);
        }

        for (int i = 0; i <= maxfd; i++)
        {
            // 用于通信的文件描述符 cfd 的读缓冲区有数据了 , 也就是有客户端发消息过来了
            if (i != lfd && FD_ISSET(i, &temp))
            {
                FdInfo *info = (FdInfo *)malloc(sizeof(FdInfo));
                info->fd = i;
                info->maxfd = &maxfd;
                info->readset = &readset;

                pthread_t tid;
                pthread_create(&tid, NULL, communicate, info);
                pthread_detach(tid);
            }
        }
    }

    close(lfd);
    pthread_mutex_destroy(&mutex);

    return 0;
}

客户端不需要使用IO多路复用进行处理，因为客户端和服务器的对应关系是 1 : N 1:N 1:N，也就是说客户端是比较专一的，只能和一个连接成功的服务器通信。

虽然使用select这种IO多路转接技术可以降低系统开销，提高程序效率，但是它也有局限性：

  • 待检测集合（第 2 、 3 、 4 2、3、4 2、3、4 个参数）需要频繁的在用户区和内核区之间进行数据的拷贝，效率低
  • 内核对于 select() 传递进来的待检测集合的检测方式是线性的
    • 如果集合内待检测的文件描述符很多，检测效率会比较低
    • 如果集合内待检测的文件描述符相对较少，检测效率会比较高
  • 使用 select 能够检测的最大文件描述符个数有上限，默认是 1024 1024 1024，这是在内核中被写死了的。

2.poll

poll 的机制跟 select 类似，使用方法也是类似的，以下是它们两个的对比：

  • 内核检测文件描述符的状态也是通过 线性遍历 的形式；
  • poll 和 select 检测的文件描述符的集合 会在被检测的过程频繁的进行 用户区 和 内核区的拷贝，它的开销随着文件描述符数量的增加而增大，所以效率也会变得越来越低；
  • select 可以跨平台使用，支持 Linux 、Windows 、MacOS；而 poll 只能在 Linux 平台下使用；
1.函数原型
#include <poll.h>
// 每个委托poll检测的fd都对应这样一个结构体
struct pollfd {
    int   fd;         /* 委托内核检测的文件描述符 */
    short events;     /* 委托内核检测文件描述符的什么事件 */
    short revents;    /* 文件描述符实际发生的事件 -> 传出 */
};

struct pollfd myfd[100];
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

fds ：这是一个 struct pollfd 类型的数组，里面存储了待检测的文件描述符的信息，它一共有三个成员：

  • fd ： 委托内核检测的文件描述符；
  • events：委托内核检测的文件描述符对应的事件（读，写，错误）；
  • revents：这是一个传出参数，数据由内核写入，存储内核检测之后的结果；

nfds ：这是第一个参数数组中最后一个元素的下标 + 1，用来表示循环结束的条件；

timeout ：指定 poll() 函数的阻塞时长：

  • − 1 -1 −1，一直阻塞，直到检测的集合中有就绪的文件描述符才会解除阻塞；
  • 0 0 0，不阻塞，不管待检测的集合中有没有文件描述符，函数执行完之后就返回；
  • > 0 > 0 >0，阻塞指定的毫秒数，就解除阻塞返回；

函数返回值：

  • − 1 -1 −1，失败；
  • > 0 >0 >0，成功。返回的数就是集合中已经就绪的文件描述符的总个数；
2.实现

客户端代码：

#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>

int main(){

    //1.创建用于通信的文件描述符 cfd
    int cfd = socket(AF_INET,SOCK_STREAM,0);
    if(cfd == -1){
        perror("socket");
        return -1;
    }

    printf("1.成功创建了用于通信的文件描述符 : %d\n",cfd);

    //2.连接服务器
    unsigned short port = 10000;
    const char* ip = "10.0.8.14";

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET,ip,&addr.sin_addr.s_addr);

    int ret = connect(cfd,(struct sockaddr*)&addr,sizeof(addr));
    if(ret == -1){
        perror("connet");
        return -1;
    }
    printf("2.成功连接了服务器 , ip : %s , port : %d\n",ip,port);

    //3.开始通信
    char send_buf[1024];
    char recv_buf[1024];

    int cnt = 0;

    while(1){
        memset(send_buf,0,sizeof send_buf);
        memset(recv_buf,0,sizeof recv_buf);

        sprintf(send_buf,"hello i love you : %d",cnt++);

        //发送数据
        send(cfd,send_buf,strlen(send_buf) + 1,0);
        //接收数据
        int len = recv(cfd,recv_buf,sizeof(recv_buf),0);

        if(len > 0){
            printf("服务端 : %s\n",recv_buf);
        }
        else if(len == 0){
            printf("服务端已经断开了连接...\n");
            break;
        }
        else{
            perror("recv");
            break;
        }

        sleep(1);
    }

    close(cfd);

    return 0;
}

服务端代码：

#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <poll.h>

int main()
{

    // 1.创建用于监听的文件描述符
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1)
    {
        perror("socket");
        return -1;
    }

    // 2.绑定 ip 和 端口号
    unsigned short port = 10000;

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(port);
    saddr.sin_addr.s_addr = INADDR_ANY;

    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (ret == -1)
    {
        perror("bind");
        return -1;
    }

    // 3.设置监听
    ret = listen(lfd, 128);
    if (ret == -1)
    {
        perror("listen");
        return -1;
    }
    printf("设置监听成功...\n");

    // 4.获取连接

    struct pollfd fds[1024];

    for (int i = 0; i < 1024; i++)
    {
        fds[i].fd = -1;
        fds[i].events |= POLLIN;
    }

    // 把用于监听的文件描述符 lfd 加入到 fds 数组中
    fds[0].fd = lfd;

    int addr_len = sizeof(struct sockaddr_in);
    int maxfd = 0;

    char buf[1024];
    char *str = "ok";

    while (1)
    {

        int ret = poll(fds, maxfd + 1, -1);

        if(ret == -1){
            perror("poll");
            exit(0);
        }

        // 检测 用于监听的文件描述符 lfd 读缓冲区是否有数据 ， 也就是是否有新的连接到来

        if (fds[0].revents & POLLIN)
        {
            struct sockaddr_in addr;

            // 获取连接 ， 返回用于通信的文件描述符
            int cfd = accept(lfd, (struct sockaddr *)&addr, &addr_len);

            printf("获取连接成功 , 客户端 ip : %s  , port : %d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

            // 把用于通信的文件描述符 cfd 加入到 fds 中
            int i = 1;
            for (; i < 1024; i++)
            {
                if (fds[i].fd == -1)
                {
                    fds[i].fd = cfd;
                    break;
                }
            }

            maxfd = i > maxfd ? i : maxfd;
        }

        for (int i = 1; i <= maxfd; i++)
        {
            // 用于通信的文件描述符 cfd 的读缓冲区有数据了 , 也就是有客户端发消息过来了
            if (fds[i].revents & POLLIN)
            {
                int cfd = fds[i].fd;

                memset(buf, 0, sizeof buf);
                int len = read(cfd, buf, sizeof buf);
                printf("客户端 : %s\n", buf);

                if (len > 0)
                {
                    write(cfd, str, strlen(str) + 1);
                }
                else if (len == 0)
                {
                    // 客户端已经关闭了连接
                    printf("客户端已经关闭了连接...\n");
                    close(cfd);
                    fds[i].fd = -1;
                }
                else
                {
                    perror("read");
                    exit(0);
                }
            }
        }
    }

    close(lfd);

    return 0;
    }
感觉画质不如…原神
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
windows下多路复用IO（select,WSAAsyncSelect,WSAEventSelect）
11-17
windows下多路复用IO（select,WSAAsyncSelect,WSAEventSelect）
IO多路复用之epoll全面总结(必看篇)
09-15
IO多路复用技术在高并发服务器编程中扮演着至关重要的角色，因为它允许单个线程同时处理多个连接。在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细...
Windows C++运用IOCP IO多路复用同时监听1000个tcp套接字消息
weixin_46100993的博客
07-14 596
Windows C++运用IOCP IO多路复用同时监听1000个tcp套接字消息
操作系统中的IO多路复用
最新发布
yualian的博客
04-20 990
内核提供的一种事件通知机制，用于实现高性能的I/O多路复用。允许同时监视多个文件描述符，可以在这些文件描述符中的任何一个上等待数据的到达，而不需要为每个文件描述符创建一个单独的线程或进程来处理。可以在一组文件描述符上进行非阻塞的等待，当其中任何一个文件描述符准备好进行I/O操作时，函数返回，并告知哪些文件描述符已经就绪。是事件驱动的，当文件描述符上发生对应的事件时，内核会将该事件通知给应用程序，从而实现了异步的。只会通知活跃的事件，而不是遍历所有注册的文件描述符，因此在有大量非活跃文件描述符的情况下，
IO多路复用技术详解
weixin_30635053的博客
01-19 153
　　IO多路复用：I/O是指网络I/O,多路指多个TCP连接(即socket或者channel）,复用指复用一个或几个线程。意思说一个或一组线程处理多个TCP连接。最大优势是减少系统开销小，不必创建过多的进程/线程，也不必维护这些进程/线程。 　　IO多路复用使用两个系统调用(select/poll/epoll和recvfrom)，blocking IO只调用了recvfrom；select/...
IO多路复用之select、poll、epoll详解
hnzwx888的专栏
04-25 787
原文网址：https://www.toutiao.com/a6603975473665933838/ IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： 当客户处理多个描述符时（一般是交互式输入和网络套接口），必须使用I/O复用。 当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 如果一个TCP服务器既要处理监听套...
IO多路复用
aoeaoao的博客
08-22 772
IO多路复用，以及IO复用方法的使用
详解Python IO口多路复用
09-16
首先，我们需要理解IO多路复用的基本概念。在传统的IO模型中，如阻塞IO，当一个进程执行IO操作时，如读取数据，如果数据尚未准备好，进程会暂停执行，直到数据准备好并被拷贝到用户空间。这种等待状态就是所谓的阻塞...
1.18 第六章 IO多路复用
01-18
1.18 第六章 IO多路复用
io多路复用解析
12-07
IO 多路复用是一种高效的输入/输出（I/O）管理机制，允许单个进程同时监控多个文件描述符（FD），以便在其中某个文件描述符上发生事件时，立即响应。IO 多路复用机制广泛应用于服务器端编程、网络编程等领域，能够...
windows下socket多路复用
10-31
windows下socket多路复用,select FD_SET FD_ZERO FD_ISSET FD_CLR等函数的用法，包含客户端和服务器端代码，开发环境vs2008
IO多路复用之select全面总结(必看篇)
01-10
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户...
php io多路复用 window,Windows-IO多路复用(select)
weixin_28976057的博客
03-20 291
我会以一个回应反射式服务器(与《Windows网络编程》第八章一样)来介绍。我们假设客户端的代码如下(为代码直观，省去所有错误检查，以下同)：#include #include #define SERVER_ADDRESS "137.117.2.148"#definePORT5150#defineMSGSIZE1024#pragma comment(lib, "ws2_32.lib")int ...
操作系统：IO多路复用
向北~的博客
05-11 504
线程是运行在进程中的一个“逻辑流”，单进程中可以运行多个线程，同进程里的线程可以共享进程的部分资源，比如文件描述符列表、进程空间、代码、全局数据、堆、共享库等，这些共享些资源在上下文切换时不需要切换，而只需要切换线程的私有数据、寄存器等不共享的数据，因此同一个进程下的线程上下文切换的开销要比进程小得多。这种用多个进程来应付多个客户端的方式，在应对 100 个客户端还是可行的，但是当客户端数量高达一万时，肯定扛不住的，因为每产生一个进程，必会占据一定的系统资源，而且进程间的上下文切换会影响性能。
IO多路复用select/poll/epoll
一个后端菜鸟的博客
03-18 314
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、io多路复用二、select/poll/epoll1.select2. poll3.epoll仓库文章 前言 一、io多路复用 使用场景：一个高性能的网络服务器，可以让多个客户端同时使用 （bs）并且可以获取这些客户端的请求 并处理 怎么处理这些请求的 高并发状况 如果使用多线程 可以做 但是 多线程的使用需要上下文的切换（需要处理一些句柄） 客户端比较多的时候 代价是非常高的 二、select/poll/epoll .
IO多路复用详解
氷的博客
05-30 1409
在IO多路复用模型中，引入了一种新的系统调用，查询IO的就绪状态。在Linux系统中，对应的系统调用为select/poll/epoll系统调用。通过该系统调用，一个进程可以监视多个文件描述符，一旦某个描述符就绪（一般是内核缓冲区可读/可写），内核能够将就绪的状态返回给应用程序。随后，应用程序根据就绪的状态，进行相应的IO系统调用。在IO多路复用模型中通过select/poll/epoll系统调用，单个应用程序的线程，可以不断地轮询成百上千的socket连接，当某个或者某些socket网络连接有IO就绪的状
I/O多路复用，我懂了！
tanjianjun123456的博客
10-13 652
I/O Linux/Unix常见IO模型：阻塞（Blocking I/O）、非阻塞（Non-Blocking I/O）、IO多路复用（I/O Multiplexing）、信号驱动 I/O（Signal Driven I/O）（不常用）和异步（Asynchronous I/O）。网络IO操作主要涉及到内核和进程，其主要分为两个过程： 内核等待数据可操作（可读或可写）——阻塞与非阻塞 内核与进程之间数据的拷贝——同步与异步 基础概念 ① 阻塞（Blocking）和非阻塞（Non-blocking...
redisIO多路复用
09-15
Redis利用IO多路复用技术来实现高效的网络通信。在Redis中，通过使用epoll来实现IO多路复用，将连接信息和事件放到队列中，并由事件分派器将事件分发给事件处理器。这种方式可以让单个线程高效地处理多个连接请求，减少了网络IO的时间消耗。 多路复用IO模型中，有一个内核线程不断地轮询多个socket的状态，只有当真正有读写事件发送时，才会调用实际的IO读写操作。这样可以减少资源的占用，因为只有在有读写事件发生时才会使用IO资源，同时不需要建立新的进程或线程，也无需维护这些线程和进程。 使用多路复用技术可以提高Redis的性能，特别是在内存中操作数据的速度非常快的情况下。Redis可以高效地处理多个连接请求，同时通过IO多路复用机制减少了不必要的操作，提高了系统的吞吐量和性能。 总结起来，Redis利用IO多路复用技术来实现高效的网络通信，通过epoll来实现IO多路复用，将连接信息和事件放到队列中，并由事件分派器将事件分发给事件处理器。这样可以让单个线程高效地处理多个连接请求，提高系统的吞吐量和性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值