linux下的四种IO模型

最新推荐文章于 2024-02-20 18:03:25 发布
最新推荐文章于 2024-02-20 18:03:25 发布
阅读量1k 收藏
点赞数 2
文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46060137/article/details/121768602
版权

一、linux下的四种IO模型包含哪些？

       Linux下的四种IO模型包含：阻塞模型、非阻塞模型、异步驱动模型、多路复用模型。四种模型原理图如图1-1所示。

图1-1 模型原理图

    Linux中常见的命令名如图1-2所示。

图1-2 文件命令名描述图

 

二、Linux下四种模型简介

1..阻塞模型

      一般情况下，文件描述符都是阻塞模型，与阻塞相关的函数有: accept,recv,recvfrom,read。

阻塞其实就是将进程由执行态调度到了睡眠态

代码示例1：

/*客户端*/
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>     
#include <sys/socket.h>

int main()
{
	//(1)创建数据流套接字
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd == -1)
	{
		perror(" socket tcp failed");
		return -1;
	}
	
	//(2)初始化网络通信结构体
	//(3)把网络通信结构体和套接字绑定在一起
	//(2)和(3)可以省略，此时发送方的端口号随机，如果要固定，就不能省略
	
	//(4)向服务器发起连接请求
	struct sockaddr_in destaddr;
	destaddr.sin_family  = AF_INET;
	destaddr.sin_port    = htons(40000);
	destaddr.sin_addr.s_addr = inet_addr("192.168.12.16");//服务器的IP地址
	
	socklen_t len = sizeof(struct sockaddr_in);
	int ret = connect(sockfd,(struct sockaddr*)&destaddr,len);
	if(ret == -1)
	{
		perror("connect failed");
		return -1;
	}

	//数据的收发
	char buf[32];
	while(1)
	{
		scanf("%s",buf);
		send(sockfd,buf,32,0);
	}

	return 0;
}
/*服务器端*/
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>     
#include <sys/socket.h>

int main()
{
	//(1)创建数据流套接字
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd == -1)
	{
		perror(" socket tcp failed");
		return -1;
	}
	
	//(2)初始化网络通信结构体
	struct sockaddr_in myaddr;
	myaddr.sin_family  = AF_INET;
	myaddr.sin_port    = htons(40000);
	myaddr.sin_addr.s_addr = INADDR_ANY;
	
	//(3)把网络通信结构体和套接字绑定在一起
	socklen_t len = sizeof(struct sockaddr_in);
	int ret  = bind(sockfd,(struct sockaddr*)&myaddr,len);
	if(ret == -1)
	{
		perror("bind failed");
		return -1;
	}	
	//(4)监听是否有客户端连接到服务器
	if( listen(sockfd,5) != 0)
	{
		perror("listen failed");
		return -1;
	}		
	//(5)等待客户端向服务器发起连接请求。
	struct sockaddr_in clientaddr;
	int server_sock = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
	if(server_sock == -1)
	{
		perror("accept failed");
		return -1;
	}
	printf("accept new_client connect\n");
	printf("clien.sin_port = %hu\n",ntohs(clientaddr.sin_port));
	printf("clien.sin_addr = %s\n",inet_ntoa(clientaddr.sin_addr));
	
	
	//数据的收发
	char buf[32];
	while(1)
	{
		recv(server_sock,buf,32,0);
		printf("recv:%s\n",buf);
	}

	return 0;
}

2..非阻塞模型

非阻塞模型与阻塞模型相反。修改文件属性函数：

int fcntl(int fd, int cmd, ... /* arg */ );

参数一： 要操作的文件的文件描述符

参数二： 要操作的命令

参数三： 根据参数二需要加入的参数，也可以根据情况省略

非阻塞模型下，原本可以作为阻塞使用的函数，都无法再将进程调度到睡眠态。

将server_sock设置成非阻塞模型：

long stu = fcntl(server_sock,F_GETFL); //先获取原文件的属性

stu |= O_NONBLOCK; //位或的原因:是为了不改变原有的文件属性，加上非阻塞属性

fcntl(server_sock,F_SETFL,stu); //把改变后的属性放回原文件中

代码示例2：

客户端代码与示例代码1客户端一样。

/*服务器端*/
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>     
#include <sys/socket.h>
#include <fcntl.h>


int main()
{
	//(1)创建数据流套接字
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd == -1)
	{
		perror(" socket tcp failed");
		return -1;
	}
	
	//(2)初始化网络通信结构体
	struct sockaddr_in myaddr;
	myaddr.sin_family  = AF_INET;
	myaddr.sin_port    = htons(40000);
	myaddr.sin_addr.s_addr = INADDR_ANY;
	
	//(3)把网络通信结构体和套接字绑定在一起
	socklen_t len = sizeof(struct sockaddr_in);
	int ret  = bind(sockfd,(struct sockaddr*)&myaddr,len);
	if(ret == -1)
	{
		perror("bind failed");
		return -1;
	}
	
	//(4)监听是否有客户端连接到服务器
	if( listen(sockfd,5) != 0)
	{
		perror("listen failed");
		return -1;
	}
		
	//(5)等待客户端向服务器发起连接请求。
	struct sockaddr_in clientaddr;
	int server_sock = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
	if(server_sock == -1)
	{
		perror("accept failed");
		return -1;
	}
	printf("accept new_client connect\n");
	printf("clien.sin_port = %hu\n",ntohs(clientaddr.sin_port));
	printf("clien.sin_addr = %s\n",inet_ntoa(clientaddr.sin_addr));
	
	
	//将server_sock设置成非阻塞模型
	long stu = fcntl(server_sock,F_GETFL);//先获取原文件的属性
	stu |= O_NONBLOCK;//位或的原因:是为了不改变原有的文件属性，加上非阻塞属性
	fcntl(server_sock,F_SETFL,stu);//把改变后的属性放回原文件中
	
	
	//数据的收发
	char buf[32];
	while(1)
	{
		recv(server_sock,buf,32,0);
		printf("recv:%s\n",buf);
	}

	return 0;
}

3..异步驱动模型

      异步驱动模型是由文件产生input或者output数据流时，引发操作系统产生SIGIO或者SIGURG信号，然后进入到信号注册函数中处理。

signal(SIGIO,catch);//注册信号

fcntl(server_sock,F_SETOWN,getpid());//接收SIGIO信号的是当前进程

fcntl(server_sock,F_SETFL,O_ASYNC);//将文件属性设置为异步属性

示例代码3：

客户端代码与示例代码1客户端一样。

/*服务器端*/
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>     
#include <sys/socket.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
 
int server_sock=0;

void catch(int sig)
{
	//数据的收发
	char buf[32];

	recv(server_sock,buf,32,0);
	printf("recv:%s\n",buf);
}

int main()
{
	//(1)创建数据流套接字
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd == -1)
	{
		perror(" socket tcp failed");
		return -1;
	}
	
	//(2)初始化网络通信结构体
	struct sockaddr_in myaddr;
	myaddr.sin_family  = AF_INET;
	myaddr.sin_port    = htons(40000);
	myaddr.sin_addr.s_addr = INADDR_ANY;
	
	//(3)把网络通信结构体和套接字绑定在一起
	socklen_t len = sizeof(struct sockaddr_in);
	int ret  = bind(sockfd,(struct sockaddr*)&myaddr,len);
	if(ret == -1)
	{
		perror("bind failed");
		return -1;
	}
	
	//(4)监听是否有客户端连接到服务器
	if( listen(sockfd,5) != 0)
	{
		perror("listen failed");
		return -1;
	}
		
	//(5)等待客户端向服务器发起连接请求。
	struct sockaddr_in clientaddr;
	server_sock = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
	if(server_sock == -1)
	{
		perror("accept failed");
		return -1;
	}
	printf("accept new_client connect\n");
	printf("clien.sin_port = %hu\n",ntohs(clientaddr.sin_port));
	printf("clien.sin_addr = %s\n",inet_ntoa(clientaddr.sin_addr));

	signal(SIGIO,catch);//注册信号
	fcntl(server_sock,F_SETOWN,getpid());//接收当前信号的是当前进程
	fcntl(server_sock,F_SETFL,O_ASYNC);//将文件属性设置为异步属性
	
	int i=0;
	while(1)
	{
		printf("sec:%d\n",i++);
		sleep(1);
	}

	return 0;
}

4..多路复用模型

       多路复用模型是不停的监控一个文件集合。如果文件集合中的文件描述符有变化，那么立即退出监控，检测变化的原因。如果没有变化，那么也只是监控一段时间，自动退出。原理图如下图所示。

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

int select(int nfds, fd_set *readfds, fd_set *writefds,
		  fd_set *exceptfds, struct timeval *timeout);
		参数一： 文件描述符的最大值+1
		参数二： 需要监控读操作的文件集合
		参数三： 需要监控写操作的文件集合
		参数四： 需要监控执行操作的文件集合
		参数五： 超时时间

	返回值： 如果有文件集合产生动作，返回值>0
			 如果没有文件集合产生动作，是超时结束，返回值==0
			 如果失败出错，返回-1.
			 
//把fd文件描述符从set集合中删除
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);

//清空set文件集合
void FD_ZERO(fd_set *set);

//超时时间结构体
struct timeval {
   long    tv_sec;         秒
   long    tv_usec;        微秒
};

多路复用模型的优点: 在同时处理多个文件描述符的时候，可以不开线程。

示例代码4：

客户端与示例代码1一样。

/*服务器端*/
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>     
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>

int main()
{
	//(1)创建数据流套接字
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd == -1)
	{
		perror(" socket tcp failed");
		return -1;
	}
	
	int on=1;
	setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));

	//(2)初始化网络通信结构体
	struct sockaddr_in myaddr;
	myaddr.sin_family  = AF_INET;
	myaddr.sin_port    = htons(40000);
	myaddr.sin_addr.s_addr = INADDR_ANY;
	
	//(3)把网络通信结构体和套接字绑定在一起
	socklen_t len = sizeof(struct sockaddr_in);
	int ret  = bind(sockfd,(struct sockaddr*)&myaddr,len);
	if(ret == -1)
	{
		perror("bind failed");
		return -1;
	}
	
	//(4)监听是否有客户端连接到服务器
	if( listen(sockfd,5) != 0)
	{
		perror("listen failed");
		return -1;
	}
	//开始设置文件描述符监控 select
	int maxfd = sockfd;	//用来保存最大的文件描述符
	fd_set rfd;		//读文件集合
	int server_fd[20];//用来保存客户端连接后产生的通信用桃姐
	int i=0;		//用来表示server_fd下表
	int num=0;		//用来表示客户端的个数
	
	struct timeval t;//超时时间结构体
	
	while(1)
	{
		FD_ZERO(&rfd);	//清空文件集合
		
		FD_SET(sockfd,&rfd);	//把套接字加入到读文件集合
		
		for(i=0;i<num;i++)
			FD_SET( server_fd[i],&rfd); //将客户端文件描述符加入到读文件集合
		
		t.tv_sec = 2;//超时时间为2秒
		
		printf("准备监听\n");
		//监控文件描述符集合
		ret = select(maxfd+1,&rfd,NULL,NULL,&t);
		if(ret == -1)
		{
			perror("select failed");
			return -1;
		}
		
		else if(ret == 0)
		{
			printf("时间超时\n");
			continue;
		}
		
		else if(ret > 0)//文件集合中的文件描述符有动作
		{
			//判断 sockfd 是否还在集合中
			if( FD_ISSET(sockfd,&rfd) )
			{
				//(5)等待客户端向服务器发起连接请求。
				struct sockaddr_in clientaddr;
				server_fd[num] = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
				if(server_fd[num] == -1)
				{
					perror("accept failed");
					return -1;
				}
				printf("accept new_client connect\n");
				printf("clien.sin_port = %hu\n",ntohs(clientaddr.sin_port));
				printf("clien.sin_addr = %s\n",inet_ntoa(clientaddr.sin_addr));
				
				if(maxfd < server_fd[num])
					maxfd = server_fd[num];//最大的文件描述符是最新创建的这个
				
				num++;//客户端连接个数+1
			}		
			//客户端发过来数据---每次遍历客户端文件描述符集合
			for(i=0;i<num;i++)
			{
				if(  FD_ISSET(server_fd[i],&rfd) )
				{	
					//数据的收发
					char buf[32];

					recv(server_fd[i],buf,32,0);
					printf("server_fd[%d]=%d,recv:%s\n",i,server_fd[i],buf);	
					
					if(strcmp("88",buf)==0)
					{
						close(server_fd[i]);

						int j;
						for(j=i;j<num;j++)
							server_fd[j] = server_fd[j+1];
						num--;
					}	
				}	
			}
		}	
	}
	return 0;
}

总结

本文仅仅对Linux下的阻塞模型、非阻塞模型、异步驱动模型、多路复用模型四种IO模型进行了简单的介绍。

Joseph-song
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux下五种网络IO模型
yangrendong的专栏
05-24 2162
本文我们主要来了解一下Unix/Linux下5种网络IO模型：blocking IO, nonblocking IO, IO multiplexing, signal driven IO, asynchronous IO的基本原理，更好的理解在高级语言中的异步编程，一起来看看吧，希望对大家学习linux有所帮助。 　　写在前面 　　为了更好的理解下面提到的Linux下5种网络IO的概念，...
linux: 五种IO模型（IO多路复用）
qq_42665165的博客
01-03 197
linux: 五种IO模型（IO多路复用） 阻塞和非阻塞 侧重状态。 阻塞调用是指调用后对方一直没有给你回复，你一直等着，什么事都不能干。 非阻塞调用指在调用后一直没有给你回复，你每一段时间就问一次，你在这期间可以干别的。 同步和异步 侧重方式。 同步：甲方请求一次，乙方应答一次”这样的有序序列处理业务，只有当“一次请求一次应答”的过程结束才可以发生下一次的“一次请求一次应答”，那么就说他们采用的是同步。 异步：如果甲方只要有需要，就会发送请求，不管上次请求有没有得到乙方应答。而乙方只要甲方有请求就会接受，
Linux中5种IO模型
weixin_45819295的博客
07-15 2490
同步/异步，阻塞/非阻塞，Linux中5种IO模型，BIO、NIO、AIO
文件高级---IO处理,文件锁,存储映射
yuanzhiyuan的博客
02-24 843
socket阻塞与非阻塞，同步与异步 1. 同步，就是我调用一个功能，该功能没有结束前，我死等结果。 2. 异步，就是我调用一个功能，不需要知道该功能结果，该功能有结果后通知我（回调通知） 3. 阻塞，      就是调用我（函数），我（函数）没有接收完数据或者没有得到结果之前，我不会返回。 4. 非阻塞，  就是调用我（函数），我（函数）立即返回，通过select通知调用者
在UNIX和LINUX下的四种I/O模型
weixin_70251166的博客
11-19 531
UNIX和LINUX下的四种I/O模型基础
一张图学会JVM内存模型和运行原理
qq_14868375的博客
10-14 181
先上一张重要的原理图，这里挂上原理图的psd文件，方便大家有了自己的理解后在里面增加修改自己理解的内容。psd文件地址：https://download.csdn.net/download/qq_14868375/12922475 理解jvm主要要理解两个内容 1、Java类的编译、加载和执行。这是今天篇文章主要讲的内容。 2、JVM的内存管理和垃圾回收机制。这个主要讲的是堆的的管理，是下一篇文章主要讲的内容。 今天先讲Java类的编译、加载和执行。 1. Java类的编译过程 这是由*.j
Linux 中的五种 I/O 模型
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
04-03 1232
阻塞 I/O 模型、非阻塞 I/O 模型、I/O 复用模型、信号驱动 I/O 模型、异步 I/O 模型
Linux下的五种IO模型
02-26
针对linux操作系统而言，将最高的1G字节（从虚拟地址0xC0000000到0xFFFFFFFF），供内核使用，称为内核空间，而将较低的3G字节（从虚拟地址0×00000000到0xBFFFFFFF），供各个进程使用，称为用户空间。为了控制进程的...
Linux 下的五种 IO 模型详细介绍
09-15
主要介绍了Linux 下的五种 IO 模型详细介绍的相关资料,需要的朋友可以参考下
linux io 模型
01-09
linux io模型，区分阻塞非阻塞同步异步的概念，从底层理解io。
Linux的5种IO模型
最新发布
byteinit的专栏
02-20 373
非阻塞IO模型与阻塞IO模型类似，但应用程序线程不会被阻塞。在非阻塞IO模型中，当应用程序发起一个IO请求时，如果内核无法立即完成该请求，应用程序线程可以继续执行其他操作，直到内核完成该请求并通知应用程序。阻塞IO模型是最简单的IO模型，也是最常用的IO模型之一。在阻塞IO模型中，当应用程序发起一个IO请求时，如果内核无法立即完成该请求，应用程序线程会被阻塞，直到内核完成该请求。IO多路复用模型允许应用程序监视多个IO句柄，并在一个线程中处理多个IO事件。
Linux的五个I/O模型
QtHalcon
09-23 4640
前面的 fcntl()函数解决了文件的共享问题， 接下来该处理 I/O 复用的情况了。 总的来说， I/O 处理的模型有 5 种。  1.阻塞 I/O 模型： 在这种模型下， 若所调用的 I/O 函数没有完成相关的功能， 则会使进程挂起， 直到相关数据到达才会返回。 如常见对管道设备、 终端设备和网络设备进行读写时经常会出现这种情况。 2.非阻塞 I/O 模型： 在这种模型下， ...
Linux中的五种IO模型
m0_56602092的博客
04-19 439
Linux中有以下五种IO模型。一、同步阻塞IO（Blocking IO, BIO）二、同步非阻塞IO（Non-Blocking IO, NIO）三、IO多路复用 四、信号驱动 I/O 五、异步 I/O（Async IO, AIO）
Linux 5种IO模型
weixin_41613490的博客
05-22 260
select 和poll 只会通知用户进程有FD就绪，但不确定具体是哪个FD，需要用户进程逐个遍历FD 来确认。epoll 则会在通知用户进程的FD 就绪的同时，把已就绪的FD写入用户空间。
Linux下五种IO模型
m0_52165864的博客
06-20 1304
目录1、引入的概念1.1 用户空间和内核空间1.2 进程切换1.3 进程的阻塞 1.4文件描述符fd1.5 缓存IO2、Linux IO模型2.1 同步阻塞IO（blocking IO）2.1.1 同步阻塞情景描述：2.1.2 网络模型2.1.3 流程描述2.2 同步非阻塞IO（nonlocking IO）2.2.1 同步非阻塞情景描述2.2.2 网络模型2.2.3 流程描述2.3 IO多路复用(IO multiplexing）2.3.1 IO多路复用情景描述2.3.2 网络模型2.3.3 流程描述2.4
高性能IO模型分析-I/O模型简介（一）
泡飞的博客
12-05 1022
I/O模型简介 文章目录一、基础概念用户空间和内核空间进程切换进程阻塞文件描述符缓存 I/O二、I/O执行的两大阶段三、五大模型及对比Linux的五大I/O模型1、同步阻塞IO（blocking IO）2、同步非阻塞IO（nonblocking IO)3、IO多路复用（IO multiplexing）4、信号驱动IO（signal driven IO）5、异步IO（asynchronous IO）...
关于linux io模型的描述正确的是,Linux 下的五种 IO 模型详细介绍(2)
weixin_26749245的博客
05-14 327
典型的异步编程模型比如Node.js。2016.4.17更新：POSIX对这两个术语的定义：同步I/O操作：导致请求进程阻塞，直到I/O操作完成异步I/O操作：不导致请求进程阻塞2. 阻塞与非阻塞阻塞和非阻塞关注的是程序在等待调用结果(消息，返回值)时的状态。阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线...
Linux 5种网络IO模型
feikudai8460的博客
08-16 1739
1、支持一个进程所能打开的最大连接数select：单个进程所能打开的最大连接数有FD_SETSIZE宏定义，其大小是32个整数的大小（在32位的机器上，大小就是3232，同理64位机器上FD_SETSIZE为3264），当然我们可以对进行修改，然后重新编译内核，但是性能可能会受到影响，这需要进一步的测试。poll：poll本质上和select没有区别，但是它没有最大连接数的限制，原因是它是基于链表来存储的。
【网络篇】Linux 下的五种IO模型（万字总结）
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，主要集中在瑞芯微和全志平台。
03-27 460
Linux下的五种IO模型：阻塞IO、非阻塞IO、IO多路复用、信号驱动IO、异步IO
Linux IO模型
08-13
它主要包括阻塞IO、非阻塞IO、多路复用IO和异步IO四种模型。 阻塞IO是最简单的IO模型，当一个IO操作发生时，应用程序会被阻塞，直到IO操作完成才能继续执行。这种模型的特点是简单直接，但是当有多个IO操作时会造成...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值