Cleofwine | 开发者

后端技术_网络io与io多路复用

最近更新：2024-09-23 | 字数总计：2.7k | 阅读估时：10分钟 | 阅读量：次

五种IO网络模型

五种IO网络模型

网络 IO，会涉及到两个系统对象，一个是用户空间调用 IO 的进程或者线程，另一个是内核空间的内核系统，比如发生 IO 操作 read 时，它会经历两个阶段：

等待数据准备就绪
将数据从内核拷贝到进程或者线程中。

因为在以上两个阶段上各有不同的情况，所以出现了多种网络 IO 模型

阻塞IO（blocking IO）

在 linux 中，默认情况下所有的 socket 都是 blocking，当用户进程调用了 read 这个系统调用， kernel 就开始了 IO 的第一个阶段：准备数据。对于network io 来说，很多时候数据在一开始还没有到达（比如，还没有收到一个完整的数据包），这个时候 kernel 就要等待足够的数据到来。而在用户进程这边，整个进程会被阻塞。当 kernel一直等到数据准备好了，它就会将数据从 kernel 中拷贝到用户内存，然后 kernel 返回结果，用户进程才解除 block 的状态，重新运行起来。
所以， blocking IO 的特点就是在 IO 执行的两个阶段（等待数据和拷贝数据两个阶段）都被block 了。
实际上，除非特别指定，几乎所有的 IO 接口 ( 包括 socket 接口 ) 都是阻塞型的。这给网络编程带来了一个很大的问题，如在调用 send()的同时，线程将被阻塞，在此期间，线程将无法执行任何运算或响应任何的网络请求。一个简单的改进方案是在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。

一个连接一个线程处理模式

##include <stdio.h>
##include <errno.h>
##include <unistd.h>
##include <string.h>
##include <sys/socket.h>
##include <netinet/in.h>

##include <fcntl.h>
##include <pthread.h>

##define BUFFER_LENGTH 1024

// 一个连接一个线程的方式
void *client_thread(void *arg)
{
	int clientfd = *(int*)arg;
	while(1){
		// 接收数据, recv也是阻塞的
		char buffer[BUFFER_LENGTH] = {0};
		int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
		if(ret == 0) // 主动断开
		{
		
	close(clientfd);
			break;
		}
		printf("ret : %d, Buffer : %s\n",ret, buffer);
		// 发送数据
		send(clientfd, buffer, ret, 0);

	}
}

int main()
{
	// open
	int sockfd = socket(AF_INET, SOCK_STREAM, 0); // fd

	// 监听ip
	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(struct sockaddr_in));

	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(9999);

	// 绑定地址
	if(-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr)))
	{
		printf("bind failed: %s", strerror(errno));
		return -1;
	}
	// 开始监听
	listen(sockfd, -1);

##if 0
	// 设置非阻塞，否则accept是一个阻塞io
	int flags = fcntl(sockfd, F_GETFL, 0);
	flags |= O_NONBLOCK;
	fcntl(sockfd, F_SETFL, flags);
##endif

	// acceptfd相当于一次连接的服务员，每个连接都需要分配一个accept_fd
	struct sockaddr_in clientaddr;
	socklen_t len = sizeof(clientaddr);
	
	while(1)
	{
		int clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len);

	#if 0
		// 接收数据, recv也是阻塞的
		char buffer[BUFFER_LENGTH] = {0};
		int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);

		printf("ret : %d, Buffer : %s\n",ret, buffer);
		// 发送数据
		send(clientfd, buffer, ret, 0);
	#else
		pthread_t threadid; // 把数据处理都放到线程里执行，防止多个accept阻塞数据收发
		pthread_create(&threadid, NULL, client_thread, &clientfd);
		
	#endif
	}
}

非阻塞IO（non-blocking IO）

当用户进程发出 read 操作时，如果 kernel 中的数据还没有准备好，那么它并不会 block 用户进程，而是立刻返回一个 error。从用户进程角度讲，它发起一个
read 操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个 error时，它就知道数据还没有准备好，于是它可以再次发送 read 操作。一旦 kernel 中的数据准备好了，并且又再次收到了用户进程的 system call，那么它马上就将数据拷贝到了用户内存，然后返回，所以，在非阻塞式 IO 中，用户进程其实是需要不断的主动询问 kernel数据准备好了没有。
在非阻塞状态下， recv() 接口在被调用后立即返回，返回值代表了不同的含义。如在

recv() 返回值大于 0，表示接受数据完毕，返回值即是接受到的字节数；
recv() 返回 0，表示连接已经正常断开；
recv() 返回 -1，且 errno 等于 EAGAIN，表示 recv 操作还没执行完成；
recv() 返回 -1，且 errno 不等于 EAGAIN，表示 recv 操作遇到系统错误 errno。

非阻塞的接口相比于阻塞型接口的显著差异在于，在被调用之后立即返回。使用如下的函数可以将某句柄 fd 设为非阻塞状态。

fcntl( fd, F_SETFL, O_NONBLOCK );

循环调用 recv()将大幅度推高 CPU占用率；此外，在这个方案中 recv()更多的是起到检测“操作是否完成”的作用，实际操作系统提供了更为高效的检测“操作是否完成“作用的接口，例如 select()多路复用模式，可以一次检测多个连接是否活跃。

多路复用IO（IO multiplexing）

select/epoll 的好处就在于单个 process 就可以同时处理多个网络连接的 IO。它的基本原理就是 select/epoll 这个 function会不断的轮询所负责的所有 socket，当某个 socket 有数据到达了，就通知用户进程。
当用户进程调用了 select，那么整个进程会被 block，而同时， kernel 会“监视”所有 select 负责的 socket，当任何一个 socket 中的数据准备好了， select 就会返回。这个时候用户进程再调用 read 操作，将数据从 kernel 拷贝到用户进程。
如果处理的连接数不是很高的话，使用select/epoll 的 web server 不一定比使用 multi-threading + blocking IO 的 web server 性能更好，可能延迟还更大。 select/epoll 的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。
多路复用模型中，对于每一个 socket，一般都设置成为 non-blocking，整个用户的 process 其实是一直被 block 的。只不过 process 是被 select 这个函数 block，而不是被 socket IO 给 block。因此 select()与非阻塞 IO 类似。

IO多路复用

select

select , maxfd 最大检测fd， rfds 检测可读， wfds 检测可写， efds 检测出错， timeout 超时；
缺点：
select 的bit map需要传入内核，而且需要通过写入后返回，让我们可以进行判断；
select 的bit map底层是通过循环，判断每一位，然后更改每一位的结果
select 的bit map是通过数组实现的，是有长度限制的，有可能会出现溢出的情况

fd_set rfds; // 检测可读，bit位
FD_ZERO(&rfds);
FD_SET(sockfd, &rfds);

fd_set rset;

int maxfd = sockfd;
int clientfd;

while(1)
{
    rset = rfds;
    int nready = select(maxfd + 1, &rset, NULL,NULL,NULL);

    if(FD_ISSET(sockfd, &rset)) // 检测sockfd是否已经可读
    {

        clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len);
        printf("accept : %d\n", clientfd);

        FD_SET(clientfd, &rfds);
        if(clientfd > maxfd) maxfd = clientfd;

        if(--nready == 0) continue;
    }

    int i = 0; // 将所有可读的fd一起处理
    for(int i = sockfd + 1;i <= maxfd;i++)
    {

        if(FD_ISSET(i, &rset))
        {
            char buffer[BUFFER_LENGTH] = {0};
            int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
            printf("ret : %d, Buffer : %s\n",ret, buffer);
        }
    }
}

poll

poll 也对fd数量有限制
也是遍历的实现

但是因为是定义了事件，所以接口更简单了

struct pollfd fds[POLL_SIZE] = {0};
fds[sockfd].fd = sockfd;
fds[sockfd].events = POLLIN;

int maxfd = sockfd;

int clientfd = 0;

while(1)
{
    int nready = poll(fds, maxfd + 1, -1);
    if(fds[sockfd].revents & POLLIN) // 检测该fd是否返回了pollin事件
    {
        clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len);
        printf("accept : %d\n", clientfd);

        fds[clientfd].fd = clientfd;
        fds[clientfd].events = POLLIN;
        
        if(clientfd > maxfd) maxfd = clientfd;

        if(--nready == 0) continue;
    }

    for(int i = 0;i<=maxfd;i++)
    {
        if(fds[i].revents & POLLIN)
        {
            char buffer[BUFFER_LENGTH] = {0};
            int ret = recv(i, buffer, BUFFER_LENGTH, 0);
            if(ret == 0)
            {
                fds[i].fd = -1;
                fds[i].events = 0;
                close(i);
                break;
            }
            printf("ret : %d, Buffer : %s\n",ret, buffer);
        }
    }
}

异步IO（Asynchronous I/O）

用户进程发起 read 操作之后，立刻就可以开始去做其它的事。而另一方面，从 kernel的角度，当它受到一个 asynchronous read 之后，首先它会立刻返回，所以不会对用户进程产生任何 block。然后， kernel 会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后， kernel 会给用户进程发送一个 signal，告诉它 read 操作完成了。

信号驱动IO

首先我们允许套接口进行信号驱动 I/O,并安装一个信号处理函数，进程继续运行并不阻塞。当数据准备好时，进程会收到一个 SIGIO 信号，可以在信号处理函数中调用 I/O 操作函数处理数据。当数据报准备好读取时，内核就为该进程产生一个 SIGIO 信号。我们随后既可以在信号处理函数中调用 read 读取数据报，并通知主循环数据已准备好待处理，也可以立即通知主循环，让它来读取数据报。无论如何处理 SIGIO 信号，这种模型的优势在于等待数据报到达(第一阶段)期间，进程可以继续执行，不被阻塞。免去了 select 的阻塞与轮询，当有活跃套接字时，由注册的 handler 处理。

五种IO网络模型总结

阻塞IO与非阻塞IO

blocking 与 non-blocking。前面的介绍中其实已经很明确的说明了这两者的区别。调用 blocking IO 会一直 block 住对应的进程直到操作完成，而
non-blocking IO 在 kernel 还在准备数据的情况下会立刻返回。

同步IO与异步IO

synchronous IO 与 asynchronous IO。两者的区别就在于 synchronous IO 做”IO operation”的时候会将 process 阻塞。按照这个定义，之前所述的 blocking IO， non-blocking IO， IO multiplexing 都属于synchronous IO。有人可能会说， non-blocking IO 并没有被 block 啊。这里有个非常“狡猾”的地方，定义中所指的”IO operation”是指真实的 IO 操作，就是例子中的 read 这个系统调用。 non-blocking IO 在执行 read 这个系统调用的时候，如果 kernel 的数据没有准备好，这时候不会 block 进程。但是当 kernel 中数据准备好的时候， read 会将数据从 kernel 拷贝到用户内存中，这个时候进程是被 block 了，在这段时间内进程是被 block的。而 asynchronous IO 则不一样，当进程发起 IO 操作之后，就直接返回再也不理睬了，直到 kernel 发送一个信号，告诉进程说 IO 完成。在这整个过程中，进程完全没有被 block。

2023-11-28 该篇文章被 Cleofwine 归为分类: 服务端