面试官:聊聊BIO、NIO、AIO
我:emmm......我只知道IO
虽然IO流是Java基础部分学习的内容,而且用起来也是比较简单的;但是,如果让你系统的说一下IO,还是比较困难的。这篇博客通过各方面对比,来聊一聊这几个IO。
在学习Java的IO流之前,我们必须要知道一些关键词。
同步与异步:(关注的是消息通信机制)
同步(Synchronous):代码按顺序执行,执行到同步方法时,不管方法有没有返回值都要执行完,才能往下执行。
异步(Asynchronous):代码按顺序执行,执行到异步方法时,会把该异步方法交给其他线程(返回结果是什么,原线程不管),原线程继续向下执行。
阻塞与非阻塞:(关注的是程序等待时的状态)
IO是用来实现输入和输出操作的,其下可以分为BIO、NIO、AIO
I/O | 名称 | 适用领域 | 描述 |
BIO (Blocking I/O) | 同步阻塞I/O模型 | 低负载、低并发 | 数据的读取写入必须阻塞在一个线程内等待其完成 |
NIO (New I/O) | 同步非阻塞的I/O模型 | 高负载、高并发 | Java 1.4 中引入,对应 java.nio 包 |
AIO (Asynchronous I/O) | 异步非阻塞的IO模型 | 应用还不是很广泛 | Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型 |
JAVA IO流共涉及40多个类,这些类看上去很杂乱,但实际上很有规则,而且彼此之间存在非常紧密的联系, Java IO流的40多个类都是从如下4个抽象类基类中派生出来的。
InputStream、OutputStream、Reader、Writer
按操作数据分为:字节流(InputStream、OutputStream)和字符流(Reader、Writer)
按流向分:输入流(Reader、InputStream)和输出流(Writer、OutputStream)
这么多类,属实有点头痛,我们这里也按功能分类一下。
分类 | 字节输入流 | 字节输出流 | 字符输入流 | 字符输入流 |
---|---|---|---|---|
抽象基类 | InputStream | OutputStream | Reader | Writer |
访问文件 | FileInputStream | FileOutStream | FilerReader | FileWriter |
访问数组 | ByteArrayInputSteam | ByteArrayOutStream | CharArrayReader | CharArrayWriter |
访问管道 | PipeInputStream | PipeOutputStream | PipeReader | PipeWriter |
访问字符串 | StringReader | StringWriter | ||
缓冲流 | BufferedInputSteam | BufferedOutputStream | BufferReader | BuffereWriter |
转换流 | InputStreamReader | OutputStreamWriter | ||
对象流 | ObjectInputStream | ObjectOutputStream | ||
抽象基类 | FilterInputStream | FilterOutputStream | FilterReader | FilterWriter |
打印流 | PrintStream | PrintWriter | ||
推回输入流 | PushbackInputStream | PushBackReader | ||
特殊流 | DataInputStream | DataOutputStream |
io包下的类还是非常多的,我们当然不用全部都记住,只需要知道几个常用类即可,不管是应付工作还是面试都足够。
1)文件输入流FileInputStream/FileReader
InputStream和Reader都是抽象类,本身不能创建实例,但它们分别有一个用于读取文件的输入流:FileInputStream和FileReader,它们都是节点流——会直接和指定文件关联。下面程序示范使用FileInputStream和FileReader。
使用FileInputStream读取文件:
public class MyClass {
public static void main(String[] args)throws IOException{
FileInputStream fis=null;
try {
//创建字节输入流
fis=new FileInputStream("C:\\Test.txt");
//创建一个长度为1024的竹筒
byte[] b=new byte[1024];
//用于保存的实际字节数
int hasRead=0;
//使用循环来重复取水的过程
while((hasRead=fis.read(b))>0){
//取出竹筒中的水滴(字节),将字节数组转换成字符串进行输出
System.out.print(new String(b,0,hasRead));
}
}catch (IOException e){
e.printStackTrace();
}finally {
fis.close();
}
}
}
注:上面程序最后使用了fis.close()来关闭该文件的输入流,与JDBC编程一样,程序里面打开的文件IO资源不属于内存的资源,垃圾回收机制无法回收该资源,所以应该显示的关闭打开的IO资源。Java 7改写了所有的IO资源类,它们都实现了AntoCloseable接口,因此都可以通过自动关闭资源的try语句来关闭这些Io流。
使用FileReader读取文件:
public static void main(String[] args)throws IOException{
FileReader fr=null;
try {
//创建字节输入流
fr=new FileReader("C:\\Test.txt");
//创建一个长度为1024的竹筒
char[] b=new char[1024];
//用于保存的实际字节数
int hasRead=0;
//使用循环来重复取水的过程
while((hasRead=fr.read(b))>0){
//取出竹筒中的水滴(字节),将字节数组转换成字符串进行输出
System.out.print(new String(b,0,hasRead));
}
}catch (IOException e){
e.printStackTrace();
}finally {
fr.close();
}
}
}
可以看出使用FileInputStream和FileReader进行文件的读写并没有什么区别,只是操作单元不同而且。
2)文件输出流FileOutputStream/FileWriter
FileOutputStream/FileWriter是Io中的文件输出流,下面介绍这两个类的用法。
FileOutputStream的用法:
public class FileOutputStreamTest {
public static void main(String[] args)throws IOException {
FileInputStream fis=null;
FileOutputStream fos=null;
try {
//创建字节输入流
fis=new FileInputStream("C:\\Test.txt");
//创建字节输出流
fos=new FileOutputStream("C:\\newTest.txt");
byte[] b=new byte[1024];
int hasRead=0;
//循环从输入流中取出数据
while((hasRead=fis.read(b))>0){
//每读取一次,即写入文件输入流,读了多少,就写多少。
fos.write(b,0,hasRead);
}
}catch (IOException e){
e.printStackTrace();
}finally {
fis.close();
fos.close();
}
}
}
运行程序可以看到输出流指定的目录下多了一个文件:newTest.txt, 该文件的内容和Test.txt文件的内容完全相同。FileWriter的使用方式和FileOutputStream基本类似,这里就带过。
注: 使用java的io流执行输出时,不要忘记关闭输出流,关闭输出流除了可以保证流的物理资源被回收之外,还可以将输出流缓冲区中的数据flush到物理节点中(因为在执行close()方法之前,自动执行输出流的flush()方法)。java很多输出流默认都提供了缓存功能,其实我们没有必要刻意去记忆哪些流有缓存功能,哪些流没有,只有正常关闭所有的输出流即可保证程序正常。
3)缓冲流
(BufferedInputStream/BufferedReader,BufferedOutputStream/BufferedWriter):
下面介绍字节缓存流的用法(字符缓存流的用法和字节缓存流一致就不介绍了):
public class BufferedStreamTest {
public static void main(String[] args)throws IOException {
FileInputStream fis=null;
FileOutputStream fos=null;
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
try {
//创建字节输入流
fis=new FileInputStream("C:\\Test.txt");
//创建字节输出流
fos=new FileOutputStream("C:\\newTest.txt");
//创建字节缓存输入流
bis=new BufferedInputStream(fis);
//创建字节缓存输出流
bos=new BufferedOutputStream(fos);
byte[] b=new byte[1024];
int hasRead=0;
//循环从缓存流中读取数据
while((hasRead=bis.read(b))>0){
//向缓存流中写入数据,读取多少写入多少
bos.write(b,0,hasRead);
}
}catch (IOException e){
e.printStackTrace();
}finally {
bis.close();
bos.close();
}
}
}
可以看到使用字节缓存流读取和写入数据的方式和文件流(FileInputStream,FileOutputStream)并没有什么不同,只是把处理流套接到文件流上进行读写。
上面代码中我们使用了缓存流和文件流,但是我们只关闭了缓存流。这个需要注意一下,当我们使用处理流套接到节点流上的使用的时候,只需要关闭最上层的处理就可以了。java会自动帮我们关闭下层的节点流。
4)转换流(InputStreamReader/OutputStreamWriter):
下面以获取键盘输入为例来介绍转换流的用法。java使用System.in代表输入。即键盘输入,但这个标准输入流是InputStream类的实例,使用不太方便,而且键盘输入内容都是文本内容,所以可以使用InputStreamReader将其包装成BufferedReader,利用BufferedReader的readLine()方法可以一次读取一行内容,如下代码所示:
public class InputStreamReaderTest {
public static void main(String[] args)throws IOException {
try {
// 将System.in对象转化为Reader对象
InputStreamReader reader=new InputStreamReader(System.in);
//将普通的Reader包装成BufferedReader
BufferedReader bufferedReader=new BufferedReader(reader);
String buffer=null;
while ((buffer=bufferedReader.readLine())!=null){
// 如果读取到的字符串为“exit”,则程序退出
if(buffer.equals("exit")){
System.exit(1);
}
//打印读取的内容
System.out.print("输入内容:"+buffer);
}
}catch (IOException e){
e.printStackTrace();
}finally {
}
}
}
上面程序将System.in包装成BufferedReader,BufferedReader流具有缓存功能,它可以一次读取一行文本——以换行符为标志,如果它没有读到换行符,则程序堵塞。等到读到换行符为止。运行上面程序可以发现这个特征,当我们在控制台执行输入时,只有按下回车键,程序才会打印出刚刚输入的内容。
5)对象流(ObjectInputStream/ObjectOutputStream):
写入对象:
public static void writeObject(){
OutputStream outputStream=null;
BufferedOutputStream buf=null;
ObjectOutputStream obj=null;
try {
//序列化文件輸出流
outputStream=new FileOutputStream("C:\\myfile.tmp");
//构建缓冲流
buf=new BufferedOutputStream(outputStream);
//构建字符输出的对象流
obj=new ObjectOutputStream(buf);
//序列化数据写入
obj.writeObject(new Person("A", 21));//Person对象
//关闭流
obj.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
读取对象
public static void readObject() throws IOException {
try {
InputStream inputStream=new FileInputStream("C:\\myfile.tmp");
//构建缓冲流
BufferedInputStream buf=new BufferedInputStream(inputStream);
//构建字符输入的对象流
ObjectInputStream obj=new ObjectInputStream(buf);
Person tempPerson=(Person)obj.readObject();
System.out.println("Person对象为:"+tempPerson);
//关闭流
obj.close();
buf.close();
inputStream.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
背景
从JDk1.4开始,java提供了一系列改进的输入和输出处理的新功能,这些功能被统称为New IO或者Non Blocking IO(NIO)。新增了许多用于处理输入和输出的类,这些类都被放在java.nio包及其子包下;并且对原io的很多类都以NIO为基础进行了改写,新增了满足NIO的功能。
JDk1.4使用NIO改写了传统Io后,传统Io的读写速度和NIO差不了太多。
主要区别
Java中I/O相关的两个包是java.io和java.nio,它们的最重要的区别就是java.io里面的类是面向流的(stream oriented),java.nio里面的类是面向缓存的(buffer oriented)。
面向流意味着一次读取一个或者一些字节,然后处理这些字节,在读取和处理这些字节时当前线程是阻塞的,不能干其他事情。面向缓存意味着把一些字节读到缓存里面,选择了读取的字节之后当前线程可以去做其他事情,以后再去处理缓存里面的字节也可以,也就是线程非阻塞。
IO | NIO |
面向流(Stream Oriented) | 面向缓冲区(Buffer Oriented) |
阻塞IO(Blocking IO) | 非阻塞IO(Non Blocking IO) |
(无) | 选择器(Selectors) |
缓冲区(火车),负责数据的存储
通道(火车道),负责数据的连接
选择器
缓冲区(Buffer):
Buffer下有四个重要的属性
private int mark = -1; 标记,表示当前position的位置。可以通过reset()恢复到mark的位置
private int position = 0; 位置,表示缓冲区中正在操作数据的位置
private int limit; 界限,表示缓冲区中可以操作数据的大小。(limit 后面的数据不能进行读写
private int capacity; 容量,表示缓冲区中最大存储数据的容量。一旦声明不能改变
0 <= mark <= position <= limit <= capacity
public void test01(){
String str = "abcde";
// 分配缓冲区大小
ByteBuffer buffer = ByteBuffer.allocate(1024);
System.out.println("---------allocate()-----------");
System.out.println(buffer.position());
System.out.println(buffer.limit());
System.out.println(buffer.capacity());
//2、利用put()方法,存入数据到缓冲区
buffer.put(str.getBytes());
System.out.println("---------put()-----------");
System.out.println(buffer.position());
System.out.println(buffer.limit());
System.out.println(buffer.capacity());
//3、使用flip()方法,切换到读模式
buffer.flip();
System.out.println("---------flip()-----------");
System.out.println(buffer.position());
System.out.println(buffer.limit());
System.out.println(buffer.capacity());
//4、利用get()方法读取缓冲区中的数据
byte[] dst = new byte[buffer.limit()];
buffer.get(dst);
System.out.println(new String(dst,0,dst.length));
System.out.println("------------get()---------------");
System.out.println(buffer.position());
System.out.println(buffer.limit());
System.out.println(buffer.capacity());
//5、rewind(),可重复读数据
buffer.rewind();
System.out.println("------------rewind()---------------");
System.out.println(buffer.position());
System.out.println(buffer.limit());
System.out.println(buffer.capacity());
//6、clear(),清空缓冲区。但是缓冲区中的数据依然存在,但是出于“被遗忘”状态
buffer.clear();
System.out.println("------------clear()---------------");
System.out.println(buffer.position());
System.out.println(buffer.limit());
System.out.println(buffer.capacity());
}
public void test02(){
String str = "abcde";
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put(str.getBytes());
buffer.flip();
byte[] dst = new byte[buffer.limit()];
buffer.get(dst,0,2);
System.out.println(buffer.position());
buffer.mark();
buffer.get(dst,2,2);
System.out.println(buffer.position());
// reset() ,恢复到mark的位置
buffer.reset();
System.out.println(buffer.position());
//判断缓冲区中是否还有数据
if(buffer.hasRemaining()){
//输出缓冲区中剩余数据的数量
System.out.println(buffer.remaining());
}
}
面试题:
直接缓冲区与非直接缓冲区:
直接缓冲区,效率虽然高,但是不稳定
文章浏览阅读1.6k次。安装配置gi、安装数据库软件、dbca建库见下:http://blog.csdn.net/kadwf123/article/details/784299611、检查集群节点及状态:[root@rac2 ~]# olsnodes -srac1 Activerac2 Activerac3 Activerac4 Active[root@rac2 ~]_12c查看crs状态
文章浏览阅读1.3w次,点赞45次,收藏99次。我个人用的是anaconda3的一个python集成环境,自带jupyter notebook,但在我打开jupyter notebook界面后,却找不到对应的虚拟环境,原来是jupyter notebook只是通用于下载anaconda时自带的环境,其他环境要想使用必须手动下载一些库:1.首先进入到自己创建的虚拟环境(pytorch是虚拟环境的名字)activate pytorch2.在该环境下下载这个库conda install ipykernelconda install nb__jupyter没有pytorch环境
文章浏览阅读5.2k次,点赞19次,收藏28次。选择scoop纯属意外,也是无奈,因为电脑用户被锁了管理员权限,所有exe安装程序都无法安装,只可以用绿色软件,最后被我发现scoop,省去了到处下载XXX绿色版的烦恼,当然scoop里需要管理员权限的软件也跟我无缘了(譬如everything)。推荐添加dorado这个bucket镜像,里面很多中文软件,但是部分国外的软件下载地址在github,可能无法下载。以上两个是官方bucket的国内镜像,所有软件建议优先从这里下载。上面可以看到很多bucket以及软件数。如果官网登陆不了可以试一下以下方式。_scoop-cn
文章浏览阅读4.5k次,点赞2次,收藏3次。首先要有一个color-picker组件 <el-color-picker v-model="headcolor"></el-color-picker>在data里面data() { return {headcolor: ’ #278add ’ //这里可以选择一个默认的颜色} }然后在你想要改变颜色的地方用v-bind绑定就好了,例如:这里的:sty..._vue el-color-picker
文章浏览阅读640次。基于芯片日益增长的问题,所以内核开发者们引入了新的方法,就是在内核中只保留函数,而数据则不包含,由用户(应用程序员)自己把数据按照规定的格式编写,并放在约定的地方,为了不占用过多的内存,还要求数据以根精简的方式编写。boot启动时,传参给内核,告诉内核设备树文件和kernel的位置,内核启动时根据地址去找到设备树文件,再利用专用的编译器去反编译dtb文件,将dtb还原成数据结构,以供驱动的函数去调用。firmware是三星的一个固件的设备信息,因为找不到固件,所以内核启动不成功。_exynos 4412 刷机
文章浏览阅读2w次,点赞24次,收藏42次。Linux系统配置jdkLinux学习教程,Linux入门教程(超详细)_linux配置jdk
文章浏览阅读3.3k次,点赞5次,收藏19次。xlabel('\delta');ylabel('AUC');具体符号的对照表参照下图:_matlab微米怎么输入
文章浏览阅读119次。顺序读写指的是按照文件中数据的顺序进行读取或写入。对于文本文件,可以使用fgets、fputs、fscanf、fprintf等函数进行顺序读写。在C语言中,对文件的操作通常涉及文件的打开、读写以及关闭。文件的打开使用fopen函数,而关闭则使用fclose函数。在C语言中,可以使用fread和fwrite函数进行二进制读写。 Biaoge 于2024-03-09 23:51发布 阅读量:7 ️文章类型:【 C语言程序设计 】在C语言中,用于打开文件的函数是____,用于关闭文件的函数是____。
文章浏览阅读3.4k次,点赞2次,收藏13次。跟随鼠标移动的粒子以grid(SOP)为partical(SOP)的资源模板,调整后连接【Geo组合+point spirit(MAT)】,在连接【feedback组合】适当调整。影响粒子动态的节点【metaball(SOP)+force(SOP)】添加mouse in(CHOP)鼠标位置到metaball的坐标,实现鼠标影响。..._touchdesigner怎么让一个模型跟着鼠标移动
文章浏览阅读178次。项目运行环境配置:Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX(Webstorm也行)+ Eclispe(IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持)。项目技术:Springboot + mybatis + Maven +mysql5.7或8.0+html+css+js等等组成,B/S模式 + Maven管理等等。环境需要1.运行环境:最好是java jdk 1.8,我们在这个平台上运行的。其他版本理论上也可以。_基于java技术的停车场管理系统实现与设计
文章浏览阅读3.5k次。前言对于MediaPlayer播放器的源码分析内容相对来说比较多,会从Java-&amp;gt;Jni-&amp;gt;C/C++慢慢分析,后面会慢慢更新。另外,博客只作为自己学习记录的一种方式,对于其他的不过多的评论。MediaPlayerDemopublic class MainActivity extends AppCompatActivity implements SurfaceHolder.Cal..._android多媒体播放源码分析 时序图
文章浏览阅读2.4k次,点赞41次,收藏13次。java 数据结构与算法 ——快速排序法_快速排序法