Linux学习_多路I/O复用

最新推荐文章于 2024-08-14 15:41:15 发布
最新推荐文章于 2024-08-14 15:41:15 发布
阅读量129 收藏
点赞数
分类专栏： Linux学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44342705/article/details/117094932
版权

网络高级编程 多路I/O复用

概念

  • 如recv,send,read和write等函数都是阻塞性函数，若资源没有准备好则调用该函数的进程将进入阻塞状态。
  • 我们可以使用I/O多路复用解决，有两种方式：
    • fcntl函数实现(非阻塞方式)
    • select函数实现
  • 守护进程

fcntl非阻塞实现

在这里插入图片描述

动态数组函数：

/*
 * vector_fd.c
 * 
 */

#include "vector_fd.h"
#include <malloc.h>
#include <assert.h>
#include <stdlib.h>
#include <memory.h>


static void encapacity(VectorFD* vfd)
{
	if(vfd->counter >= vfd->max_counter){
		int *fds = (int*)calloc(vfd->counter+5,sizeof(int));
		assert(fds != NULL);
		memcpy(fds, vfd->fd, sizeof(int)*vfd->counter);
		free(vfd->fd);
		vfd->fd = fds;
		vfd->max_counter += 5;
	}
}

static int indexof(VectorFD *vfd, int fd)
{
	int i=0;
	for(;i < vfd->counter; i++){
		if(vfd->fd[i]==fd) return i;
	}
	return -1;
}

/*创建动态数组*/
VectorFD* create_vector_fd(void)
{
	VectorFD *vfd = (VectorFD*)calloc(1,sizeof(VectorFD));
	assert(vfd != NULL);
	vfd->fd = (int*)calloc(5,sizeof(int));
	assert(vfd->fd != NULL);
	vfd->counter = 0;
	vfd->max_counter = 0;
	return vfd;
}

/*销毁动态数组*/
void destroy_vector_fd(VectorFD *vfd)
{
	assert(vfd != NULL);
	free(vfd->fd);
	free(vfd);
	
}

/*从动态数组中根据下标得到套接字描述符*/
int get_fd(VectorFD* vfd, int index)
{
	assert(vfd != NULL);
	if(index<0 || index > vfd->counter-1)return 0;
	return vfd->fd[index];
}
	
/*删除某一个套接字描述符*/
void remove_fd(VectorFD* vfd, int fd)
{
	assert(vfd != NULL);
	int index = indexof(vfd, fd);
	if(index == -1) return;
	int i = index;
	for(;i < vfd->counter-1; i++){
		vfd->fd[i] = vfd->fd[i+1];
	}
	vfd->counter--;
}

/*增加一个套接字描述符*/
void add_fd(VectorFD* vfd, int fd)
{
	assert(vfd != NULL);
	encapacity(vfd);
	vfd->fd[vfd->counter++] = fd;
	
}

程序实现：

/*
 * TCP服务器.c
 * 
 * 
 */


#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <signal.h>
#include <time.h>
#include <arpa/inet.h>
#include "vector_fd.h"
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>

VectorFD* vfd;
int sockfd;

//登记信号处理函数，使程序接收ctrl+C信号时关闭服务器
void sig_handler(int signo)
{
	if(signo==SIGINT)
	{
		printf("server close\n");
		/*步骤6：关闭客户端的socket*/
		close(sockfd);
		//销毁动态数组
		destroy_vector_fd(vfd);
		exit(1);
	}

}

/*输出连接上来的客户端相关信息*/
void out_addr(struct sockaddr_in *clientaddr)
{
	//将端口号从网络字节序转换成主机字节序
	int port = ntohs(clientaddr->sin_port);
	char ip[16];
	memset(ip,0,sizeof(ip));
	//将ip地址从网络字节序转换成点分十进制放到ip字符数组中
	inet_ntop(AF_INET,
					&clientaddr->sin_addr.s_addr,
					ip, sizeof(ip));
	printf("client: %s(%d) connected\n",ip,port);
}

/* fd对应于某个连接的客户端
 * 功能：和某一个连接的客户端进行双向通信
 * (非阻塞方式)
 */
void do_service(int fd)
{
	/*和客户端进行读写操作(双向通信)*/
	char buff[512];
	memset(buff,0,sizeof(buff));
	/*因为采用非阻塞方式，若读不到数据直接返回
	 * 直接服务于下一个客户端
	 * 因此不需要判断size小于0的情况。
	 */
	size_t size = read(fd,buff,sizeof(buff));
	if(size == 0){//客户端已关闭连接
		char info[]="client closed";
		write(STDOUT_FILENO, info, sizeof(info));//使用不带缓存的内核函数
		//从动态数组中删除对应的fd
		remove_fd(vfd, fd);
		//关闭对应客户端的socket
		close(fd);
	}else if(size>0){
		write(STDOUT_FILENO, buff, sizeof(buff));
		if(write(fd, buff, size) < 0){ //客户端关闭，读取出错，返回值为-1
			if(errno==EPIPE){//客户端关闭连接
				perror("write error");
				remove_fd(vfd, fd);
				close(fd);
			} 
		}
	}
}

//线程遍历动态数组中的socket描述符
void* th_fn(void* arg)
{
	int i = 0;
	while(1){
		i=0;
		//遍历动态数组中的socket描述符
		for(; i < vfd->counter; i++){
			do_service(get_fd(vfd, i));
		}
	}
	return NULL;
}

/*主函数*/
int main(int argc, char **argv)
{
	
	if(argc<2)
	{
		printf("usage:%s #port\n",argv[0]); //传递端口参数
		exit(1);
	}
	/*处理ctl+c信号，关闭服务器*/
	if(signal(SIGINT, sig_handler)==SIG_ERR) 
	{
		perror("signal sigint error");
		exit(1);
	}
	
	/*步骤1：创建socket
	 * 注：socket创建在内核中，是一个结构体。
	 * AF_INET：IPv4
	 * SOCK_STREAM:tcp协议
	 * */
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	
	/*步骤2：将socket和地址(包括ip、port)进行绑定*/
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof(serveraddr));
	//往地址中填入ip、port、internet地址族类型
	serveraddr.sin_family = AF_INET; //IPv4
	serveraddr.sin_port = htons(atoi(argv[1])); //port
	serveraddr.sin_addr.s_addr = INADDR_ANY; //INADDR_ANY响应所有客户端请求
	if(bind(sockfd, (struct sockaddr*)&serveraddr,
				sizeof(serveraddr))<0)
		{perror("bind error");exit(1);}
		
	/*步骤3：调用listen启动监听(指定端口监听)
	 * 通知系统去接受来自客户端的连接请求
	 * (将接收到的客户端连接请求放置到对应的队列中)
	 * 第二个参数：指定队列长度为10
	 * */
	if(listen(sockfd, 10)<0)
	{perror("listen error");exit(1);}
	
	/*步骤4：调用accept函数，
	 * 从队列中获得一个客户端的请求连接,
	 * 并返回新的socket描述符。
	 * 若没有客户端连接，调用此函数会阻塞，直到获得一个客户端连接。
	 * */
	
	//创建放置套接字描述符fd的动态数组
	vfd = create_vector_fd();
	
	pthread_t th;
	int err;
	err = pthread_create(&th,0,th_fn,(void*)0);
	if(err){perror("create error");exit(1);}
	//以分离状态启动子线程
	pthread_detach(th);
	
	
	/* 1)主控线程获得客户端的连接，将新的socket描述符
	 *    放置到动态数组中
	 * 2)启动的子线程负责遍历动态数组中的socket描述符
	 *    并和对应的客户端进行双向通信
	 *    (采用非阻塞方式读写)
	 */
	 struct sockaddr_in clientaddr;
	socklen_t len = sizeof(clientaddr);
	
	while(1){
		int fd = accept(sockfd,
								(struct sockaddr*)&clientaddr,
								&len);
		if(fd<0){
			perror("accept error");
			continue;
		}
		out_addr(&clientaddr);
		
		//将读写修改为非阻塞方式
		int val;
		fcntl(fd, F_GETFL, &val);
		val |= O_NONBLOCK;
		fcntl(fd, F_SETFL, val);
		
		//将返回的新的socket描述符fd加入到动态数组中
		add_fd(vfd, fd);
	}
	
	return 0;
}

select函数实现

select函数定义：

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

int select(int maxfdp1, fd_set* readfds, fd_set* writefds,
				fd_set* exceptfds, struct timeval *timeout);
返回：准备就绪的描述符的数量，若超时则为0,若出错则为-1
功能：委托内核查看这些描述符集里的描述符是否已经准备好可以使用。用户程序调用时会阻塞。

struct timeval{
	long tv_sec;
	long tv_usec;
};

参数：

  • maxfdp1: 最大fd加1值(max fd plus 1)。在三个描述符集中找出最大的描述符编号值，然后加1。表示描述符的数量范围。
  • readfds, writefds和exceptfds：是指向描述符集的指针。这三个描述符集说明了我们关心的可读，可写或处于异常条件的各个描述符。每个描述符集存放在一个fd_set数据类型中。
  • timeout：指定愿意等待的时间
    • timeout的三种值
      • NULL：永远等待，直到捕捉到信号 或 文件描述符准备好为止。
      • 具体值：struct timeval类型的指针，若等待为timeout时间，还没有文件描述符准备好，就立即返回。
      • 0：从不等待，测试所有的描述符并立即返回。

传向select的参数告诉内核
- 我们所关心的描述符
- 对于每个描述符我们所关心的条件(是否可读一个给定的描述符，是否可写一个给定的描述符，是否关心一个描述符的异常条件)
- 希望等待多长时间(可以永远等待，等待一个固定的时间，或者完全不等待)
从select返回时内核告诉我们
- 已准备好的描述符数量
- 哪一个描述符已准备好读、写或异常条件
- 使用这种返回值，就可调用相应的I/O函数(一般是read或write)，并且确认该函数不会阻塞。
select函数根据希望进行的文件操作对文件描述符进行分类处理，这里对文件描述符的处理主要涉及4个宏函数
- FD_ZERO(fd_set* set)——清除一个文件描述符集
- FD_SET(int fd, fd_set* set)——将一个文件描述符加入文件描述符集中
- FD_CLR(int fd, fd_set* set)——将一个文件描述符从文件描述符集中清除
- FD_ISSET(int fd, fd_set* set)——测试该集中的一个给定位是否有变化
在使用select函数之前，首先使用FD_ZERO和FD_SET来初始化文件描述符集，在使用select函数时，可循环使用FD_ISSET测试描述符集，在执行完成对相关文件描述符后，使用FD_CLR来清除描述符集。

实现：
在这里插入图片描述

服务器端：

/*
 * IO_tcp_server.c
 * 
 */

/*系统相关头文件*/
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <time.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
/*网络相关头文件*/
#include <sys/socket.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <memory.h>

/*宏定义*/
#define BUFFLEN 24
#define SERVER_PORT 8888
#define LISTEN_QUE 5
#define CLIENT_NUM 1024

/*函数声明*/
void handle_sig(int signum);
void* handle_request(void *arg);
void* handle_connect(void *arg);

/*全局变量*/
int connect_host[CLIENT_NUM];
int connect_num = 0;
pthread_t th[2];
int serverfd;


/*主函数*/
int main(int argc, char *argv[])
{
	signal(SIGINT,handle_sig);
	signal(SIGPIPE,handle_sig);
	
	struct sockaddr_in local_addr; //本地地址
	memset(connect_host,-1,sizeof(connect_host));
	
	/*建立套接字*/
	serverfd = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址*/
	memset(&local_addr, 0, sizeof(local_addr));
	local_addr.sin_family = AF_INET;
	local_addr.sin_port = htons(SERVER_PORT);
	local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	
	/*将socket描述符绑定本地地址和端口*/
	bind(serverfd, (struct sockaddr*)&local_addr, sizeof(local_addr));
	
	/*侦听socket*/
	listen(serverfd, LISTEN_QUE);
	
	/*创建线程处理客户端连接*/
	pthread_create(&th[0], 0, handle_connect,0);
	pthread_detach(th[0]);
	/*创建线程处理客户端请求*/
	pthread_create(&th[1], 0, handle_request,0);
	pthread_detach(th[1]);
	
	while(1);
	
	return 0;
}

/*函数：信号处理*/
void handle_sig(int signum)
{
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,0);
	switch(signum){
		case SIGINT:
			pthread_cancel(th[0]);
			pthread_cancel(th[1]);
			close(serverfd);
			printf("server closed\n");
			exit(0);
			break;
		case SIGPIPE: 
			printf("client close\n");
			break;
		default:
		break;
	}
}

/*函数：客户端连接*/
void* handle_connect(void *arg)
{
	struct sockaddr_in client_addr;
	socklen_t len = sizeof(client_addr);
	
	/*接收客户端连接*/
	while(1){
		int i = 1;
		int client_fd = accept(serverfd, (struct sockaddr*)&client_addr, &len);
		/*接收客户端请求*/
		printf("A client connect, from: %s\n",inet_ntoa(client_addr.sin_addr));
		/*查找在线文件描述符数组合适的位置，放入客户端的文件描述符*/
		for(i=0; i<CLIENT_NUM; ++i){
			if(connect_host[i] == -1){
				connect_host[i] = client_fd;
				connect_num ++;
				/*继续轮询等待客户连接*/
				break;
			}
		}
	}
	return NULL;
}

/*函数：客户端请求*/
void* handle_request(void *arg)
{
	time_t now;
	char buff[BUFFLEN]; //收发数据缓冲区
	int size=0;
	int maxfd = -1; //最大侦听文件描述符
	fd_set scanfd; //侦听描述符集合
	struct timeval timeout; //超时
	timeout.tv_sec = 1;
	timeout.tv_usec = 0;
	
	int i;
	int err = -1;
	while(1){
		maxfd = -1; //最大侦听文件描述符值初始化为-1
		FD_ZERO(&scanfd); //将文件描述符集合清零
		for(i=0;i<CLIENT_NUM;++i){ //将文件描述符放入集合
			if(connect_host[i] != -1){ //合法的文件描述符
				FD_SET(connect_host[i], &scanfd); //放入集合
				if(maxfd < connect_host[i]) maxfd = connect_host[i]; //更新最大描述符
			}
		}
		/*select等待*/
		err = select(maxfd+1, &scanfd, NULL, NULL, &timeout);
		switch(err){
			case 0: //超时
				break;
			case -1: //有错误发生
				break;
			default:
			if(connect_num<=0)break;
			for(i=0;i<CLIENT_NUM;++i){
				/*查找激活的文件描述符*/
				if(connect_host[i] != -1){
					//printf("client_fd id: %d\n",connect_host[i]);
					if(FD_ISSET(connect_host[i], &scanfd)){
						/*操作请求*/
						bzero(buff, BUFFLEN);
						size = recv(connect_host[i], buff, BUFFLEN, MSG_DONTWAIT);
						if(size>0){ 
							if(!strncmp(buff, "TIME", 4)){ //判断操作是否为获取时间
								bzero(buff, BUFFLEN);
								now = time(NULL);
								sprintf(buff, "%s\n", ctime(&now));
								send(connect_host[i], buff, BUFFLEN, 0);
							}
						}else{
							printf("recv bytes : %d client off\n",size);
							/*若客户关闭则更新描述符在数组中的值*/
							connect_host[i] = -1;
							connect_num --;
							close(connect_host[i]);
							}
					}
				}
			}
			break;
		}
	}
	return NULL;
}

客户端：

/*
 * time_tcp_client.c
 * 
 */

#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h> //包含宏STDOUT_FILENO
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <arpa/inet.h>//包含函数inet_pton
#include <signal.h>

#define BUFFLEN 24
#define SERVER_PORT 8888

int sockfd;

void sig_handle(int signum)
{
		/*步骤4：关闭socket*/
		close(sockfd);
		printf("\nclient off\n");
		exit(0);
}

int main(int argc, char **argv)
{
	signal(SIGINT,sig_handle);
	
	if(argc<2){
		printf("usage: %s ip port\n",argv[0]);
		exit(1);
	}
	
	/*步骤1：创建socket*/
	sockfd = socket(AF_INET, SOCK_STREAM,0);
	if(sockfd<0){printf("socket error");exit(1);}
	
	//往serveraddr中填入ip,port和地址族类型
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof(serveraddr));
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(SERVER_PORT);
	//将ip地址转换成网络字节序
	inet_pton(AF_INET, argv[1], &serveraddr.sin_addr.s_addr);
	/*步骤2：客户端调用connect函数连接到服务器端*/
	if(connect(sockfd, (struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){
			perror("connect error");
			exit(1);
		}
		
	char buffer[BUFFLEN];
	while(1){
		/*步骤3：调用IO函数(read/write)和服务器端进行双向通信*/
		
		memset(buffer,0,BUFFLEN);
		strcpy(buffer,"TIME");
		write(sockfd,buffer,BUFFLEN);
		memset(buffer,0,BUFFLEN);
		size_t size=0;
		//从套接字文件中读取信息
		if((size = read(sockfd,buffer,sizeof(buffer)))<0){
				perror("read error");
				exit(1);			
			}
		//将读取的数据在屏幕上输出
		printf("\n");
		if(write(STDOUT_FILENO, buffer, size) != size){
			perror("write error");
			exit(1);
		}
		sleep(1);
	}
	return 0;
}

守护进程

  1. 概念
  • 守护进程或称后台进程(daemon)是生存周期长的一种进程。他们常常在系统引导装入时启动，在系统关闭时终止。
  • 所有守护进程都以超级用户(用户ID为0)的优先权运行。
  • 守护进程没有控制终端
  • 守护进程的父进程都是init进程
  1. 守护进程编程步骤
  • 使用umask将文件模式创建屏蔽字设为0
  • 调用fork，然后让父进程退出(exit)
  • 调用setsid创建一个新会话(一个命令终端为一个会话)
  • 将当前工作目录更改为根目录
  • 关闭不需要的文件描述符
  1. 守护进程的出错处理
  • 由于守护进程完全脱离了控制终端，因此不能像其他程序一样通过输出错误信息到控制台的方式来通知程序员。
  • 通常办法是使用syslog服务，将出错信息输入到"/var/log/syslog"系统日志文件中去。
  • syslog是linux中的系统日志管理服务通过守护进程syslog来维护。
  1. syslog服务说明
  • openlog函数：用于打开系统日志服务的一个连接
  • syslog函数：用于向日志文件中写入消息，在这里可以规定消息的优先级，消息的输出格式等。
  • closelog函数：用于关闭系统日志服务的连接。
Leslie X徐
关注
专栏目录
Linux的IO多路复用
qq_36059306的博客
07-09 294
IO多路复用 多路：多个文件描述符fd 复用：复用一个后台线程 多路复用就是指：复用一个后台线程处理多个fd IO多路复用的目的：快速处理每个fd 那一个 IO 请求（比如 write ）对应一个线程来处理，这样所有的 IO 不都并发了吗？是可以，但是有瓶颈，线程数一旦多了，性能是反倒会差的 最朴素的实现 while True: for each fdList { read/write(fd, /* 参数 */) } sleep(1s) 默认创建的fd都是阻塞型的，
【计算机网络笔记九】I/O 多路复用
川峰的博客
09-28 1121
计算机网络笔记之I/O 多路复用相关内容，包括 select、poll、epoll 多路复用的了解。
Linux下的IO多路复用
m0_64288219的博客
02-26 1346
首先epoll_create创建epoll实例，它会创建所需要的红黑树，以及就绪链表，以及代表epoll实例的文件句柄，其实就是在内核开辟一块内存空间，所有与服务器连接的socket都会放到这块空间中，这些socket以红黑树的形式存在，同时还会有一块空间存放就绪链表；1.1 优点 select 其实就是把NIO中用户态要遍历的 fd 数组拷贝到了内核态，让内核态来遍历，因为用户态判断socket是否有数据还是要调用内核态的，所有拷贝到内核态后，这样遍历判断的时候就不用一直用户态和内核态频繁切换了。
Linux应用--IO多路复用
最新发布
m0_56399733的博客
08-14 921
IO多路复用技术：select、poll、epoll及两种工作模式。
Linux网络编程—— IO多路复用
weixin_43412762的博客
03-03 2345
 I/O 多路复用 使得程序能 同时监听 多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用 的 系统调用主要有 select、poll 和 epoll。
Linux——IO多路复用
没实力的码农写的渣渣博客
07-30 196
对于监听和通信而言两者都有两个缓冲区，监听调用accept函数的时候会有读写缓冲区，通信调用read和write的时候也有读写缓冲区；在单线程的条件下是不能同时处理这三个函数的阻塞的，使用多路IO复用就可以同时检测若干个文件描述符； IO多路转接并发 使用io多路复用时是委托内核检测服务端所有文件描述符（通信和监听两类），这个检测过程会导致进程/线程的阻塞，如果检测到已经就绪的文件描述符阻塞解除，并将这些已就绪的文件描述符传出； 根据类型对传出的所有已经就绪的文件描述符进行判断，并做出不同的处理： 监听的
Linux编程--IO多路复用
xinqi_1的博客
06-17 2133
IO多路复用是指通过一种机制，使得单个进程可以监控多个文件描述符的可读、可写和异常等事件。常见的IO多路复用技术包括：select、poll、epoll等。在实际应用中，IO多路复用可以提高程序的运行效率和性能，减少系统开销，降低系统资源的使用率。它广泛应用于网络编程、服务器开发、操作系统等领域，可以帮助开发人员更好地处理大量的网络连接和数据请求。
Linux I/O多路复用详解及实例
09-15
Linux I/O多路复用是一种高效的编程模型，它允许单个进程同时监视多个I/O事件，从而提高了系统的并发处理能力。在Linux中，I/O多路复用主要有三种实现方式：`select`、`poll`和`epoll`。这些机制都用于解决传统阻塞I...
一文彻底搞懂I/O多路复用及其技术
Linuxhus的博客
08-31 874
前言 ​ 高性能是每个程序员的追求，无论写一行代码还是做一个系统，都希望能够达到高性能的效果。高性能架构设计主要集中在两方面： 尽量提升单服务器的性能，将单服务器的性能发挥到极致 如果单服务器无法支撑性能，设计服务器集群方案 ​ 单服务器高性能的关键之一就是服务器采取的网络编程模型。服务器如何管理连接，如何处理请求等。这两个设计点最终都和操作系统的I/O模型及进程模型相关。 I/O模型：阻塞、非阻塞、同步、异步 进程模型：单进程、多进程、多线程。 ​ 我们所说的I/O模型是指网络I/O模型,就是服
I/O多路复用之select模型简析
weixin_42323999的博客
03-15 349
目录1 I/O多路复用1.1 主旨思想2 select函数2.1 函数原型2.2 参数说明2.3 优缺点2.3.1 优点三级目录参考： 1 I/O多路复用 1.1 主旨思想 首先要构造文件描述符列表，将要监听的文件描述符添加到该列表中； 调用一个系统函数，监听该列表中的文件描述符，直到这些文件描述符中的一个或者多个进行I/O操作时，该函数才会返回。 函数返回后，进程会被告知有哪些描述符已准备好可以进行IO操作。 select()，poll()，epoll()都是I/O多路复用的机制。I/O多路复用通过
I/O复用
灲咲的博客
04-27 555
什么是I/O复用？ 什么是I/O复用（I/O multiplexing）呢？具体点就是当你编写的程序需要同时处理多个描数字（socket或file或device），你又不知道什么时候应该（比方说有数据可以读了）去操作（读/写）哪个描数字。这时候I/O复用就需要登场了。 I/O复用是一种让进程预先“警告”内核能力，使得内核一旦发现进程预先告知时指定的一个或多个I/O条件...
Linux中IO多路复用
David_361的博客
01-14 855
本篇博客将说明linux中的阻塞IO、非阻塞IO以及这两种进行IO操作的困境，最后说明解决这种困境的方法，也就是IO多路复用 1、阻塞式IO 阻塞式IO是指在执行设备操作时，若不能获得资源，则挂起进程直到满足可操作的条件后在进行操作。被挂起的进程进入睡眠状态，被从调度运行器的运行队列中移走，直到等待的条件满足。内核中默认的都是阻塞式的实现方式，因为这种实现方式效率比较高，被阻塞时，该进程并不占...
Linux之IO多路复用
qq_35600620的博客
05-05 411
一、什么是IO多路复用 关于这部分内容请移步到下面的链接进行学习，本文主要介绍select，poll和epoll三种多路复用的实现。 https://www.zhihu.com/question/32163005 二、select的实现 2.1 select的原理： user space创建一张存放文件描述符的表，（该表的大小为1024个bit，受限于能打开文件个数），并且将需要监...
linux-I/O 多路复用
jiu_yue_ya的博客
07-19 228
IO 多路复用在 Linux 下包括了三种，select、poll、epoll，抽象来看，他们功能是类似的，但具体细节各有不同：首先都会对一组文件描述符进行相关事件的注册，然后阻塞等待某些事件的发生或等待超时。ET（边缘触发）模式下，在它检测到有 I/O 事件时，通过 epoll_wait 调用会得到有事件通知的文件描述符，对于每一个被通知的文件描述符，如可读，则必须将该文件描述符一直读到空，让 errno 返回 EAGAIN 为止，否则下次的 epoll_wait 不会返回余下的数据，会丢掉事件。
IO多路复用学习
shenfenxihuan的博客
07-03 705
在文件I/O过程中，如果为每一个对文件描述符都分配一个独立的进程/线程去完成监听等工作，会导致高并发场景下出现大量的进程/线程，造成资源损耗。因此，I/O多路复用的思想是==通过单个线程同时监控多个文件描述符（包括网络套接字、管道、文件等）进行I/O操作==。目标：单个进程或线程中能够同时处理多个输入或输出作用：单个进程或线程可以同时监视多个文件描述符，避免了创建多个进程或线程的开销**方法：**通过系统调用（selectpollepoll）实现。
Linux I/O多路复用
Xiami2019的博客
01-16 173
IO多路复用（multiplexing）本质是通过系统内核缓冲IO数据，让单个进程可以监视多个文件描述符，一旦有某个描述符就绪（读就绪或写就绪），进程就可以进行相应的操作。 select、epoll、poll是Linux提供的IO多路复用API。 Linux五种IO模型： 阻塞IO Blocking IO 非阻塞IO Nonblocking IO IO多路复用 IO Multiplexing 信号驱动IO Signal Driven IO 异步IO asynchronous IO 前四种都属于同步IO，
Linux ---- I/O 多路复用
Happinesspills
07-22 288
I/O多路复用使得程序能同时监听多个文件描述符，能够提高程序的性能，Linux下实现I/O多路复用的系统调用主要有select、poll和epoll。
Linux系统编程---I/O多路复用
qq_41683305的博客
04-28 1466
文章目录1 什么是IO多路复用2 解决什么问题说在前面I/O模型阻塞I/O非阻塞I/OIO多路复用信号驱动IO异步IO3 目前有哪些IO多路复用的方案解决方案总览常见软件的IO多路复用方案4 具体怎么用selectpollepolllevel-triggered and edge-triggered状态变化通知(edge-triggered)模式下的epoll5 不同IO多路复用方案优缺点poll vs selectepoll vs poll&select 1 什么是IO多路复用 一句话解释：单线程
Linux I/O多路复用详解：实战与应用
Linux I/O多路复用详解及实例深入剖析了在Linux操作系统中处理I/O（Input/Output）操作的一种高级技术，它允许进程同时监控多个文件描述符，而非等待每个I/O操作完全完成。Linux操作系统将各种设备抽象为文件，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值