C++网络编程进阶篇_IO多路复用

最新推荐文章于 2023-04-03 17:46:00 发布
最新推荐文章于 2023-04-03 17:46:00 发布
阅读量574 收藏 5
点赞数 1
分类专栏： 网络编程 文章标签： 网络 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stephen8848/article/details/128508620
版权

文章目录

之前写过一篇C++关于网络编程入门的博文：
socket网络编程入门

主要是介绍C++网络编程的API接口的使用，该博文中的例子对socket的
调用流程是最简单且最基本的，它只能实现一对一通信，因为它使用的是同步阻塞的方式。

现代网络编程都需要考虑到并发，也就是一对多的通信状态，
继续使用之前一对一的通信模型是行不通的，只有通过改进网络I/O模型来实现。

网络编程绕不开的C10k问题

请添加图片描述

提出该问题的作者是Dan Kegel是Winetricks的作者，博客原文
《The C10K problem》。
相关的资源拓展：
高性能网络编程经典：《The C10K problem(英文)》[附件下载]

原文介绍了一些I/O框架，其中libevent是目前后端开发较常用的网络库，
本人曾经也在项目中使用过该库，是实现多并发较理想的解决方案之一。

C10k问题的本质是尽可能的减少网络程序并发状态下的服务器资源消耗，
比如避免或减少频繁的创建和销毁进程和线程，针对此问题的解决方案有使用线程池来管理线程资源；
避免或减少频繁的数据拷贝，引申出了零拷贝的解决方案。
总的来说解决C10k问题的关键就是尽可能减少这些CPU资源消耗！

解决方案

这里我想通过逐一介绍不同的网络I/O模型来引出现阶段网络编程处理多并发场景较理想的解决方案。
以最基本的实现一对一通信模型的socket代码为例展开修改，
这里仅以tcp服务端代码举例，客户端使用其它软件连接：

/* 同步阻塞基本socket服务端模型 */
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>

#define BUFFER_LENGTH   128

int main() {    
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);  //
	if (listenfd == -1) {
		return -1;
	}
			
	struct sockaddr_in servaddr;
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(9999);
	
	if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
			return -2;
	}
	listen(listenfd, 10);
	
	struct sockaddr_in client;
	socklen_t len = sizeof(client);
	int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);
	
	unsigned char buffer[BUFFER_LENGTH] = {0};
	int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
	printf("buffer : %s, ret: %d\n", buffer, ret);
	
	ret = send(clientfd, buffer, ret, 0);
	
	close(clientfd);
	return 0;
}
  1. 使用循环的方式处理多个socket连接

传统的I/O网络模型就是阻塞式I/O模型，在 socket网络编程入门
这篇文章中的例子就是该模型。刚才已经在上文说过这类模型不适合直接应用于多并发场景下的网络编程。
上述的代码很简单，问题也很明显：

  • 可以连接多个客户端，但是第二个客户端不能正常处理发送和接受数据；
  • 第一个客户端断开之后，服务端程序也直接退出。

接下来我们使用循环来处理上面的问题，
当然像下面这样直接将接受和发送的代码放入循环是不能解决根本问题的：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>

#define BUFFER_LENGTH   128

int main() {

// block
        int listenfd = socket(AF_INET, SOCK_STREAM, 0);  //
        if (listenfd == -1) return -1;
// listenfd
        struct sockaddr_in servaddr;
        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port = htons(9999);

        if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
				return -2;
        }
        listen(listenfd, 10);

        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);

        while (1) {
                unsigned char buffer[BUFFER_LENGTH] = {0};
                int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
                if (ret == 0) {
                        close(clientfd);
                        break;
                }
                printf("buffer : %s, ret: %d\n", buffer, ret);

                ret = send(clientfd, buffer, ret, 0);
        }

        return 0;
}

这里推荐阅读多线程模型
结合下面的代码一起理解。这里直接跳过了多进程模型是因为进程占用的资源较大，
而且进程的善后工作没做好会产生僵尸进程，这类进程越多就会逐渐耗尽我们的系统资源。
所以采用轻量级的多线程模型，是现阶段较好的解决方案。
首先将处理接受和发送数据的代码放入到线程中，用多线程模型来处理socket连接的并发场景：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>

#define BUFFER_LENGTH   128
void *routine(void *arg) {
        int clientfd = *(int *)arg;
        printf("listen --> clientfd: %d\r\n",clientfd);
        while (1) {
                unsigned char buffer[BUFFER_LENGTH] = {0};
                int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
                if (ret == 0) {
                        printf("close clientfd: %d\r\n",clientfd);
                        close(clientfd);
                        break;
                }

                printf("buffer : %s, ret: %d clientfd: %d\r\n", buffer, ret,clientfd);

                ret = send(clientfd, buffer, ret, 0); //
        }
}

int main(){
        int listenfd = socket(AF_INET, SOCK_STREAM, 0);  //
        if (listenfd == -1) return -1;

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

        if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
                return -2;
        }

        listen(listenfd, 10);
        while (1) {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);

                pthread_t threadid;
                pthread_create(&threadid, NULL, routine, &clientfd);

        }
        return 0;
}

程序运行图示：
请添加图片描述

  1. 运用到select模型来处理多个socket连接

使用多线程循环处理socket的结果似乎已经能满足一对多的想法了，但它仍然存在一些问题。
比如一个线程对应一个socket请求，造成服务器资源的消耗较大，
频繁的创建和销毁线程对系统也是一个不小的开销,当然我们可以使用线程池的方式来避免线程的频繁创建和销毁，
但最关键的一点是，多线程模型还不能解决C10k问题。

多线程循环处理socket和select的区别是，selcet对线程进行了复用，也是I/O多路复用模型的优势，
系统不需要频繁的创建和销毁线程，一个线程管理所有socket，
它相对于多线程模型的优势是同时能处理更多的socket连接：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>

#define BUFFER_LENGTH 128

int main() {

	int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
	if (listenfd == -1) return -1;

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

	if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
		return -2;
	}

	listen(listenfd, 10);

	fd_set rfds, wfds, rset, wset;

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

	int maxfd = listenfd;

	unsigned char buffer[BUFFER_LENGTH] = {0}; // 0 
	int ret = 0;

	while (1) {
		/* 每次调用之前都要初始化fd_set结构体 */
		rset = rfds;
		wset = wfds;

		int nready = select(maxfd+1, &rset, &wset, NULL, NULL);
		if (FD_ISSET(listenfd, &rset)) {
			printf("listenfd --> %d\r\n"，listenfd);

			struct sockaddr_in client;
			socklen_t len = sizeof(client);
			int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);
			
			FD_SET(clientfd, &rfds);

			if (clientfd > maxfd) maxfd = clientfd;
		} 
		
		int i = 0;
		for (i = listenfd+1; i <= maxfd;i ++) {
			if (FD_ISSET(i, &rset)) { //
				memset(buffer, 0, sizeof(buffer));	
				ret = recv(i, buffer, BUFFER_LENGTH, 0);
				if (ret == 0) {
                    printf("close clientfd: %d\r\n",i);
					close(i);
					FD_CLR(i, &rfds);
				} else if (ret > 0) {
					printf("buffer : %s, ret: %d, clientfd: %d\r\n", buffer, ret,i);
					FD_SET(i, &wfds);
				}

				
			} else if (FD_ISSET(i, &wset)) {
				ret = send(i, buffer, ret, 0); // 
				FD_CLR(i, &wfds); //
				FD_SET(i, &rfds);
			}
		}
	}
	return 0;
}

程序运行图示：
请添加图片描述

  1. 使用poll模型来处理多个socket连接

上面的select模型的优势很明显，实现了I/O多路复用，但问题也不少，
比如监视文件句柄的数量上存在上限；每次调用之前都要重新初始化fd_set结构体；需要通过遍历数组的方式来监视fd的状态，存在不必要的消耗。

poll模型主要解决了前面两个问题，它将select使用的三个fd_set结构体参数修改成了struct pollfd *类型的数组的形式，原理还是和select模型一样的，只是理论上解决了文件句柄数量的上限和避免了避免重复初始化的问题，遍历数组监视fd状态的效率依旧存在。

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#include <string.h>

#define MAX_FD  1024
#define BUFFER_LENGTH 128

int main(){
    //创建一个侦听socket
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);  
	if (listenfd == -1) return -1;
	
	//默认使用阻塞模式
	struct sockaddr_in servaddr;
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(9999);

	if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
        printf("bind error.");
		return -2;
	}
    //启动侦听
    if (-1 == listen(listenfd, SOMAXCONN)){
        printf("listen error.");
        close(listenfd);
        return -3;
    }
	
	struct pollfd  fds[MAX_FD] = {0};
    fds[0].fd = listenfd;
    fds[0].events = POLLIN;	
	
	int cur_max_fd = listenfd;
	/* 初始化poll数组 */
	int i = 0;
	for(i=1; i < MAX_FD; i++){
		fds[i].fd = -1;
	}

	unsigned char buffer[BUFFER_LENGTH] = {0}; // 0 
	int ret = 0;
	
	while(1){
		int nready = poll(fds, cur_max_fd+1, -1);
		if (nready < 0){
            perror("poll error\r\n");
            return -4;
        }
		
		if(fds[0].revents & POLLIN){
			struct sockaddr_in client;
			socklen_t len = sizeof(client);
			int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);
			fds[clientfd].fd = clientfd;//将客户端socket加入到集合中
            fds[clientfd].events = POLLIN;
			
			printf("listen --> \r\n");
			if (clientfd > cur_max_fd) {
				cur_max_fd = clientfd;
			}
			if (--nready == 0) continue;
		}
		
		for(i=listenfd+1; i<= cur_max_fd; i++){
			if(fds[i].revents & POLLIN){
				ret = recv(i, buffer, BUFFER_LENGTH, 0);
				if(ret > 0){
					buffer[ret] = '\0';
					printf("buffer : %s, ret: %d, clientfd: %d\r\n", buffer, ret,i);

					send(i, buffer, ret, 0);
				}else if(ret == 0){
					fds[i].fd = -1;
                    printf("close clientfd: %d\r\n",i);
		            close(i);
				}
				if (--nready == 0) break;
			}
		}
	}
	close(listenfd);
	return 0;
}
  1. epoll

epoll使用了红黑树的数据结构来监视所有fd的状态变化，它只返回状态有变化的fd，
而不像select/poll那样通过轮询扫描的方式去遍历整个fd数组。
它利用三个关键的api对fd进行管理，先用epoll_create创建一个 epoll 对象 epfd，
再通过 epoll_ctl 将需要监视的 socket 添加到 epfd 中，最后调用 epoll_wait 等待数据。
在客户端请求的fd数量达到10k时，epoll的性能优于select/poll，这样的设计解决了C10k问题：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <string.h>

#define MAX_FD  1024
#define BUFFER_LENGTH 128

int main(){
    //创建一个侦听socket
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);
	if(-1 == listenfd) return -1;
	
	//默认使用阻塞模式
	struct sockaddr_in servaddr;
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(9999);

	if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
        printf("bind error.");
		return -2;
	}
    //启动侦听
    if (-1 == listen(listenfd, SOMAXCONN)){
        printf("listen error.");
        close(listenfd);
        return -3;
    }
	
	int epfd = epoll_create(1); //int size

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

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

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

	unsigned char buffer[BUFFER_LENGTH] = {0}; // 0 
	int ret = 0;
	while (1) {
		int nready = epoll_wait(epfd, events, MAX_FD, 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);
				int connfd = accept(listenfd, (struct sockaddr *)&client, &len);

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

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

				ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
		        if (ret > 0) {
		            buffer[ret] = '\0';
		            //printf("recv msg from client: %s\n", buffer);
					printf("buffer : %s, ret: %d, clientfd: %d\r\n", buffer, ret,clientfd);

					send(clientfd, buffer, ret, 0);
		        } else if (ret == 0) { //
					ev.events = EPOLLIN;
					ev.data.fd = clientfd;

					epoll_ctl(epfd, EPOLL_CTL_DEL, clientfd, &ev);
                    printf("close clientfd: %d\r\n",clientfd);

		            close(clientfd);
		        }
			}
		}
	}
    close(listenfd);
	return 0;
}

引用列表

《深入理解计算机系统》- 第三部分 程序间的交流和通信
深入理解LinuxIO复用之epoll
深入了解epoll模型（特别详细）
《图解系统》- 九、网络系统 -小林coding
《高性能网络编程》- 即时通讯网博客

CallMea阿堃
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++网络编程之I/O多路复用、IO模型
有梦想的小新人的博客
04-02 979
文章目录1.select模型1.1 select模型服务程序的流程10.相关面试题1.网络编程select、poll和epoll1.epoll的边缘触发和水平触发了解吗？分别说一下特点和区别。3.epoll两种触发方式 适用场景 1.select模型 1.1 select模型服务程序的流程 10.相关面试题 1.网络编程select、poll和epoll 1.epoll的边缘触发和水平触发了解吗？分别说一下特点和区别。 3.epoll两种触发方式 适用场景 ...
c++ IO多路复用
mary0712的博客
08-24 2169
1. 什么是IO多路复用 一句话解释：单线程或单进程同时监测若干个文件描述符是否可以执行IO操作的能力。 2. 解决什么问题 说在前头 应用程序通常需要处理来自多条事件流中的事件，比如我现在用的电脑，需要同时处理键盘鼠标的输入、中断信号等等事件，再比如web服务器如nginx，需要同时处理来来自N个客户端的事件。 逻辑控制流在时间上的重叠叫做并发 而CPU单核在同一时刻只能做一件事情，一种解决办法是对CPU进行时分复用(多个事件流将CPU切割成多个时间片，不同事件流的时间片交替进行)。在计算机.
SOCKET【2】-IO多路复用select
m0_46535940的博客
05-28 584
文章目录前言一、socket阻塞模式二、socket非阻塞模式三、select 相关API介绍与使用3.1 seletct API3.2 seletct 使用范例四、深入理解select 模型五、用select处理外带数据六、用select来解决socket中的多客户端问题总结 前言 提示：展示select如何使用 一、socket阻塞模式 所谓阻塞模式block是指线程或者进程执行这些函数时必须等待直到某一事件的发生才能返回，如果事件不发生，进程或者线程被阻塞，函数不能立即返回。 二、socket非阻
SOCKET【1】-对IO多路复用的理解
m0_46535940的博客
05-07 1506
文章目录前言一、什么是socket？二、阻塞三、什么是IO多路复用技术四、为什么使用多路复用三、selet 与epoll的区别3.1 时间复杂度3.2 select缺点3.3 poll的理解3.3 epoll的理解3.4 select .poll.epoll的使用选择五 、其他常用IO模型5.1 堵塞I/O5.2 非阻塞I/O5.2 I/O复用模型5.3 信号驱动I/O模型（signal driven I/O， SIGIO）5.4 5、异步I/O模型(AIO, asynchronous I/O)总结 前言
Socket网络编程之IO多路复用——select、poll、epoll详谈
weixin_42690036的博客
03-21 1400
select、poll、epoll详谈
C++网络编程进阶
06-09
高并发网络通讯更是很多项目的核心模块，学好socket 网络编程显得尤为重要，本课程分为TCP/IP 协议、socket基础与进阶的异步通讯模型三个部分，通过浅显易懂的代码与讲解，让你的C++网络编程能力得到质的飞跃，...
C++_C++INT函数进阶用法_
10-01
用于调换一个三位数的各位与百位，适合初学者研究代码，用到了”%“的应用。
C++ 网络编程_c++网络编程_C++网络编程_
10-02
C++程序设计语言　C++ 网络编程 规范
vanetrbc.rar_网络编程_C++__网络编程_C++_
08-09
vanetRBC----------- vanet in ns2.35
Visual C++网络高级编程_编程_C++_basketek4_网络_vc++_
10-02
关于VC++网络编程的高级教程
IO多路复用之select全面总结(必看篇)
01-10
1、基本概念 IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 （3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。 （4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。 （5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。 与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创
select之多路IO复用
m0_60529319的博客
04-03 157
举一个简单地网络服务器的例子，如果你的服务器需要和多个客户端保持连接，处理客户端的请求，属于多进程的并发问题，如果创建很多个进程来处理这些IO流，会导致CPU占有率很高。所以人们提出了I/O多路复用模型：一个线程，通过记录I/O流的状态来同时管理多个I/O，需要的线程数大大减少，减少了内存开销和上下文切换的CPU开销。
基于Linux的socket网络编程（select IO多路复用）
Solahalo的博客
10-15 543
基于Linux的socket网络编程（select IO多路复用）
C++网络编程（五）：IO多路复用实现并发服务器
weixin_44164489的博客
10-05 1623
目录前置知识五种IO模型阻塞i/o非阻塞I/O模型I/O复用模型信号驱动I/O模型异步I/O模型五种I/O模型比较selectselect引入seclect应用实例POLLepoll总结select poll epoll区别参考资料 前置知识 1.Unix五种IO模型 [1] blocking IO - 阻塞IO [2] nonblocking IO - 非阻塞IO [3] IO multiplexing - IO多路复用 [4] signal driven IO - 信号驱动IO [5] asynchro
多路复用IO——学习笔记
Love丶伊卡洛斯
09-21 455
一、IO模型介绍 1、阻塞IO，常用的scanf、printf、read、write、cout、cin 2、非阻塞IO，recv、send和Qt中read、write 3、多路复用IO 4、信号驱动IO 5、异步IO 二、多路复用IO 在不创建新的进程和线程的情况下监控多个文件描述符，多应用于网络编程时一个服务端程序为多个客户端程序提供服务， 多用...
redis IO多路复用原理：高性能IO之Reactor模式
Turn X7
06-23 6541
首先你得了解redis是单线程的，然后你接着会有个疑问，单线程怎么会有高性能呢（据悉，在普通的笔记本上redis吞吐量亦能达到每秒几十W次），带着疑问看看下面转载的帖子吧。 先个人总结： 所谓的redis的多路复用原理 他是把IO操作再细分成多个事件去处理 比如IO涉及连接 读取 输入 把这三种当成三种事件分别起三个线程处理 如果一个连接来了显示被读取线程处理了，然后再执行写入，那么之前的读取......
IO多路复用机制详解
寒山空明月
04-02 6490
0. IO多路复用机制详解 参考 ： https://blog.csdn.net/baixiaoshi/article/details/48708347        1. IO多路复用        参考： https://www.zhihu.com/question/32163005要弄清问题先要知道问题的出现原因原因: 由于进程的执行过程是线性的(也就是顺序执行),当我们调用低速系统I/O(...
IO多路复用select poll epoll的底层原理和C++使用例子
weixin_44660094的博客
03-22 628
综述 首先要搞明白两个基本概念：I/O复用和(非)阻塞机制。 I/O复用指的是允许计算机执行或者阻塞在一组数据流上，直到某个到达唤醒阻塞的进程，此时的I/O信道不仅仅是通过一个数据流，而是一组，所以是复用。 阻塞和非阻塞：拿I/O为例子，如果是阻塞模型，那么程序一直会等到有数据来的时候才会继续向下执行，否则会一直等待数据的到来；如果是非阻塞模型，如果有数据，那么直接读取数据向下执行，没有数据也会继...
socket通信之最简单的I/O 多路复用
写代码的小孩
10-07 4009
在Linux/UNIX 下，有下面这五种I/O 操作方式： 1.阻塞 I/O 2. 非阻塞 I/O 3.I/O 多路复用 4.信号驱动 I/O（SIGIO） 5.异步 I/O 至于每种模式的含义自己去查吧，百度百科、wiki百科介绍的都很详细，要是介绍的话，我也就是抄袭过来，要学会使用搜索引擎~~ 还记得上一篇文章的例子吧，那就是基于阻塞I/O模式的，简单的不能再简单的socket通
c++ io多路复用
最新发布
09-13
IO多路复用是一种通过一个线程同时监听多个IO事件的机制。它能够提高系统的性能和资源利用率，减少系统开销。在C语言中，可以使用以下方式实现IO多路复用： 1. select函数：select函数是最常用的实现IO多路复用的方法之一。它可以同时监听多个文件描述符的可读、可写和异常事件，并在有事件发生时返回。通过使用fd_set结构体来管理要监听的文件描述符集合。 2. poll函数：poll函数与select函数类似，也是用来实现IO多路复用的方法之一。它可以监听多个文件描述符的可读、可写和异常事件，并在有事件发生时返回。与select相比，poll函数没有文件描述符数量的限制，并且通过一个pollfd数组来管理要监听的文件描述符。 3. epoll函数：epoll是Linux下高性能的IO多路复用机制。它可以监听大量文件描述符并返回就绪的事件，相比select和poll具有更高的性能。通过使用epoll_create创建一个epoll实例，并通过epoll_ctl来添加、修改和删除要监听的文件描述符。 这些方法都有各自的优缺点，根据具体的需求和平台选择合适的方法来实现IO多路复用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值