详解--高级IO
Posted 拾至灬名瑰
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了详解--高级IO相关的知识,希望对你有一定的参考价值。
文章目录
前言
- 理解五种IO模型的基本概念.重点是IO多路转接.
正文开始!
一、五种IO模型
IO: 等 + 数据拷贝
read/recv:
- 等 IO事件就绪 --检测功能成分在里面.
- 数据拷贝
什么叫做高效的IO?
单位事件,等的比重越小,IO的效率越高.
阻塞IO
阻塞IO:在内核将数据准备好之前,系统调用会一直等待.所有的套接字,默认都是阻塞方式.
阻塞IO是最常见的IO模型.
非阻塞IO
非阻塞IO:如果内核还未将数据准备好,系统调用仍然会直接返回,并且返回EWOULDBLOCK错误码.
非阻塞IO往往需要程序猿循环的方式反复尝试读取文件描述符,这个过程叫做轮询.这对CPU来说是较大的浪费,一般只有特定的场景下才使用.
信号驱动IO
信号驱动IO:内核将数据准备好的时候,使用SIGIO信号通知应用程序进行IO操作.
IO多路转接:
IO多路转接:虽然从流程图上看起来和阻塞IO类似.实际上最核心在于IO多路转接能够同时等待多个文件描述符的就绪状态.
前四种IO模型我们统称同步IO!!!
异步IO
异步IO:由内核在数据拷贝完成时,通知应用程序(而信号驱动是告诉应用程序何时可以开始拷贝数据).
小结:
- 任何IO过程,都包含两个步骤.第一是等待,第二是拷贝.而且在实际的应用场景中,等待消耗的时间往往都远远高于拷贝的时间.让IO更高效,最核心的办法就是让等待的时间尽量少.
二、高级IO
在这里,需要强调几个概念
同步通信和异步通信
同步通信和异步通信(synchronous communication/asynchronous communication)关注的是消息通信机制.
- 所谓同步,就是在发出一个调用时,在没有得到结果之前,该调用就不返回.但是一旦调用返回,就得到返回值了;换句话说,就是由调用者主动等待这个调用的结果;
- 异步则是相反,调用在发出之后,这个调用就直接返回了,所以没有返回结果;换句话说,当一个异步过程调用发出后,调用者不会立刻得到结果;而是在调用后发出,被调用者通过状态、通知来通知调用者,或是通过回调函数处理这个调用.
另外,在多进程和多线程的时候,也提到同步和互斥.这里的同步通信和进程间的同步是完全不相干的概念.
- 进程/线程同步也是进程/线程之间直接的制约关系.
- 是为完成某种任务而建立的两个或多个线程,这个线程需要在某些位置上协调他们的工作次序而等待、传递信息所产生的制约关系.尤其是访问临界资源的时候.
所以以后在看到同步这个词,一定要先搞清楚大背景是什么.这个同步,是同步通信异步通信的同步还是同步与互斥的同步.
阻塞 VS 非阻塞
阻塞和非阻塞关注的是程序在等待调用结果(消息,返回值)时的状态.
- 阻塞调用是指调用结果返回之前,当前线程会被挂起,调用线程只有在得到结果之后才会返回.
- 非阻塞调用值在不能立刻得到结果之前,该调用不会阻塞当前线程.
其他高级IO
非阻塞IO,记录锁,系统V流机制,IO多路转接(页脚IO多路复用),readv和writev函数以及存储映射IO(mmap),这些统称为高级IO.
接下来重点讨论的是IO多路转接.
三、非阻塞IO
fcntl
一个文件描述符,默认都是阻塞IO.
函数原型如下:
#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );
传入的cmd的值不同,后面追加的参数也不相同.
fcntl函数有5中功能:
- 复制一个现有的描述符(cmd = F_DUPFD).
- 获得/设置文件描述符标记(cmd = D_GETFD或F_SETFD).
- 获得/设置文件状态标记(cmd = F_GETFL或F_SETFL).
- 获得/设置异步IO所有权(cmd = F_GETOWN或F_SETOWN).
- 获得/设置记录锁(cmd = F_GETLK,S_SETLK或F_SETLKW).
在这里只使用了第三种功能,获取/设置文件状态标记.就可以将一个文件描述符设置为非阻塞.
#include"util.hpp"
#include<string>
int main()
// 0号描述符
while(true)
string s;
cin>>s; // 0
cout<<"刚刚获取的内容是 # "<<s<<endl;
return 0;
运行该程序就会默认阻塞在这里等待用户的输入.
实现函数SetNoBlock
基于fcntl,实现一个SetNoBlock函数,将文件描述符设置为非阻塞.
#ifndef _UTTL_HPP_
#define _UTTL_HPP_
#include<iostream>
#include<unistd.h>
#include<fcntl.h>
using namespace std;
namespace Util
bool SetNonBlock(int sock)
int flag = fcntl(sock,F_GETFL);
if(flag == -1)
return false;
int n = fcntl(sock,F_SETFL, flag | O_NONBLOCK);
if(n == -1)
return false;
return true;
#endif
#include"util.hpp"
#include<string>
int main()
Util::SetNonBlock(0);
// 0号描述符
char buffer[1024];
while(true)
buffer[0] = 0;
scanf("%s",buffer);
cout<<"刚刚获取的内容是 # "<<buffer<<endl;
sleep(1);
return 0;
- 使用F_GETFL将当前的文件描述符的属性取出来(这是一个位图).
- 然后在使用F_SET_FL将文件描述符设置回去.设置回去的同时,加上一个O_NONBLOCK参数.
此时就是非阻塞了!!!
总结
(本章完!)
IO基础之缓冲流的详解
处理流/包装流(相对于节点流更高级):1、隐藏了底层的节点流的差异,并对外提供了更方便的输入/输出功能,让我们只关心高级流的操作;
2、使用处理流包装节点流,程序直接操作处理流,让节点流与底层的设备做IO操作;
3、只需要关闭处理流即可。
包装流如何区分:写代码的时候,发现创建对象的时候,需要传递另一个流对象。
new 包装流(流对象);
什么是缓冲流:
是一个包装流,目的起缓冲作用:
BufferdInputStream:字节缓冲输入流
BufferdOutputStream:字节缓冲输出流
BufferdReader:字符缓冲输入流
BufferdWriter:字符缓冲输出流
缓冲流的目的:
操作流的时候,习惯定义一个byte/char数组。
int read():每次都从磁盘文件中读取一个字节,直接操作磁盘文件性能极低。
解决方法:定义一个数组作为缓冲区
byte[] buffer = new byte[1024];//该数组其实就是一个缓冲区
一次性从磁盘文件中读取1024个字节,如此一来,操作磁盘文件的次数少了--->性能得以提升。
缓冲流所提供的缓冲区大小是8192(1024*8)(这个可以查源码)
字节缓冲流:
/**
* Created by Layne_Yao on 2017-7-28 上午11:01:52.
* CSDN:http://blog.csdn.net/Jsagacity
*/
public class BufferedStreamDemo
public static void main(String[] args) throws Exception
//字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("stream.txt",true));
bos.write("i am BufferedStream!!!".getBytes());
bos.close();
//字节缓冲输入流
BufferedInputStream bin = new BufferedInputStream(new FileInputStream("stream.txt"));
byte[] buffer = new byte[1024];
int len = -1;
while((len = bin.read(buffer))!=-1)
System.out.println(new String(buffer,0,len));
bin.close();
字符缓冲流:
/**
* Created by Layne_Yao on 2017-7-28 上午11:16:53.
* CSDN:http://blog.csdn.net/Jsagacity
*/
public class BufferedReaderWriterDemo
public static void main(String[] args) throws Exception
// 字符缓冲输出流
BufferedWriter out = new BufferedWriter(new FileWriter("file/stream.txt"));
out.write("处理流/包装流(相对于节点流更高级):");
out.newLine();
out.write("1、隐藏了底层的节点流的差异,并对外提供了更方便的输入/输出功能,让我们只关心高级流的操作;");
out.newLine();
out.write("2、使用处理流包装节点流,程序直接操作处理流,让节点流与底层的设备做IO操作; ");
out.newLine();
out.write("3、只需要关闭处理流即可。");
out.newLine();
out.write("包装流如何区分:写代码的时候,发现创建对象的时候,需要传递另一个流对象。");
out.newLine();
out.write("new 包装流(流对象);");
out.close();
// 字符缓冲输入流
BufferedReader in = new BufferedReader(new FileReader("file/stream.txt"));
// // 传统方案:
// char[] buffer = new char[1024];
// int len = -1;
// while ((len = in.read(buffer)) != -1)
// System.out.println(new String(buffer, 0, len));
//
// in.close();
String line =null;//表示读取的行
while((line = in.readLine())!=null)
System.out.println(line);
in.close();
操作字节和字符都习惯使用缓冲流给包装起来,提高IO性能/效率。
程序运行效率的对比:(准备一个10M左右的mp4文件)
/**
* Created by Layne_Yao on 2017-7-28 下午1:50:48.
* CSDN:http://blog.csdn.net/Jsagacity
*/
// 节点流和缓冲流性能对比
public class NodeStreamVSBufferedStreamDemo
public static void main(String[] args) throws Exception
File srcFile = new File("file/1蓝牙的功能与本地蓝牙.mp4");
File destFile = new File("target/本地蓝牙.mp4");
test4(srcFile, destFile);
// 使用节点流,从磁盘文件中一个字节一个字节的读写:89251ms
private static void test1(File srcFile, File destFile) throws Exception
long begin = System.currentTimeMillis();
InputStream in = new FileInputStream(srcFile);
OutputStream out = new FileOutputStream(destFile);
int len = -1;
while ((len = in.read()) != -1)
out.write(len);
out.close();
in.close();
System.out.println(System.currentTimeMillis() - begin);
// 使用缓冲流,从内存文件中一个字节一个字节的读写:595ms
private static void test2(File srcFile, File destFile) throws Exception
long begin = System.currentTimeMillis();
InputStream in = new BufferedInputStream(new FileInputStream(srcFile));
OutputStream out = new BufferedOutputStream(new FileOutputStream(
destFile));
int len = -1;
while ((len = in.read()) != -1)
out.write(len);
out.close();
in.close();
System.out.println(System.currentTimeMillis() - begin);
// 使用节点流,从磁盘文件中每次读写1024个字节:161ms
private static void test3(File srcFile, File destFile) throws Exception
long begin = System.currentTimeMillis();
InputStream in = new FileInputStream(srcFile);
OutputStream out = new FileOutputStream(destFile);
byte[] buffer = new byte[1024];
int len = -1;
while ((len = in.read(buffer)) != -1)
out.write(buffer,0,len);
out.close();
in.close();
System.out.println(System.currentTimeMillis() - begin);
// 使用缓冲流,从内存文件中每次读写1024个字节:54ms(最常用的方式)
private static void test4(File srcFile, File destFile) throws Exception
long begin = System.currentTimeMillis();
InputStream in = new BufferedInputStream(new FileInputStream(srcFile));
OutputStream out = new BufferedOutputStream(new FileOutputStream(
destFile));
byte[] buffer = new byte[1024];
int len = -1;
while ((len = in.read(buffer)) != -1)
out.write(buffer,0,len);
out.close();
in.close();
System.out.println(System.currentTimeMillis() - begin);
以上是关于详解--高级IO的主要内容,如果未能解决你的问题,请参考以下文章
自动驾驶感知算法实战6——目标分类详解(ResNetVGGGoogLeNet等)