并发式IO的解决方案---非阻塞式、多路复用和异步通知（异步IO）

2024-06-12 06:48
文章标签 解决方案 异步 阻塞 io 通知 多路复用 发式

本文主要是介绍并发式IO的解决方案---非阻塞式、多路复用和异步通知（异步IO），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

---非阻塞式IO
阻塞式读取键盘和鼠标： 
    
  1. // 读取鼠标
  2. 	int fd = -1;
  3. 	char buf[200];
  4. 	
  5. 	fd = open("/dev/input/mouse1", O_RDONLY);
  6. 	if (fd < 0)
  7. 	{
  8. 		perror("open:");
  9. 		return -1;
  10. 	}
  11. 	
  12. 	memset(buf, 0, sizeof(buf));
  13. 	printf("before 鼠标 read.\n");
  14. 	read(fd, buf, 50);
  15. 	printf("鼠标读出的内容是：[%s].\n", buf);
  16. 	
  17. 	
  18. 	// 读键盘
  19. 	memset(buf, 0, sizeof(buf));
  20. 	printf("before 键盘 read.\n");
  21. 	read(0, buf, 5);
  22. 	printf("键盘读出的内容是：[%s].\n", buf);
  23. 	
  24. 	
  25. 	return 0;

实现非阻塞IO访问：O_NONBLOCK和fcntl 
    
  1. int fcntl(int fd, int cmd, ... /* arg */ );
F_GETFL (void)
Get the file access mode and the file status flags; arg is ignored.
F_SETFL (int)
Set the file status flags to  the  value  specified  by  arg.   File  access  mode
(O_RDONLY,  O_WRONLY,  O_RDWR)  and  file  creation  flags (i.e., O_CREAT, O_EXCL,
O_NOCTTY, O_TRUNC) in arg are ignored.  On Linux this command can change only  the
O_APPEND, O_ASYNC, O_DIRECT, O_NOATIME, and O_NONBLOCK flags.
属性：
O_NONBLOCK //非阻塞
O_ASYNC //接收异步IO
 
    
  1. int fd = -1;
  2. 	int flag = -1;
  3. 	char buf[200];
  4. 	int ret = -1;
  5. 	
  6. 	fd = open("/dev/input/mouse1", O_RDONLY | O_NONBLOCK);
  7. 	if (fd < 0)
  8. 	{
  9. 		perror("open:");
  10. 		return -1;
  11. 	}
  12. 	
  13. 	// 把0号文件描述符（stdin）变成非阻塞式的
  14. 	flag = fcntl(0, F_GETFL);		// 先获取原来的flag
  15. 	flag |= O_NONBLOCK;				// 添加非阻塞属性
  16. 	fcntl(0, F_SETFL, flag);		// 更新flag
  17. 	// 这3步之后，0就变成了非阻塞式的了
  18. 	
  19. 	while (1)
  20. 	{
  21. 		// 读鼠标
  22. 		memset(buf, 0, sizeof(buf));
  23. 		//printf("before 鼠标 read.\n");
  24. 		ret = read(fd, buf, 50);
  25. 		if (ret > 0)
  26. 		{
  27. 			printf("鼠标读出的内容是：[%s].\n", buf);
  28. 		}
  29. 		
  30. 		// 读键盘
  31. 		memset(buf, 0, sizeof(buf));
  32. 		//printf("before 键盘 read.\n");
  33. 		ret = read(0, buf, 5);
  34. 		if (ret > 0)
  35. 		{
  36. 			printf("键盘读出的内容是：[%s].\n", buf);
  37. 		}
  38. 	}

---多路复用IO
select和poll
外部阻塞式，内部非阻塞式自动轮询多路阻塞式IO
---select函数介绍 
     
  1. int select(int nfds, fd_set *readfds, fd_set *writefds,
  2.                   fd_set *exceptfds, struct timeval *timeout);     
  3. //nfds：多路阻塞式IO中最大的文件描述符+1
  4. //*readfds：要读的IO
  5. //*writefds：要写的IO
  6. //*exceptfds：出现错误的IO
  7. //*timeout：超时时间，在超时时间内，有IO激活函数，则立刻返回，没有IO激活，则在到达超时时间时返回
  8. //struct timeval {time_t      tv_sec;     /* seconds */suseconds_t tv_usec;    /* microseconds */};

  10. //返回值：0-超时返回   >0-返回的是IO的返回路数   -1-返回错误
select的几个宏函数： 
      
  1.        void FD_CLR(int fd, fd_set *set);              //将fd从set里面拿出去    clearO(∩_∩)O~
  2.        int  FD_ISSET(int fd, fd_set *set);             //判断fd有没有被置位，返回值是正的，说明这个fd的IO发生了，负的就没有发生
  3.        void FD_SET(int fd, fd_set *set);                //将fd添加进set里面去
  4.        void FD_ZERO(fd_set *set);                       //将所有的fd_set全部清除出去
代码实践：用select函数实现同时读取键盘鼠标 
     
  1. 	int fd = -1, ret = -1;
  2. 	char buf[200];
  3. 	fd_set myset;
  4. 	struct timeval tm;
  5. 	
  6. 	fd = open("/dev/input/mouse1", O_RDONLY);
  7. 	if (fd < 0)
  8. 	{
  9. 		perror("open:");
  10. 		return -1;
  11. 	}
  12. 	
  13. 	// 当前有2个fd，一共是fd一个是0
  14. 	// 处理myset
  15. 	FD_ZERO(&myset);
  16. 	FD_SET(fd, &myset);    //鼠标的
  17. 	FD_SET(0, &myset);     //键盘的
  18. 	
  19. 	tm.tv_sec = 10;
  20. 	tm.tv_usec = 0;
  22. 	ret = select(fd+1, &myset, NULL, NULL, &tm);       //如果两个都没有输入，程序就会在这阻塞住
  23. 	if (ret < 0)
  24. 	{
  25. 		perror("select: ");
  26. 		return -1;
  27. 	}
  28. 	else if (ret == 0)
  29. 	{
  30. 		printf("超时了\n");
  31. 	}
  32. 	else
  33. 	{
  34. 		// 等到了一路IO，然后去监测到底是哪个IO到了，处理之
  35. 		if (FD_ISSET(0, &myset))
  36. 		{
  37. 			// 这里处理键盘
  38. 			memset(buf, 0, sizeof(buf));
  39. 			read(0, buf, 5);
  40. 			printf("键盘读出的内容是：[%s].\n", buf);
  41. 		}
  42. 		
  43. 		if (FD_ISSET(fd, &myset))
  44. 		{
  45. 			// 这里处理鼠标
  46. 			memset(buf, 0, sizeof(buf));
  47. 			read(fd, buf, 50);
  48. 			printf("鼠标读出的内容是：[%s].\n", buf);
  49. 		}
  50. 	}
  52. 	return 0;


---poll函数介绍 
    
  1. int poll(struct pollfd *fds, nfds_t nfds, int timeout);
//使用前必须先设置 struct pollfd * fds 
    
  1. struct pollfd {
  2.                int   fd;         /* file descriptor */
  3.                short events;     /* requested events */
  4.                short revents;    /* returned events */ //是内核设置的
  5.            };
     
  1. events常用宏：
  2.               POLLIN     There is data to read.   //FD要读
  3.               POLLOUT     Writing now will not block.//FD要写
如果有事件发生，要判断是哪个IO发生的，就去判断每个IO的 events和revents是否相等 ，若相等就说明此IO发生
返回值和select一样；
代码实践：用poll函数实现同时读取键盘鼠标 
    
  1. // 读取鼠标
  2. 	int fd = -1, ret = -1;
  3. 	char buf[200];
  4. 	struct pollfd myfds[2] = {0};
  5. 	
  6. 	fd = open("/dev/input/mouse1", O_RDONLY);
  7. 	if (fd < 0)
  8. 	{
  9. 		perror("open:");
  10. 		return -1;
  11. 	}
  12. 	
  13. 	// 初始化我们的pollfd
  14. 	myfds[0].fd = 0;			// 键盘
  15. 	myfds[0].events = POLLIN;	// 等待读操作
  16. 	
  17. 	myfds[1].fd = fd;			// 鼠标
  18. 	myfds[1].events = POLLIN;	// 等待读操作
  20. 	ret = poll(myfds, fd+1, 10000);
  21. 	if (ret < 0)
  22. 	{
  23. 		perror("poll: ");
  24. 		return -1;
  25. 	}
  26. 	else if (ret == 0)
  27. 	{
  28. 		printf("超时了\n");
  29. 	}
  30. 	else
  31. 	{
  32. 		// 等到了一路IO，然后去监测到底是哪个IO到了，处理之
  33. 		if (myfds[0].events == myfds[0].revents)
  34. 		{
  35. 			// 这里处理键盘
  36. 			memset(buf, 0, sizeof(buf));
  37. 			read(0, buf, 5);
  38. 			printf("键盘读出的内容是：[%s].\n", buf);
  39. 		}
  40. 		
  41. 		if (myfds[1].events == myfds[1].revents)
  42. 		{
  43. 			// 这里处理鼠标
  44. 			memset(buf, 0, sizeof(buf));
  45. 			read(fd, buf, 50);
  46. 			printf("鼠标读出的内容是：[%s].\n", buf);
  47. 		}
  48. 	}
  50. 	return 0;

---异步通知（异步IO）
异步IO的工作方法是：我们当前进程注册一个异步IO事件（使用signal注册一个信号SIGIO的处理函数），然后当前进程可以正常处理自己的事情，当异步事件发生后当前进程会收到一个SIGIO信号从而执行绑定的处理函数去处理这个异步事件。
3.6.6.2、涉及的函数：
(1)fcntl（F_GETFL、F_SETFL、O_ASYNC、F_SETOWN）
(2)signal或者sigaction（SIGIO）
3.6.3.代码实践 
    
  1. int mousefd = -1;
  3. // 绑定到SIGIO信号，在函数内处理异步通知事件
  4. void func(int sig)
  5. {
  6. 	char buf[200] = {0};
  7. 	
  8. 	if (sig != SIGIO)
  9. 		return;
  11. 	read(mousefd, buf, 50);
  12. 	printf("鼠标读出的内容是：[%s].\n", buf);
  13. }
  15. int main(void)
  16. {
  17. 	// 读取鼠标
  18. 	char buf[200];
  19. 	int flag = -1;
  20. 	
  21. 	mousefd = open("/dev/input/mouse1", O_RDONLY);
  22. 	if (mousefd < 0)
  23. 	{
  24. 		perror("open:");
  25. 		return -1;
  26. 	}	
  27. 	// 把鼠标的文件描述符设置为可以接受异步IO
  28. 	flag = fcntl(mousefd, F_GETFL);
  29. 	flag |= O_ASYNC;        //接受异步IO
  30. 	fcntl(mousefd, F_SETFL, flag);
  31. 	// 把异步IO事件的接收进程设置为当前进程
  32. 	fcntl(mousefd, F_SETOWN, getpid());
  33. 	
  34. 	// 注册当前进程的SIGIO信号捕获函数
  35. 	signal(SIGIO, func);
  36. 	
  37. 	// 读键盘
  38. 	while (1)
  39. 	{
  40. 		memset(buf, 0, sizeof(buf));
  41. 		//printf("before 键盘 read.\n");
  42. 		read(0, buf, 5);
  43. 		printf("键盘读出的内容是：[%s].\n", buf);
  44. 	}
  45. 		
  46. 	return 0;
  47. }

---存储映射IO
mmap函数
LCD显示和IPC之共享内存
存储映射IO的特点
(1)共享而不是复制，减少内存操作
(2)处理大文件时效率高，小文件不划算






这篇关于并发式IO的解决方案---非阻塞式、多路复用和异步通知（异步IO）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1053479。

相关文章

线上Java OOM问题定位与解决方案超详细解析

线上Java OOM问题定位与解决方案超详细解析

《线上JavaOOM问题定位与解决方案超详细解析》OOM是JVM抛出的错误,表示内存分配失败,：本文主要介绍线上JavaOOM问题定位与解决方案的相关资料,文中通过代码介绍的非常详细,需要的朋... 目录一、OOM问题核心认知1.1 OOM定义与技术定位1.2 OOM常见类型及技术特征二、OOM问题定位工具
阅读更多...
Python一次性将指定版本所有包上传PyPI镜像解决方案

Python一次性将指定版本所有包上传PyPI镜像解决方案

《Python一次性将指定版本所有包上传PyPI镜像解决方案》本文主要介绍了一个安全、完整、可离线部署的解决方案,用于一次性准备指定Python版本的所有包,然后导出到内网环境,感兴趣的小伙伴可以跟随... 目录为什么需要这个方案完整解决方案1. 项目目录结构2. 创建智能下载脚本3. 创建包清单生成脚本4
阅读更多...
java.sql.SQLTransientConnectionException连接超时异常原因及解决方案

java.sql.SQLTransientConnectionException连接超时异常原因及解决方案

《java.sql.SQLTransientConnectionException连接超时异常原因及解决方案》：本文主要介绍java.sql.SQLTransientConnectionExcep... 目录一、引言二、异常信息分析三、可能的原因3.1 连接池配置不合理3.2 数据库负载过高3.3 连接泄漏
阅读更多...
C#文件复制异常："未能找到文件"的解决方案与预防措施

C#文件复制异常："未能找到文件"的解决方案与预防措施

《C#文件复制异常：未能找到文件的解决方案与预防措施》在C#开发中,文件操作是基础中的基础,但有时最基础的File.Copy()方法也会抛出令人困惑的异常,当targetFilePath设置为D:2... 目录一个看似简单的文件操作问题问题重现与错误分析错误代码示例错误信息根本原因分析全面解决方案1. 确保
阅读更多...
C# LiteDB处理时间序列数据的高性能解决方案

C# LiteDB处理时间序列数据的高性能解决方案

《C#LiteDB处理时间序列数据的高性能解决方案》LiteDB作为.NET生态下的轻量级嵌入式NoSQL数据库,一直是时间序列处理的优选方案,本文将为大家大家简单介绍一下LiteDB处理时间序列数... 目录为什么选择LiteDB处理时间序列数据第一章：LiteDB时间序列数据模型设计1.1 核心设计原则
阅读更多...
Python异步编程之await与asyncio基本用法详解

Python异步编程之await与asyncio基本用法详解

《Python异步编程之await与asyncio基本用法详解》在Python中,await和asyncio是异步编程的核心工具,用于高效处理I/O密集型任务（如网络请求、文件读写、数据库操作等）,接... 目录一、核心概念二、使用场景三、基本用法1. 定义协程2. 运行协程3. 并发执行多个任务四、关键
阅读更多...
SpringBoot3匹配Mybatis3的错误与解决方案

SpringBoot3匹配Mybatis3的错误与解决方案

《SpringBoot3匹配Mybatis3的错误与解决方案》文章指出SpringBoot3与MyBatis3兼容性问题,因未更新MyBatis-Plus依赖至SpringBoot3专用坐标,导致类冲... 目录SpringBoot3匹配MyBATis3的错误与解决mybatis在SpringBoot3如果
阅读更多...
C++ vector越界问题的完整解决方案

C++ vector越界问题的完整解决方案

《C++vector越界问题的完整解决方案》在C++开发中,std::vector作为最常用的动态数组容器,其便捷性与性能优势使其成为处理可变长度数据的首选,然而,数组越界访问始终是威胁程序稳定性的... 目录引言一、vector越界的底层原理与危害1.1 越界访问的本质原因1.2 越界访问的实际危害二、基
阅读更多...
Go中select多路复用的实现示例

Go中select多路复用的实现示例

《Go中select多路复用的实现示例》Go的select用于多通道通信,实现多路复用,支持随机选择、超时控制及非阻塞操作,建议合理使用以避免协程泄漏和死循环,感兴趣的可以了解一下... 目录一、什么是select基本语法：二、select 使用示例示例1：监听多个通道输入三、select的特性四、使用se
阅读更多...
Python 字符串裁切与提取全面且实用的解决方案

Python 字符串裁切与提取全面且实用的解决方案

《Python字符串裁切与提取全面且实用的解决方案》本文梳理了Python字符串处理方法,涵盖基础切片、split/partition分割、正则匹配及结构化数据解析（如BeautifulSoup、j... 目录python 字符串裁切与提取的完整指南 基础切片方法1. 使用切片操作符[start:end]2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2