网络socket编程--多路复用_socket 多路复用-优快云博客

本文链接：https://blog.youkuaiyun.com/KingRing_/article/details/113816223

一、五种网络I/O模型

1.什么是I/O

I/O在计算机中指Input/Output，也就是输入和输出。由于程序和运行时数据是在内存中驻留，由CPU这个超快的计算核心来执行，涉及到数据交换的地方，通常是磁盘、网络等，就需要IO接口。

比如你打开浏览器，访问新浪首页，浏览器这个程序就需要通过网络IO获取新浪的网页。浏览器首先会发送数据给新浪服务器，告诉它我想要首页的HTML，这个动作是往外发数据，叫Output，随后新浪服务器把网页发过来，这个动作是从外面接收数据，叫Input。所以，通常，程序完成IO操作会有Input和Output两个数据流。当然也有只用一个的情况，比如，从磁盘读取文件到内存，就只有Input操作，反过来，把数据写到磁盘文件里，就只是一个Output操作。

I/O编程中，Stream（流）是一个很重要的概念，可以把流想象成一个水管，数据就是水管里的水，但是只能单向流动。Input Stream就是数据从外面（磁盘、网络）流进内存，Output Stream就是数据从内存流到外面去。对于浏览网页来说，浏览器和新浪服务器之间至少需要建立两根水管，才可以既能发数据，又能收数据。所以，程序运行是依靠cpu和内存来进行的，I/O操作是相对于内存而言的，从外部设备进入内存就叫Input,反之从内存输出到外部设备就叫Output.

I/O按照设备来分的话，分为两种，其一是网络I/O，也就是通过网络进行数据的拉取和输出。还有一种是磁盘I/O,主要是对磁盘进行读写工作。

2.阻塞、非阻塞、同步、异步分析

由于CPU和内存的速度远远高于外设的速度，所以，在IO编程中，就存在速度严重不匹配的问题。举个例子来说，比如要把100M的数据写入磁盘，CPU输出100M的数据只需要0.01秒，可是磁盘要接收这100M数据可能需要10秒，怎么办呢？

这就牵扯出来了同步、异步、阻塞与非阻塞这些概念。

举一个烧水的例子来具体解释这几个概念。
说到烧水，我们都是通过热水壶来烧水的。在很久之前，科技还没有这么发达的时候，如果我们要烧水，需要把水壶放到火炉上，我们通过观察水壶内的水的沸腾程度来判断水有没有烧开。随着科技的发展，现在市面上的水壶都有了提醒功能，当我们把水壶插电之后，水壶水烧开之后会通过声音提醒我们水开了。

2.1 什么是同步、异步

对于烧水这件事儿来说，传统水壶的烧水就是同步的，高科技水壶的烧水就是异步的。

同步请求，A调用B，B的处理是同步的，在处理完之前他不会通知A，只有处理完之后才会明确的通知A。

异步请求，A调用B，B的处理是异步的，B在接到请求后先告诉A我已经接到请求了，然后异步去处理，处理完之后通过回调等方式再通知A。

所以说，同步和异步最大的区别就是被调用方的执行方式和返回时机。同步指的是被调用方做完事情之后再返回，异步指的是被调用方先返回，然后再做事情，做完之后再想办法通知调用方。

2.2 什么是阻塞和非阻塞

还是那个烧水的例子，当你把水放到水壶里面，按下开关后，你可以坐在水壶前面，别的事情什么都不做，一直等着水烧好。你还可以先去客厅看电视，等着水开就好了。

对于你来说，坐在水壶前面等就是阻塞的，去客厅看电视等着水开就是非阻塞的。

阻塞请求，A调用B，A一直等着B的返回，别的事情什么也不干。

非阻塞请求，A调用B，A不用一直等着B的返回，先去忙别的事情了。

所以说，同步和异步最大的区别就是在被调用方返回结果之前的这段时间内，调用方是否一直等待。阻塞指的是调用方一直等待别的事情什么都不做。非阻塞指的是调用方先去忙别的事情。

2.3 阻塞、非阻塞和同步、异步的区别

有人认为阻塞和同步是一回事儿，非阻塞和异步是一回事。但是这是不对的。

首先，前面已经提到过，阻塞、非阻塞和同步、异步其实针对的对象是不一样的。阻塞、非阻塞说的是调用者，同步、异步说的是被调用者。

针对于上文所说的烧水的案例来说，阻塞与非阻塞是形容调用者人的，而同步和异步是形容被调用者烧水这件事儿。
同步里面可以有阻塞的情形，也可以有非阻塞的性情。异步也可以有阻塞的情形和非阻塞的情形。

我们先来看同步场景中是如何包含阻塞和非阻塞情况：

我们是用传统的水壶烧水。在水烧开之前我们一直做在水壶前面，等着水开。这就是阻塞的。
我们是用传统的水壶烧水。在水烧开之前我们先去客厅看电视了，但是水壶不会主动通知我们，需要我们时不时的去厨房看一下水有没有烧开。这就是非阻塞的。

再来看异步场景中是如何包含阻塞和非阻塞情况

我们是用带有提醒功能的水壶烧水。在水烧发出提醒之前我们一直做在水壶前面，等着水开。这就是阻塞的。
我们是用带有提醒功能的水壶烧水。在水烧发出提醒之前我们先去客厅看电视了，等水壶发出声音提醒我们。这就是非阻塞的。

我回到开始的那个问题：由于CPU和内存的速度远远高于外设的速度，所以，在IO编程中，就存在速度严重不匹配的问题。举个例子来说，比如要把100M的数据写入磁盘，CPU输出100M的数据只需要0.01秒，可是磁盘要接收这100M数据可能需要10秒，怎么办呢？

有两种办法：

第一种是CPU等着，也就是程序暂停执行后续代码，等100M的数据在10秒后写入磁盘，再接着往下执行，这种模式称为同步IO；

另一种方法是CPU不等待，只是告诉磁盘，“您老慢慢写，不着急，我接着干别的事去了”，于是，后续代码可以立刻接着执行，这种模式称为异步IO。

同步和异步的区别就在于是否等待IO执行的结果。好比你去麦当劳点餐，你说“来个汉堡”，服务员告诉你，对不起，汉堡要现做，需要等5分钟，于是你站在收银台前面等了5分钟，拿到汉堡再去逛商场，这是同步IO。

你说“来个汉堡”，服务员告诉你，汉堡需要等5分钟，你可以先去逛商场，等做好了，我们再通知你，这样你可以立刻去干别的事情（逛商场），这是异步IO。

很明显，使用异步IO来编写程序性能会远远高于同步IO，但是异步IO的缺点是编程模型复杂。想想看，你得知道什么时候通知你“汉堡做好了”，而通知你的方法也各不相同。如果是服务员跑过来找到你，这是回调模式，如果服务员发短信通知你，你就得不停地检查手机，这是轮询模式。总之，异步IO的复杂度远远高于同步IO。

在Linux下进行网络编程时，我们常常见到同步(Sync)/异步(Async)，阻塞(Block)/非阻塞(Unblock)四种调用方式：

同步和异步的概念描述的是用户线程与内核的交互方式：同步是指用户线程发起IO请求后需要等待或者轮询内核IO操作完成后才能继续执行；而异步是指用户线程发起IO请求后仍继续执行，当内核IO操作完成后会通知用户线程，或者调用用户线程注册的回调函数。

阻塞和非阻塞的概念描述的是用户线程调用内核IO操作的方式：阻塞是指IO操作在没有接收完数据或者没有得到结果之前不会返回，需要彻底完成后才返回到用户空间；而非阻塞是指IO操作被调用后立即返回给用户一个状态值，无需等到IO操作彻底完成。

在Linux下进行网络编程时，服务器端编程经常需要构造高性能的IO模型，常见的IO模型有五种：

（1）同步阻塞IO（Blocking IO）
（2）同步非阻塞IO（Non-blocking IO）
（3）IO多路复用（IO Multiplexing）
（4）信号驱动IO（signal driven IO）
（5）异步IO（Asynchronous IO）

3.五种IO模型：

1.同步阻塞IO（Blocking IO):

即传统的IO模型，在linux中默认情况下所有的socket都是阻塞模式。当用户进程调用了read()这个系统调用，内核就开始了IO的第一个阶段：准备数据。对于网络IO来说，很多时候数据在一开始还没有到达（比如，还没有收到一个完整的UDP包），这个时候内核就要等待足够的数据到来。而在用户进程这边，整个进程会被阻塞。当内核一直等到数据准备好了，它就会将数据从内核中拷贝到用户内存，然后内核返回结果，用户进程才解除阻塞的状态，重新运行起来；几乎所有的程序员第一次接触到的网络编程都是从listen()、read()、write() 等接口开始的，这些接口都是阻塞型的，一个简单的改进方案是在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。
在这里插入图片描述

2.同步非阻塞IO（Non-blocking IO）：

默认创建的socket都是阻塞的，同步非阻塞IO是在同步阻塞IO的基础上，将socket设置为NONBLOCK，这个可以使用ioctl()系统调用设置。这样做用户线程可以在发起IO请求后可以立即返回，如果该次读操作并未读取到任何数据，用户线程需要不断地发起IO请求，直到数据到达后，才真正读取到数据，继续执行。整个IO请求的过程中，虽然用户线程每次发起IO请求后可以立即返回，但是为了等到数据，仍需要不断地轮询、重复请求，消耗了大量的CPU的资源。一般很少直接使用这种模型，而是在其他IO模型中使用非阻塞IO这一特性。

在这里插入图片描述

3.IO多路复用（IO Multiplexing）：

IO多路复用模型是建立在内核提供的多路分离函数select基础之上的，使用select函数可以避免同步非阻塞IO模型中轮询等待的问题，此外poll、epoll都是这种模型。在该种模式下，用户首先将需要进行IO操作的socket添加到select中，然后阻塞等待select系统调用返回。当数据到达时，socket被激活，select函数返回。用户线程正式发起read请求，读取数据并继续执行。从流程上来看，使用select函数进行IO请求和同步阻塞模型没有太大的区别，甚至还多了添加监视socket，以及调用select函数的额外操作，效率更差。但是，使用select以后最大的优势是用户可以在一个线程内同时处理多个socket的IO请求。用户可以注册多个socket，然后不断地调用select读取被激活的socket，即可达到在同一个线程内同时处理多个IO请求的目的。而在同步阻塞模型中，必须通过多线程的方式才能达到这个目的。

在这里插入图片描述

4 .信号驱动IO（signal driven IO）：

调用sigaltion系统调用，当内核中IO数据就绪时以SIGIO信号通知请求进程，请求进程
再把数据从内核读入到用户空间，这一步是阻塞的。

5.异步IO（Asynchronous IO）：

即经典的Proactor设计模式，也称为异步非阻塞IO。“真正”的异步IO需要操作系统更强
的支持。在IO多路复用模型中，事件循环将文件句柄的状态事件通知给用户线程，由用户线程自行读取数据、处理数据。而在异步IO模型中，当用户线程收到通知时，数据已经被内核读取完毕，并放在了用户线程指定的缓冲区内，内核在IO完成后通知用户线程直接使用即可。

相比于IO多路复用模型，信号驱动IO和异步IO并不十分常用，不少高性能并发服务程序使用IO多路复用模型+多线程任务处理的架构基本可以满足需求。况且目前操作系统对异步IO的支持并非特别完善，更多的是采用IO多路复用模型模拟异步IO的方式。

在这里我们把前三种做一个形象地类比：

阻塞IO, 给女神发一条短信, 说我来找你了, 然后就默默的一直等着女神下楼, 这个期间除了等待你不会做其他事情；
非阻塞IO, 给女神发短信, 如果不回, 接着再发, 一直发到女神下楼, 这个期间你除了发短信等待不会做其他事情；
IO多路复用, 是找一个宿管大妈来帮你监视下楼的女生, 这个期间你可以些其他的事情，例如可以顺便玩玩王者荣耀, 打篮球等等。IO复用又包括 select, poll, epoll 模式.

那么它们的区别是什么?
select大妈每一个女生下楼, select大妈都不知道这个是不是你的女神, 她需要一个一个询问, 并且select大妈能力还有限, 最多一次帮你监视1024个妹子；

poll大妈不限制盯着女生的数量, 只要是经过宿舍楼门口的女生, 都会帮你去问是不是你女神；

epoll大妈不限制盯着女生的数量, 并且也不需要一个一个去问. 那么如何做呢? epoll大妈会为每个进宿舍楼的女生脸上贴上一个大字条,上面写上女生自己的名字, 只要女生下楼了, epoll大妈就知道这个是不是你女神了, 然后大妈再通知你；

二、select多路复用

1、基本概念

IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：

当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。

当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。

如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。

如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。

如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。

与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

2、select()函数

select()函数允许进程指示内核等待多个事件(文件描述符)中的任何一个发生，并只在有一个或多个事件发生或经历一段指定时间后才唤醒它，然后接下来判断究竟是哪个文件描述符发生了事件并进行相应的处理,函数原型如下：

#include <sys/select.h>
#include <sys/time.h>
struct timeval
{
   
long tv_sec; //seconds
long tv_usec; //microseconds
};
FD_ZERO(fd_set* fds) //清空集合
FD_SET(int fd, fd_set* fds) //将给定的描述符加入集合
FD_ISSET(int fd, fd_set* fds) //判断指定描述符是否在集合中
FD_CLR(int fd, fd_set* fds) //将给定的描述符从文件中删除

int select(int max_fd, fd_set *readset, fd_set *writeset, fd_set *exceptset, struct timeval *timeout);

说明：

select监视并等待多个文件描述符的属性发生变化，它监视的属性分3类，分别是readfds(文件描述符有数据到来可读)、writefds(文件描述符可写)、和exceptfds(文件描述符异常)。调用后select函数会阻塞，直到有描述符就绪（有数据可读、可写、或者有错误异常），或者超时（timeout 指定等待时间）发生函数才返回。当select()函数返回后，可以通过遍历 fdset，来找到究竟是哪些文件描述符就绪。
timeout告知内核等待所指定描述字中的任何一个就绪可花多少时间。其timeval结构用于指定这段时间的秒数和微秒数。这个参数有三种可能：
（1）永远等待下去：仅在有一个描述字准备好I/O时才返回。为此，把该参数设置为空指针NULL。
（2）等待一段固定时间：在有一个描述字准备好I/O时返回，但是不超过由该参数所指向的timeval结构中指定的秒数和微秒数。
（3）根本不等待：检查描述字后立即返回，这称为轮询。为此，该参数必须指向一个timeval结构，而且其中的定时器值必须为0。
select函数的返回值是就绪描述符的数目，超时时返回0，出错返回-1；
第一个参数max_fd指待测试的fd的总个数，它的值是待测试的最大文件描述符加1。Linux内核从0开始到max_fd-1扫描文件描述符，如果有数据出现事件(读、写、异常)将会返回；假设需要监测的文件描述符是8,9,10，那么Linux内核实际也要监测0_{7，此时真正带测试的文件描述符是0}10总共11个，即max(8,9,10)+1，所以第一个参数是所有要监听的文件描述符中最大的+1。
中间三个参数readset、writeset和exceptset指定要让内核测试读、写和异常条件的fd集合，如果不需要测试的可以设置为NULL；
最后一个参数是设置select的超时时间，如果设置为NULL则永不超时；需要注意的是待测试的描述集总是从0， 1， 2， …开始的。所以，假如你要检测的描述符为8， 9， 10，那么系统实际也要监测0， 1， 2， 3， 4， 5， 6, 7，此时真正待测试的描述符的个数为11个，也就是max（8， 9， 10） + 1在Linux内核有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数中，这也意味着select所用到的FD_SET是有限的，也正是这个原因select()默认只能同时处理1024个客户端的连接请求：

/linux/posix_types.h:
#define __FD_SETSIZE 1024

下面是使用select()多路复用实现网络socket服务器多路并发的流程图：

在这里插入图片描述

下面是使用select()多路复用实现的服务器端示例代码：

#include <stdio.h>
#include <stdlib.h>#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))

static inline void msleep(unsigned long ms);
static inline void print_usage(char *progname);
int socket_server_init(char *listen_ip, int listen_port);

int main(int argc, char **argv)
{
   
        int listenfd, connfd;
        int serv_port = 0;
        int daemon_run = 0;
        char *progname = NULL;
        int opt;
        fd_set rdset;
        int rv;
        int i, j;
        int found;
        int maxfd=0;
        char buf[1024];
        int fds_array[1024];
        
struct option long_options[] =
{
   
        {
   "daemon", no_argument, NULL, 'b'},
        {
   "port", required_argument, NULL, 'p'},
        {
   "help", no_argument, NULL, 'h'},
        {
   NULL, 0, NULL, 0}
};

        progname = basename(argv[0]);
        /* Parser the command line parameters */
        while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
        {
   
                switch (opt)
                {
   
                        case 'b':
                        daemon_run=1;
                        break;
                        case 'p':
                        serv_port = atoi(optarg);
                        break;
                        case 'h': /* Get help information */
                        print_usage(progname);
                        return EXIT_SUCCESS;
                        default:
                        break;
                }
        }
        if( !serv_port )
        {
   
                print_usage(progname);
                return -1;}
                if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
                {
   
                        printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
                        return -2;
                }
        printf("%s server start to listen on port %d\n", argv[0],serv_port);
        /* set program running on background */
        if( daemon_run )
        {
   
                daemon(0, 0);
        }
        for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
        {
   
                fds_array[i]=-1;
        }
        fds_array[0] = listenfd;
        for ( ; ; )
        {
   
                FD_ZERO(&rdset);
                for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
                {
   
                        if( fds_array[i] < 0 )
                        continue;
                        maxfd = fds_array[i]>maxfd ? fds_array[i] : maxfd;
                        FD_SET(fds_array[i], &rdset);
                }
                /* program will blocked here */
                rv = select(maxfd+1, &rdset, NULL, NULL, NULL);
                if(rv < 0)
                {
   
                        printf("select failure: %s\n", strerror(errno));
                        break;
                }
                else if(rv == 0