Linux网络IO模型浅析（三）多路复用IO

最新推荐文章于 2024-08-03 12:18:10 发布
最新推荐文章于 2024-08-03 12:18:10 发布
阅读量176 收藏 1
点赞数
分类专栏： 网络编程 文章标签： linux 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46833172/article/details/129973316
版权

Linux网络IO模型浅析（三）多路复用IO

多路复用IO（IO multiplexing）

提到IO multiplexing，可能大部分人会感觉到陌生，但实际上我们平时用的select，epoll等就是多路复用IO的实例。

因为IO多路复用本质上是内核一旦发现某进程指定的一个或多个IO产生事件，就通知该进程，所以有些时候我们也称这种IO方式为事件驱动IO(event driven IO)。

多路复用的意义

应用程序如果同时处理多路输入输出流：

  • 如果采用阻塞模式，将得不到预期的目的
  • 如果采用非阻塞模式，对多个输入进行轮询，又太浪费时间
  • 如果设置多个进程或进程，分别处理一条数据通路的数据，将产生同步互斥问题，让程序变得复杂。
  • 与多进程多线程相比，IO多路复用技术的最大优势是系统开销小（系统不必创建进程/线程，也不必维护这些进程线程，从而大大减少系统开销）

多路复用基本思想：

​ 1. 构建一张有关文件描述符的表，然后调用函数将要监控的文件fd加入到表中
​ 2. 当文件描述符的表中一个或多个已经就绪准备好了才返回
​ 3. 函数返回时候告诉进程哪个文件描述符就绪，我们就可以对其直接进行IO操作了

IO多路复用基本流程如下：
在这里插入图片描述
上图以select为例，调用select后，线程将被阻塞，之后kernel监听注册到文件描述符列表里的socket，当一个或多个socket产生了事件（数据可读），select则返回。此时用户空间再调用read函数将数据从kernel拷贝到用户空间。
在响应一次网络请求的过程中，多路复用模型会经历两次阻塞：

  1. select函数调用后的阻塞
  2. read函数调用后的阻塞

对比阻塞IO的过程来看，甚至还多了一次阻塞，所以我们可以大胆推测，在连接数不多的情况下，使用阻塞IO + 多线程去处理请求，整体表现很可能比多路复用要更好 。所以多路复用的优势从来不是单连接时可以处理的更快，而是单线程可以处理多个连接。

select相关介绍

select优劣分析

优点：

  1. 跨平台性强：select在多种操作系统上都有实现，支持跨平台编程。
  2. 简单易用：select接口简单易用，使用方便，占用的CPU资源也较少。
  3. 支持多种I/O事件：select不仅能够监控读写事件，还可以监控异常事件。这使得select可以应对更加复杂的I/O场景。

劣势：

  1. 效率较低：当文件描述符数量很大时，每次调用select都需要将所有文件描述符从用户空间复制到内核空间并轮询状态，这会导致一定的开销，阻塞时间随着监听的fd个数增加而增大。
  2. 可扩展性受限：select有一个最大文件描述符数量的限制，如果需要监控的文件描述符数量超出限制，则需要重新编写程序。

简而言之，当需求的响应模型比较简单，服务的网络请求较少完全可以使用select模型，但是当需要服务一个10K级的海量接入，selcet显然无力迎战，更不要提100K,1000K的接入了。所以当我们需求需要一个高效的网络服务模型去处理海量接入时，我们可以采用epoll（Linux）或kqueue（FreeBSD和Mac OS X）；

select接口介绍

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

//该函数准许进程指示内核等待多个事件中任何一个发送，并只在一个或多个事件发生后唤醒
int select(int maxfd, 
           fd_set *readfds, 
           fd_set *writefds,
           fd_set *exceptfds, 
           struct timeval *timeout);

/*参数：
    int maxfd 指定待测试的最大文件描述符+1（因为fd从0开始的）
	fd_set *readfds  指定我们要内核测试读文件描述符的集合 
	fd_set *writefds 指定我们要内核测试写文件描述符的集合
	fd_set *exceptfds指定我们要内核测试异常文件描述符的集合
	struct timeval *timeout //超时设置 1、填NULL：一直阻塞，直到有文件描述符就绪或出错
	2、填充时间结构体timeval
    时间值为0：非阻塞，仅仅检测文件描述符集合的状态，直接返回
    设置的时间不为0：在设置的时间内，如果没有产生事件，就会超时返回，如果产生了事件正常返回。
   	返回值：
    出错：返回-1
    没有产生事件，时间却到了，返回0
    有事件产生（一个或多个），返回>0
    struct timeval{
		long tv_sec;
        long tv_usec;
        }
//操作集合函数

返回值：
	-1出错
	>0表示有多个事件产生*/
	void FD_CLR(int fd, fd_set *set);  //将文件描述符fd从set集合中删除（从集合中删除）
	int  FD_ISSET(int fd, fd_set *set);//判断fd是否在set集合中
	void FD_SET(int fd, fd_set *set);  //把fd设置进set集合中（加入集合）
	void FD_ZERO(fd_set *set);         //清空集合

select编程demo

#include<stdio.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/poll.h>
#include <sys/epoll.h>
#include <pthread.h>
#define MAXLNE 1024
int main(int argc, char **argv) {
    int listenfd, connfd, n;
    struct sockaddr_in servaddr = {0};
    char buff[MAXLNE] = {0};
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(9999);
 
    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }
 
    if (listen(listenfd, 10) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    fd_set rfds, rset, wfds, wset;  ///< set 用来注册  fds用来操作

    FD_ZERO(&rfds);
    FD_ZERO(&wfds);                                                            
    FD_SET(listenfd, &rfds);
    int max_fd = listenfd;
    while (1) {
        rset = rfds;
        wset = wfds;

        int nready = select(max_fd + 1, &rset, &wset, NULL, NULL);  ///< 阻塞监听读写事件，直至返回

        if (FD_ISSET(listenfd, &rset)) {    ///< 判断监听的套接字是否在可读集合中

            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
                printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
                return 0;
            }

            FD_SET(connfd, &rfds);

            if (connfd > max_fd) max_fd = connfd;

            if (--nready == 0) continue;

        }
        int i = 0;
        for (i = listenfd + 1 ; i <= max_fd ; i ++) {   ///< 跳过监听的套接字进行读写

            if (FD_ISSET(i, &rset)) { //

                n = recv(i, buff, MAXLNE, 0);
                if (n > 0) {
                    buff[n] = '\0';
                    printf("recv msg from client: %s\n", buff);
                    FD_CLR(i, &rfds);   ///< 之后本fd不可读
                    FD_SET(i, &wfds);

                } 
                else if (n == 0) { //

                    FD_CLR(i, &rfds);
                    //printf("disconnect\n");
                    close(i);

                }
                if (--nready == 0) break;
            } 
            else if (FD_ISSET(i, &wset)) {
                buff[n] = 10;   ///< 换行符
                buff[n + 1] = 0;    ///< 结束符
                send(i, buff, n + 1, 0);
                FD_CLR(i, &wfds);   ///< 之后本fd不可写
                FD_SET(i, &rfds);   ///< 之后本fd可读                                
            }
        }
    }
}

上述是一个简单的但是勉强能展现效果的使用实例，可用来简单展示select的使用方法。
为了节约时间笔者使用了网络助手进行数据传输测试：
在这里插入图片描述

epoll相关介绍

epoll的优劣分析

优势：

  1. 高效：epoll采用了事件驱动的方式，只有在IO事件发生时才会被唤醒，相比于select和poll等多路复用机制，可以避免不必要的系统调用。
  2. 可伸缩性好：epoll支持一个进程监听多个文件描述符，同时也支持多个进程监听同一个文件描述符，能够满足高并发、高连接数的需求。
  3. 没有文件描述符数量限制：epoll没有最大连接数的限制，它所支持的连接数与内存大小有关，能够处理成千上万个并发连接。
  4. 支持边沿触发和水平触发：epoll可以通过设置事件类型为边沿触发或水平触发来适应不同场景的需要（实际编程场景中，二者差别不大）。

劣势：

  1. 对代码质量要求高：epoll使用起来相对复杂，对代码质量和程序设计要求较高。
  2. 兼容性差：epoll只能在Linux系统下使用，不具备跨平台的优势。

epoll接口介绍

epoll主要有以下几个接口：

int epoll_create(int size);
//参数size指定了epoll实例中能够注册的文件描述符最大数量，返回一个epoll实例的句柄。实际上传一个正数即可

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
//向epoll实例中添加、修改或删除一个文件描述符，op参数值为EPOLL_CTL_ADD、EPOLL_CTL_MOD或EPOLL_CTL_DEL，分别表示添加、修改和删除操作。event参数是一个epoll_event结构体指针，用来指定事件类型和对应的文件描述符。

//int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
等待文件描述符上的事件发生并返回就绪的文件描述符信息，maxevents参数指定最多返回的事件数量，timeout参数指定等待时间。调用成功返回返回就绪的文件描述符数量，如果超时则返回0，如果出错则返回-1。

struct epoll_event;
//epoll_event结构体用于指定事件类型和对应的文件描述符，包含以下几个字段：

typedef union epoll_data {
	void *ptr;
	int fd;
	uint32_t u32;
	uint64_t u64;
} epoll_data_t;

struct epoll_event {
	uint32_t events;	/* epoll 事件 */
	epoll_data_t data;	/*用户数据 */
};

//其中events字段指定关注的事件类型，可以是EPOLLIN、EPOLLOUT、EPOLLERR、EPOLLHUP和EPOLLET等；data字段用于存储用户自定义的数据，可以是指针、文件描述符或者整数等。

epoll编程实例

#include<stdio.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/poll.h>
#include <sys/epoll.h>
#include <pthread.h>

#define MAXLNE  4096
#define POLL_SIZE	1024
int main(int argc, char **argv)
{
    int listenfd, connfd, n;
    struct sockaddr_in servaddr;
    char buff[MAXLNE];

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

	int reuse = 1;
	setsockopt(listenfd ,SOL_SOCKET ,SO_REUSEADDR, &reuse, sizeof(reuse));

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(9999);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    if (listen(listenfd, 10) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

	
	int epfd = epoll_create(1);		 ///< 创建epoll句柄

	struct epoll_event events[POLL_SIZE] = {0};
	struct epoll_event ev;

	ev.events = EPOLLIN;
	ev.data.fd = listenfd;

	epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

	while (1) {

		int nready = epoll_wait(epfd, events, POLL_SIZE, 5);
		if (nready == -1) {
			continue;
		}

		int i = 0;
		for (i = 0 ; i < nready ; i ++) {

			int clientfd =  events[i].data.fd;
			if (clientfd == listenfd) {

				struct sockaddr_in client;
			    socklen_t len = sizeof(client);
			    if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
			        printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
			        return 0;
			    }

				printf("accept\n");
				ev.events = EPOLLIN;
				ev.data.fd = connfd;
				epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);

			} 
			else if (events[i].events & EPOLLIN) {

				n = recv(clientfd, buff, MAXLNE, 0);
		        if (n > 0) {
		            buff[n] = '\0';
		            printf("recv msg from client: %s\n", buff);
					buff[n] = 10;
					buff[n + 1] = 0;
					send(clientfd, buff, n + 1, 0);
		        } 
				else if (n == 0) { 
					ev.events = EPOLLIN;
					ev.data.fd = clientfd;
					epoll_ctl(epfd, EPOLL_CTL_DEL, clientfd, &ev);
		            close(clientfd);
		        }
			}
		}
	}
    close(listenfd);
    return 0;
}

同样也是一个简单的epoll编程实例，只实现了简单的回传功能，仅作参考。
经测试效果如下：
在这里插入图片描述

写到最后

有上述可知，IO多路复用机制选型并不存在绝对的优劣，不同的应用场景可以选用合适的多路复用模型。同时有很多事件驱动库将众多模型集成，同时简化接口。常见的事件驱动库有libevent 库，还有作为libevent 替代者的libev库。这些库会根据操作系统的特点选择最合适的事件探测接口，并且加入了信号(signal) 等技术以支持异步响应，这使得这些库成为构建事件驱动模型的不二选择。

本专栏知识点是通过<零声教育>的系统学习，进行梳理总结写下文章，对c/c++linux课程感兴趣的读者，可以去零声官网查看详细的服务:

我叫大魔宝
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux下使用EPoll+队列+多线程的C++实现
12-24
该源代码使用linux的网络IO多路复用模型epoll在建立tcpserver，对用队列来缓存请求，使用线程池来处理请求。
Libev库学习2---简单的IO多路复用服务器
山鸡哥的专栏
02-23 717
1.用到的库 ①libev 使用它的对于select，epoll等等的封装来实现IO多路复用 ②csapp 使用的是csapp书中的socket函数，以及包装函数来实现一些socket的函数 2.功能 server关注的事件有两个。 ①listenfd有连接请求到来的时候，accept，并且将建立的新的socket连接建立为监听事件，加入loop之中。 ②在connfd上面有信
Linux网络编程——IO多路复用
NRWHF的博客
11-29 814
Linux网络编程——IO多路复用
2、Linux网络编程IO多路复用
qq_44918555的博客
07-27 390
IO多路复用的三个API,select \ poll \ epoll
io复用相对于多进程、多线程的优势
jigetage的专栏
03-25 1027
网络编程中，实现并发的方法一般都是多线程、多进程、io复用技术。 当被问到io复用技术相对于多线程、多进程的优势时，可以这样回答： cpu的最佳理想工作状态时：当需要的时候立即被调度到，当不需要的时候就好像没有一样。对于多进程、多线程方式，不论有无实际消息进来，线程/进程都可能被分配cpu的时间片，如果被cpu调度的时候，正好没有消息进来，那么就会造成cpu空调度，浪费资源。而对于io复用技术...
IO多路复用和线程池哪个效率更高，更有优势
snoweaglelord的博客
08-16 9211
io多路复用（这翻译真的很坑爹啊），指的是同一个进（线）程可以处理多个IO数据流。 多线程+池模型指的是每个线程处理一个IO流。 O多路复用的优势在于，当处理的消耗对比IO几乎可以忽略不计时，可以处理大量的并发IO，而不用消耗太多CPU/内存。这就像是一个工作很高效的人，手上一个todo list，他高效的依次处理每个任务。这比每个任务单独安排一个人要节省（雇人是要发工资的……）。典型的例子...
IO
qq_43204550的博客
10-15 297
BIO---Blocking IO(阻塞I/O模型) 阻塞I/O模型是常见的I/O模型，在读写数据时客户端会发生阻塞。阻塞I/O模型的工作流程为：在用户线程发出I/O请求之后，内核会检查数据是否就绪，此时用户线程一直阻塞等待内存数据就绪；在内存数据就绪后，内核将数据复制到用户线程中，并返回I/O执行结果到用户线程，此时用户线程将解除阻塞状态并开始处理数据。典型的阻塞I/O模型的例子为data = socket.read()，如果内核数据没有就绪，Socket线程就会一直阻塞在read()中等待内核数据就
linux 连接数 限制,linux设置最大连接数
weixin_39835792的博客
05-25 6718
1.最大文件打开数限制查看前用户进程打开的文件数限制，命令行执行：ulimit -n默认1024.这表示当前用户的每个进程最多允许同时打开1024个文件，这1024个文件中还得除去每个进程必然打开的标准输入，标准输出，标准错误，服务器监听 socket，进程间通讯的unix域socket等文件，那么剩下的可用于客户端socket连接的文件数就只有大概1024-10=1014个左右。也就是说缺省情况...
再看Spring之Spring5新特性——【Webflux】
风间琉璃の博客
05-31 594
1. Spring5新功能 Spring5基于JDK8并且兼容JDK9。并且自带一个日志框架 1.1 @Nullable注解 可以添加在： 属性，表示属性值可以为空； 方法，返回值可以为空； 参数，参数可以为空。 1.2GenericApplicationContext函数式风格 ...
程序员如果都懂SpringWebFlux框架的话，也不用天天CRUD了
java_lujj的博客
09-12 1970
Spring WebFlux基于Reactor框架，同时支持RxJava类库，构建响应式编程框架。查看WebFlux的Maven依赖，可以发现它依赖的项目工程包有Reactor、Spring、ReactiveX、RxJava等模块，使用WebFlux需要单独引用它的依赖包，WebFlux主要的包依赖关系如下图所示。转存失败重新上传取消WebFlux的主要特征● 采用Reactor响应式编程框架，同时提供对RxJava类库的支持。
29. Spring Boot 2.x 最佳实践之 Spring Web Flux 集成
极客星云-CSDN博客
04-05 511
这篇博文我们来分享下Spring Boot 与Spring Web Flux 的集成。
IO多路复用原理（大白话，通俗易懂）
热门推荐
Squid87的博客
03-12 3万+
IO多路复用原理BIONIOIO多路复用之select模型和poll模型IO多路复用之epoll模型Reactor模型 IO多路复用技术： 讲IO多路复用技术之前，我们得先了解NIO和BIO。 BIO BIO （Block IO）：同步阻塞IO。一般我们传统的JDK内置的Socket编程就是阻塞IO。其底层流程是：①创建socket接口，号为x，通过bind函数将接口号与端口号进行绑定，然后进行listn监听事件或者是read读事件，且会一直阻塞在该命令，直到有客户端连接或者发送数据。 缺点：如果是在单线程
全网最详细的 I/O 多路复用解析
程序员囧辉
05-11 1万+
看完起飞
C语言 Linux 聊天室(IO多路复用、多线程)
qingjiao_fa的博客
08-03 2008
服务器:建立套接字、设置ip和port、绑定ip和port、监听、连接、收发消息。​ 客户端：建立套接字、配置服务器ip和port、连接服务器、创建线程收发消息。建立一个服务器,有很多个客户端加入服务器，就可以实现群聊功能。​服务器需要很多连接加入，所以用到IO多路复用。我们创建4个终端，1个服务器，3个客户端。...
Linux IO多路复用之epoll网络编程(含源码)
weixin_33948416的博客
01-17 301
前言 本章节是用基本的Linux基本函数加上epoll调用编写一个完整的服务器和客户端例子，可在Linux上运行，客户端和服务端的功能如下: 客户端从标准输入读入一行，发送到服务端 服务端从网络读取一行，然后输出到客户端 客户端收到服务端的响应，输出这一行到标准输出   服务端 代码如下: #include &lt;unistd.h&gt;#include &lt;sys/...
Linux文件与目录管理命令 ls cp rm mv使用方法
最新发布
云计算课代表
08-03 456
Linux文件与目录的管理基本上包括：显示属性、复制、删除、移动文件与目录等，由于文件与目录的管理不仅重要而且操作频繁，所以本文列举一些常用的管理命令。
Linux初学基本命令
yuan20010401的博客
07-25 1237
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
【Linux】进程间通信（3）：共享内存
2301_76606232的博客
07-31 764
共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间，进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种互斥与同步的机制，互斥锁和信号量都可以。
优化并发服务器：多路IO模型与线程池策略
总结来说，多路IO复用并发服务器模型通过优化并发机制，降低了资源消耗，提高了系统性能，是现代高性能网络服务器架构的重要组成部分。在实际应用中，根据具体需求选择合适的I/O模式和并发模型是关键，以平衡性能与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我叫大魔宝

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值