io多路复用

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

为什么需要io多路复用

io可以分为阻塞和非阻塞io

io多路复用的前提是使用非阻塞io

通过fcnt函数控制，如下设置成非阻塞；

    int fd = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(fd, F_SETFL, O_NONBLOCK);

阻塞和非阻塞的区别在于无数据的时候是否返回；

在以前的网络使用阻塞io，服务器处理的时候，是采用一问一答的方式，这种方式虽然可行但是由于阻塞，效率低下，而且想要同时处理多个链接的时候就需要多线程或多进程实现（一个链接一个线程或进程），这样的代价太大，性能低，但是逻辑简单。io多路复用能解决这些问题。

io多路复用的优点

仅用一个线程就能处理多个链接，成本小。

事件和处理分开，可以从面向fd的方式转变为面向事件的模式，更加的灵活。

对于事件的处理可拓展性更强，如果要求变动不需要改动结构。

io多路复用的原理

我认为是一个线程管理多个io、有事件就通知、非阻塞io以及循环机制

io多路复用的实现

 实现主流为select、poll、epoll。

首先介绍select，其使用包括（fd_set、select、FD_ZERO、FD_SET、FD_ISSET)。其中fd_set可以理解是一个的int数组，大小（与内核有关）足够存32个int型数据，换算成bit为1024个bit。由于select底层是用bit位来表示事件是否存在，所以select只能表示1024个文件描述符的状态。select底层是用循环判断的事件是否触发，也就意味着select判断是否有事件，就要从最小的文件描述符到已有的最大的文件描述符遍历一次，在这个过程中还要将内核中的fd_set拷贝出来。

这里poll不过多的赘述，底层原理使用的select，优化了接口，文件描述符的数量也得到了提升。

最后是epoll，epoll有3个接口和两个结构（epoll_create、epoll_ctl、epoll_wait、struct epoll_event ev,events[EPOLLSUB]）管理epoll。epoll底层维护了一个红黑树一个就绪队列，用来存储事件和就绪队列。当事件到来时，将红黑树中的事件放到就绪队列当需要处理的时候直接从就绪队列中取出。epoll能管理的文件描述符为65535个。

#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/fcntl.h>
#include<sys/select.h>

#include <sys/poll.h>
#include <sys/epoll.h>


#include <pthread.h>
 
#define MAXLNE  4096

#define POLL_SIZE	1024

//8m * 4G = 128 , 512
//C10k
void *client_routine(void *arg) { //

	int connfd = *(int *)arg;

	char buff[MAXLNE];

	while (1) {

		int n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0) {
            buff[n] = '\0';
            printf("recv msg from client: %s\n", buff);

	    	send(connfd, buff, n, 0);
        } else if (n == 0) {
            close(connfd);
			break;
        }

	}

	return NULL;
}


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;
    }
 
    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;
    }
 #if 0
    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("========waiting for client's request========\n");
    while (1) {

        n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0) {
            buff[n] = '\0';
            printf("recv msg from client: %s\n", buff);

	    	send(connfd, buff, n, 0);
        } else if (n == 0) {
            close(connfd);
        }
        
        //close(connfd);
    }

#elif 0


    printf("========waiting for client's request========\n");
    while (1) {

		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;
	    }

        n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0) {
            buff[n] = '\0';
            printf("recv msg from client: %s\n", buff);

	    	send(connfd, buff, n, 0);
        } else if (n == 0) {
            close(connfd);
        }
        
        //close(connfd);
    }

#elif 0

	while (1) {

		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;
	    }

		pthread_t threadid;
		pthread_create(&threadid, NULL, client_routine, (void*)&connfd);

    }

#elif 0

	// 
	fd_set rfds, rset, wfds, wset;

	FD_ZERO(&rfds);
	FD_SET(listenfd, &rfds);

	FD_ZERO(&wfds);

	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_SET(i, &wfds);
                    FD_CLR(i, &rfds);

					//reactor
					//send(i, buff, n, 0);
		        } else if (n == 0) { //

					FD_CLR(i, &rfds);
					//printf("disconnect\n");
		            close(i);
					
		        }
				if (--nready == 0) break;
			} else if (FD_ISSET(i, &wset)) {

				send(i, buff, n, 0);
				FD_SET(i, &rfds);
                FD_CLR(i, &wfds);
			
			}

		}
		

	}

#elif 0


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

	int max_fd = listenfd;
	int i = 0;
	for (i = 1;i < POLL_SIZE;i ++) {
		fds[i].fd = -1;
	}

	while (1) {

		int nready = poll(fds, max_fd+1, -1);

	
		if (fds[0].revents & POLLIN) {

			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");
			fds[connfd].fd = connfd;
			fds[connfd].events = POLLIN;

			if (connfd > max_fd) max_fd = connfd;

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

		//int i = 0;
		for (i = listenfd+1;i <= max_fd;i ++)  {

			if (fds[i].revents & POLLIN) {
				
				n = recv(i, buff, MAXLNE, 0);
		        if (n > 0) {
		            buff[n] = '\0';
		            printf("recv msg from client: %s\n", buff);

					send(i, buff, n, 0);
		        } else if (n == 0) { //

					fds[i].fd = -1;

		            close(i);
					
		        }
				if (--nready == 0) break;

			}

		}

	}

#else

	//poll/select --> 
	// epoll_create 
	// epoll_ctl(ADD, DEL, MOD)
	// epoll_wait

	int epfd = epoll_create(1); //int size

	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);

					send(clientfd, buff, n, 0);
		        } else if (n == 0) { //


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

					epoll_ctl(epfd, EPOLL_CTL_DEL, clientfd, &ev);

		            close(clientfd);
					
		        }

			}

		}

	}
	

#endif
 
    close(listenfd);
    return 0;
}

 

NEW
关注
专栏目录
什么是IO多路复用？其原理和用途是什么？
小橙子的笔记屋
08-01 737
IO多路复用
IO多路复用
laugh哥的博客
09-04 1246
（1）同步阻塞IO​ 传统的IO模型。整个IO请求的过程中，用户线程是被阻塞的，这导致用户在发起IO请求时，不能做任何事情，对CPU的资源利用率不够。（2）同步非阻塞IO​ 默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。​ 虽然用户线程每次发起IO请求后可以立即返回，但是为了等到数据，仍需要不断地轮询、重复请求，消耗了大量的CPU的资源。一般很少直接使用这种模型，而是在其他IO模型中使用非阻塞IO这一特性。（3）
IO多路复用详解
氷的博客
05-30 2119
在IO多路复用模型中，引入了一种新的系统调用，查询IO的就绪状态。在Linux系统中，对应的系统调用为select/poll/epoll系统调用。通过该系统调用，一个进程可以监视多个文件描述符，一旦某个描述符就绪（一般是内核缓冲区可读/可写），内核能够将就绪的状态返回给应用程序。随后，应用程序根据就绪的状态，进行相应的IO系统调用。在IO多路复用模型中通过select/poll/epoll系统调用，单个应用程序的线程，可以不断地轮询成百上千的socket连接，当某个或者某些socket网络连接有IO就绪的状
JAVA中的IO多路复用
代码大兵
05-24 1233
在主循环中，通过调用Selector的select()方法来等待Channel的状态发生变化，如果有Channel的状态发生变化，则select()方法会返回可用的Channel数量，并使用selectedKeys()方法获取可用的SelectionKey集合。在Java NIO中，与传统IO模型不同的是，每个通道都有一个关联的Buffer，可以直接将数据读取到或写入到这个Buffer中，而不必像传统IO模型那样先创建一个byte数组，然后将数据读取到byte数组中或从byte数组中写入数据。
IO 多路复用
热门推荐
ChineseSoftware的博客
03-29 3万+
一、简述 IO 多路复用是一种同步 IO 模型，实现一个线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序，交出 cpu。IO 是指网络 IO，多路指多个TCP连接(即 socket 或者 channel)，复用指复用一个或几个线程。意思说一个或一组线程处理多个 TCP 连接。最大优势是减少系统开销小，不必创建过多的进程/线程，也不必维护这些进程/线程。IO 多路复用的三种实现方式：select、poll、epoll。 二、select .
Redis IO多路复用
Yes_water的博客
07-06 1294
本文涉及的主题： 1、BIO、NIO的业务实践和缺陷 2、Redis IO多路复用：redis快的主要原因 3、epoll 架构
IO多路复用之select
qq_55882840的博客
07-09 2175
IO多路复用也称IO多路转接，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。通过这种方式在单线程/进程的场景下也可以在服务器端实现并发。常见的IO多路转接方式有：select、poll、epoll。
操作系统- IO多路复用
an13654067079的博客
01-06 1608
1 背景 1) IO多路复用是操作系统的原理，但是很多中间件的实现都是基于它去做的，IO多复用需要 知道整个链路是样子的，输入是什么，输出是什么 2) 了解IO多路复用作用的位置是哪里 2 数据流 ...
IO多路复用之epoll全面总结(必看篇)
09-15
IO多路复用技术在高并发服务器编程中扮演着至关重要的角色，因为它允许单个线程同时处理多个连接。在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细...
IO多路复用之select全面总结(必看篇)
01-10
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户...
IO多路复用之poll全面总结(必看篇)
09-15
【IO多路复用之poll全面总结】 IO多路复用是一种高效的系统调用，用于在单个线程中管理多个文件描述符的输入/输出事件。在Linux系统中，poll是与select类似的机制，但克服了select在描述符数量上的限制。本文将对...
深入理解Web浏览器与服务器的连接过程
apple_64847327的博客
10-01 949
在互联网的世界里，我们每天都在浏览网页，但你是否想过，当你在浏览器中输入一个网址时，背后发生了什么？
scp 通过中间机器进行远程拷贝
choumin的专栏
10-08 285
scp 通过中间机器进行远程拷贝的方法
10.10 QT服务器与客户端
qq_73941453的博客
10-10 155
【代码】10.10 QT服务器与客户端。
运用MinIO技术服务器实现文件上传——在Linux系统上安装和启动（一）
h123372868的博客
10-07 850
随着大数据时代的到来，数据存储的需求日益增大，如何有效地存储和管理大规模的非结构化数据成为许多企业和开发者面临的挑战。MinIO 作为一个高性能、分布式对象存储系统，致力于为用户提供简单、快速、可扩展的存储解决方案。它的设计与 Amazon S3 兼容，用户可以无缝切换到 AWS 生态系统，并充分利用 S3 提供的丰富功能。MinIO 是基于 Go 语言开发的，因而其执行效率极高，并且可以灵活地支持各种非结构化数据的存储，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。
Netty写的Echo 服务器的例子
莫凡的博客
10-10 458
通过以上步骤，就可以使用Netty实现一个简单的Echo服务器，并进行测试。这个例子展示了Netty的基本使用方法，包括如何创建服务器、处理客户端连接和消息、以及如何关闭服务器。
裸金属服务器与虚拟机、物理机区别
09-30 613
裸金属服务器：作为一种物理服务器架构，其显著特征在于其直接运行于物理硬件之上，摒弃了虚拟化层的介入。此设计旨在提供纯粹的计算能力，确保所有计算资源均直接服务于用户的应用，从而实现了计算效率与性能的显著提升。从管理视角审视，裸金属服务器赋予了用户前所未有的硬件资源直接访问权限，包括CPU、内存及存储等核心组件，实现了对硬件资源的深度掌控与优化。此外，在公有云服务的语境下，裸金属服务器作为云服务器（云虚拟主机）的补充，以其独特的“裸露”金属般的纯粹性，清晰地区分了两者之间的界限。
服务器与内存市场｜2025预测动态早知道
最新发布
存储随笔
10-10 777
到2024年第二季度，AWS、Meta、Azure和Google等主要云服务提供商中，DDR5的使用比例分别达到了38%、33%、17%和约45%，其中AWS主要采用的是Graviton处理器，而Meta和Azure则更偏向于AI应用，Google则以Sapphire Rapids为主。根据TrendForce的研究数据，2020年至2024年期间，服务器出货量呈现持续增长趋势，尤其值得注意的是，ODM Direct模式的增长速度超过了整体市场，这主要得益于数据中心和云计算强劲的需求。
Linux中的查找操作-ubuntu系统
qq_45993770的博客
10-07 1225
Linux 提供了多种强大的查找工具和方法，适用于不同的查找需求。掌握这些工具的使用，不仅可以提高工作效率，还能帮助你更好地管理和维护系统。查找文件和目录：使用findlocatefd等命令。在文件内容中查找：使用grepripgreprg）、ag等工具。查找进程和打开的文件：使用lsofpspgrep等命令。系统信息查找：使用dfdulsblkblkid等工具。用户和权限信息：使用idwhow等命令。图形化查找工具：如Catfish等。高级查找技巧：结合正则表达式、管道、-exec和。
Python IO多路复用详解：并发连接操作指南
本文将深入解析Python中的IO多路复用技术，特别是在处理大量并发连接场景下的应用。首先，让我们明确何为IO多路复用。在计算机网络编程中，当服务器需要同时处理多个客户端连接，每个连接都需要读写操作（如Socket...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值