IO多路复用网络编程（终极篇）

1970-01-01

字数统计: 2.3k字 | 阅读时长≈ 9分

I/O多路复用

在UNIX/Linux下主要有4种I/O模型:

阻塞I/O:

最常用
同步通信模型
阻塞I/O模式是最普遍使用的I/O模式,大部分程序使用的都是阻
塞模式的I/O。
缺省情況下,套接字建立后所处于的模式就是阻塞1/0模式。
前面学习的很多读写函数在调用过程中会发生阻塞。
-读操作中的read、recv、 recvfrom
-写操作中的write、send，（sendto不阻塞）
-其他操作: accept、connect
阻塞I/O会导致调用该函数的进程或线程会被阻塞，不会被内核进行调度
处理不当会造成进程、线程被永远阻塞

以read函数为例:

进程调用read函数从套接字上读取数据,当套接字的接收缓冲区中还没有
数据可读,函数read将发生阻塞。
它会一直阻塞下去,等待套接字的接收缓冲区中有数据可读。

经过一段时间后,缓冲区内接收到数据,于是内核便去唤醒该进程,通过
read访问这些数据。

如果在进程阻塞过程中,对方发生故障,那这个进程将永远阻塞下去。

非阻塞I/O:

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

非阻塞I/O模式就和普通的全局变量、普通的缓冲区没有什么区别，需要不停的查询，缓冲区没有数据的时候cpu也要去运行查询的操作，极其浪费cpu资源。

信号（事件）驱动I/O:

一种异步通信模型

I/O多路复用:

允许同时对多个I/O进行控制
同步通信模型

IO多路复用的原理：当一个进程中有多个需要阻塞的文件描述符同时运行的时候，就把需要阻塞的这些文件描述符加到一个集合里面，当一个或多个阻塞的函数有数据到来是就返回集合阻塞函数，然后再查询具体是哪个阻塞文件描述符有数据到来了，处理完数据后继续集合阻塞。

基本常识：

linux中每个进程默认情况下,最多可以打开1024个文件,最多有1024个文件描述
符
文件描述符的特点:
1.非负整数
2.从最小可用的数字来分配
3.每个进程启动时默认打开0, 1,2三个文件描述符

多路复用针对不止套接字fd,也针对普通的文件描述fd

linux的文件描述符集合图示：

IO多路复用就是围绕着fd_set这个结构体做操作

IO多路复用相关函数：

void FD_ZERO(fd_set *fdset); // 对集合清零
void FD_SET(int fd, fd_set *fdset); // 把fd加入到集合
void FD_CLR(int fd, fd_set *fdset); // 把fd从集合中移除
int FD_ISSET(int fd, fd_set *fdset); // 判断fd是否在集合中

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);
// nfds：最大的文件描述符加一 
// readfds：读集合
// writefds：写集合，一般不会用到写集合，填NULL
// exceptfds：异常集合（带外数据），一般也不会用，填NULL
// 集合最大阻塞时间：
struct timeval 
{
    long    tv_sec;         /* 秒 */
    long    tv_usec;        /* 微秒 */
};

注：select()退出后，集合表示的是有数据的集合，有数据的集合是原来传入集合的子集。

通过 if (FD_ISSET(fd, fdset)) 判断，fd是否在这个有数据的集合中。

如果fd是监听套接字：有新的客户端连接。

如果fd是已连接客户端的套接字：客户端有数据过来。

示例程序：

服务端

//伪代码：
#include "list.h"
#include <cstd_header.h>
     
int main()
{
	/* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字
    /* 运行绑定地址快速重用 */
    setsockopt();
    
    /* 绑定套接字 */
    bind(fd, (struct sockaddr *)&sin, sizeof(sin));
    
    /* 把主动套接字变成被动套接字 */
    listen(fd, 5);
    
    while (1)
    {
        FD_ZERO(&rfds);
        FD_SET(0, &rfds); // 添加fd到集合rfds
        FD_SET(fd, &rfds);
        
        for (i = 1; i <= client_len; i++) // 遍历已连接的客户端链表添加fd到rdf
        {
            info = list_get_info_by_num(L, i);
            FD_SET(info->fd, &rfds);
        }
        
        // 阻塞等待集合rfds中是否有数据到来，注意max_fd要加一，是数组的个数是max_fd + 1，最大下标是max_fd
        select(max_fd + 1, &rfds, NULL, NULL, NULL); 
        
        if (FD_ISSET(fd, &rfds))  // 判读fd是否有数据到来，新的客户端连接
        {
            if (accept_client(fd, L) < 0) // 添加新的客户端信息到链表
            {
                printf("no newclient connect\n");
                continue;
            }
        }
		
        // 如果链表被删除，list_get_length()可能在循环时变化，需要实时计算
        for (i = 1; i <= list_get_length(L); i++) // 遍历已连接的客户端链表判断fd是否有在线客户端数据来了
        {
            info = list_get_info_by_num(L, i);
            if (FD_ISSET(info->fd, &rfds))
            {
                cli_data_handle(info, L); // 进行数据的接收和转发
            }
        }
    }
    
    close(fd);
    return 0;
}

客户端：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <sys/time.h>

void usage(char *s)
{
    printf("\n%s serv_ip serv_port", s);
    printf("\n\t serv_ip: server ip address");
    printf("\n\t serv_port: server port(>5000)\n\n");
}

int main (int argc, char **argv)
{
    int fd;
    short port;
    struct sockaddr_in sin = {0};
    
    if (argc < 3)
    {
        usage(argv[0]);
        exit(1);
    }

    port = atoi(argv[2]);
    if (port < 5000)
    {
        usage(argv[0]);
        exit(1);
    }
    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(port); // 端口号转成网络字节序
    sin.sin_addr.s_addr = inet_addr(argv[1]); // 将点斜式ip转成整形ip，内部自动转成网络字节序

    /* 连接服务器 */
    if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(-1);
     }
    printf("conect sever success\n");

    /* 读写套接字 */
    #define BUF_SIZE 1024
    char buf[BUF_SIZE];
    int ret = -1;
    int max_fd = -1;
    fd_set rfds;
    struct timeval tout;

    while (1)
    {
        FD_ZERO(&rfds);
        FD_SET(0, &rfds); // 添加fd到集合rfds
        FD_SET(fd, &rfds);

        max_fd = fd;
        tout.tv_sec = 10;
        tout.tv_usec = 0;
        select(max_fd + 1, &rfds, NULL, NULL, &tout);   // 阻塞10s等待集合rfds中是否有数据到来，注意max_fd要加一，是数组的个数是max_fd + 1，最大下标是max_fd

        if (FD_ISSET(0, &rfds))  // 判读标准输入fd是否有数据到来
        {
            bzero (buf, BUF_SIZE); // 数组清零
            do
            {
                ret = read(0, buf, BUF_SIZE -1); // 预留一个保存‘/0’ 
            } while (ret < 0 && EINTR == errno);

            if (ret < 0 || !ret)
            {
                perror("read stdin error");
                continue;
            }

            ret = write(fd, buf, strlen(buf));
            if (ret < 0)
            {
                perror("read stdin error");
                continue;
            }
            
            if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
            {
                printf("Client is exiting!\n");
                break;
            } 
        }
        
        if (FD_ISSET(fd, &rfds)) // 判断套接字是否有数据到来
        {
            bzero (buf, BUF_SIZE); // 数组清零
            do
            {
                ret = read(fd, buf, BUF_SIZE -1); // 预留一个保存‘/0’
            } while (ret < 0 && EINTR == errno);

            if (ret < 0)
            {
                perror("read stdin error");
                continue;
            }
            else if (!ret)
            {
                printf("sever is colse\n");
                break;
            }
            printf("recv serv data: %s\n", buf);

            if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
            {
                printf("Server Client is exiting!\n");
                break;
            }
        }
    }

    close (fd);
    return 0;
}

运行结果：

1.文件描述符集合：把多个需要阻塞等待的文件描述符假如到一个数组当中，当有其中一个或多个文件描述符有数据可读时，进程会被唤醒运行，然后找出是哪个文件描述符再处理这个文件描述符的数据。

2.文件描述符集合不光只对网络编程可用，对所有的文件io都可以用。

3.文件描述符使进程中多个需要阻塞的地方变成一个地方阻塞，解决了以往进程中有多个阻塞等待文件描述符数据的时候需要开多个进程或线程的问题。

源码地址：http://gitea.880755.xyz/private/TCP_IO_Demo.git

本文作者： 龙兄嵌入式
本文链接： https://hexo.880755.xyz/1970/01/01/zblog/download/60. IO多路复用网络编程（终极篇）/