Java输入输出三兄弟大比拼：IO、NIO、AIO对比分析

最新推荐文章于 2024-04-29 22:54:22 发布
最新推荐文章于 2024-04-29 22:54:22 发布
阅读量521 收藏 4
点赞数 1
文章标签： java nio servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50180963/article/details/130101657
版权

1、Java I/O发展史                

Java IO（Input/Output）是Java语言中用于读写数据的API，它提供了一系列类和接口，用于读取和写入各种类型的数据。下面是Java IO发展史的简要介绍：

  1. JDK 1.0（1996年） 最初的Java IO只支持字节流（InputStream、OutputStream）和字符流（Reader、Writer）两种，基于阻塞式IO（BIO）模型。
  2. JDK 1.1（1997年） JDK 1.1引入了NIO（New IO）包，支持了缓存区（Buffer）、通道（Channel）等概念，提供了更高效的IO操作方式，可以实现非阻塞式IO（NIO）模式。
  3. JDK 1.4（2002年） JDK 1.4增加了NIO.2 API，也称为Java NIO with buffers，提供了更   强大的文件处理功能和更高效的IO操作。
  4. JDK 7（2011年） JDK 7引入了NIO.2的改进版——NIO.2 with Completion Ports，也称为AIO（Asynchronous IO），支持异步IO方式，在处理大量并发请求时具有优势。

以下是三者之间的区别：

  1. 阻塞IO（BIO） BIO是Java最初的IO模型，它采用阻塞方式进行数据读写操作。即当一个线程在执行IO操作时，若没有数据可读，则该线程会一直阻塞等待，直到有数据可读或者超时。BIO适合处理连接数比较小且固定的场景，但并发能力不足。

  2. 非阻塞IO（NIO） NIO是Java 1.4引入的新的IO模型，它采用了多路复用器（Selector）机制，通过少量线程同时管理多个通道，实现了单线程同时处理多个请求的效果。NIO具有高并发性、高吞吐量和更高的可靠性，适合处理连接数多且连接时间较短的场景。

  3. 异步IO（AIO） AIO是Java 1.7开始支持的IO模型，它采用事件驱动的方式进行数据读写操作，当数据准备好后，在回调函数中进行处理。与NIO不同，AIO的读写操作是异步的，不需要通过轮询方式去检查数据是否准备好。AIO适合处理连接数多、连接时间长且有较多读写操作的场景。

2、Java IO

2.1 简介

在Java编程中，IO（Input/Output）操作是非常常见的操作，它涉及到文件读写、网络通信等方面。Java提供了各种类来支持这些操作。本文将从IO的基础知识讲起，逐步深入，介绍Java IO的各个方面。

2.2 基础概念

2.2.1 输入流和输出流

在Java中，输入流（InputStream）和输出流（OutputStream）是两个重要的抽象类。输入流表示输入数据的来源，可以是文件、网络连接、管道等；输出流表示输出数据的去向，可以是文件、网络连接、管道等。输入流和输出流的使用方式是相似的，都是通过创建流对象，然后使用相应的方法接口进行读写操作。

2.2.2 字节流和字符流

Java中的IO操作还可以分为字节流和字符流两种。字节流以字节（byte）为单位进行操作，适用于处理二进制数据，例如图像、音频等；而字符流以字符（char）为单位进行操作，适用于处理文本数据，例如文本文件等。Java中，字节流主要由InputStream和OutputStream类以及其子类实现，而字符流主要由Reader和Writer类以及其子类实现。

2.2.3 缓冲流

在进行IO操作时，我们可能需要经常进行读写操作，而频繁的读写可能会导致性能问题。为了解决这个问题，Java提供了缓冲流（Buffered Stream）来提高IO操作的效率。缓冲流可以通过内部缓存区域来减少对底层资源的访问次数，从而提高数据读写的效率。

2.3 Java IO的使用

2.3.1 文件读写

Java中的文件读写是开发中最常见的操作之一。下面是一个读取文件内容并输出的示例：

    try (FileInputStream fis = new FileInputStream("test.txt");
         InputStreamReader isr = new InputStreamReader(fis);
         BufferedReader br = new BufferedReader(isr)) {
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
复制代码

在这个示例中，我们使用了FileInputStream、InputStreamReader和BufferedReader等类来完成文件的读取。首先，我们通过FileInputStream类创建了一个输入流对象，并指定了要读取的文件名称；然后通过InputStreamReader将字节流转换为字符流，再通过BufferedReader实现按行读取文本内容。

类似地，在Java中进行文件写操作也非常简单，下面是一个写入文件的示例：

try (FileOutputStream fos = new FileOutputStream("test.txt");
     OutputStreamWriter osw = new OutputStreamWriter(fos);
     BufferedWriter bw = new BufferedWriter(osw)) {
    bw.write("Hello, world!");
} catch (IOException e) {
    e.printStackTrace();
}
复制代码

在这个示例中，我们使用了FileOutputStream、OutputStreamWriter和BufferedWriter等类来完成文件的写入。首先，我们通过FileOutputStream类创建了一个输出流对象，并指定了要写入的文件名称；然后通过OutputStreamWriter将字节流转换为字符流，再通过BufferedWriter实现按行写入文本内容。

3、Java NIO

3.1 简介

Java NIO（New IO）是Java SE 1.4引入的一个新的IO API，它提供了比传统IO更高效、更灵活的IO操作。与传统IO相比，Java NIO的优势在于它支持非阻塞IO和选择器（Selector）等特性，能够更好地支持高并发、高吞吐量的应用场景。本文将从NIO的基础知识讲起，逐步深入，介绍Java NIO的各个方面。

3.2 核心概念

3.2.1 选择器（Selector）

选择器是Java NIO中的一个重要组件，它可以用于同时监控多个通道的读写事件，并在有事件发生时立即做出响应。选择器可以实现单线程监听多个通道的效果，从而提高系统吞吐量和运行效率。

3.2.2 通道（Channel）

通道是一个用于读写数据的对象，类似于Java IO中的流（Stream）。与流不同的是，通道可以进行非阻塞式的读写操作，并且可以同时进行读写操作。通道分为两种类型：FileChannel和SocketChannel，分别用于文件和网络

通信。

3.2.3 缓冲区（Buffer）

在Java NIO中，所有数据都是通过缓冲区对象进行传输的。缓冲区是一段连续的内存块，可以保存需要读写的数据。缓冲区对象包含了一些状态变量，例如容量（capacity）、限制（limit）、位置（position）等，用于控制数据的读写。

3.3 Java NIO的使用

3.3.1 缓冲区操作

Java NIO中的缓冲区操作主要包括数据读取和数据写入两种操作。下面是一个简单的缓冲区读取示例：

ByteBuffer buffer = ByteBuffer.allocate(1024);
try (FileChannel channel = new FileInputStream("test.txt").getChannel()) {
    int bytesRead = channel.read(buffer);
    while (bytesRead != -1) {
        buffer.flip();
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
        buffer.clear();
        bytesRead = channel.read(buffer);
    }
} catch (IOException e) {
    e.printStackTrace();
}
复制代码

在这个示例中，我们使用了FileChannel类和ByteBuffer类来完成文件的读取。首先，我们通过FileInputStream类创建了一个输入流对象，然后通过getChannel()方法获取到对应的通道对象；接着，我们创建了一个容量为1024字节的ByteBuffer对象，并调用read()方法从通道中读取数据，将读取到的数据保存在缓冲区中。读取完成后，我们通过flip()方法将缓冲区切换为读模式，并使用hasRemaining()和get()方法逐个读取数据；最后通过clear()方法清空缓冲区，准备进行下一轮读取。

Java NIO中的缓冲区写操作也非常类似，下面是一个简单的缓冲区写入示例：

ByteBuffer buffer = ByteBuffer.wrap("Hello, world!".getBytes());
try (FileChannel channel = new FileOutputStream("test.txt").getChannel()) {
    channel.write(buffer);
} catch (IOException e) {
    e.printStackTrace();
}
复制代码

在这个示例中，我们使用了FileChannel类和ByteBuffer类来完成文件的写入。首先，我们通过ByteBuffer.wrap()方法将字符串转换为ByteBuffer对象；然后，我们通过FileOutputStream类创建了一个输出流对象，再通过getChannel()方法获取到对应的通道对象；接着，我们调用write()方法将缓冲区中的数据写入通道中，完成文件写入操作。

3.3.2 通道操作

Java NIO中的通道（Channel）是用于进行数据传输的对象。通道可以连接到源或目标节点，用于读取和写入数据。与传统的Java IO不同，NIO中的通道可以实现非阻塞式地读写数据，从而提高了应用程序的性能和并发处理能力。

要使用通道进行读写操作，首先需要打开通道。Java NIO中有多种类型的通道，每种通道都提供了自己的打开方式。例如，要打开一个文件通道，可以通过FileInputStream或FileOutputStream对象获取对应的FileChannel对象，如下所示：

    FileChannel channel = new FileInputStream("file.txt").getChannel();
复制代码

读取数据 一旦打开了通道，就可以开始读取数据。在NIO中，数据通过缓冲区进行传输。要读取数据，需要将数据存储在缓冲区中，然后从缓冲区中读取数据。以下是一个简单的读取操作示例：

ByteBuffer buffer = ByteBuffer.allocate(1024);
// 从通道中读取数据
int bytesRead = channel.read(buffer);
while (bytesRead != -1) {
    // 切换为读模式
    buffer.flip();
    // 读取缓冲区中的数据
    while (buffer.hasRemaining()) {
        System.out.print((char) buffer.get());
    }
    // 清空缓冲区
    buffer.clear();
    bytesRead = channel.read(buffer);
}
复制代码

在这个示例中，我们首先创建了一个容量为1024字节的ByteBuffer对象，并使用channel.read()方法从文件通道中读取数据。读取到数据后，我们将ByteBuffer切换为读模式，再使用hasRemaining()和get()方法逐个读取缓冲区中的数据。

写入数据 要写入数据，也需要将数据存储在缓冲区中，然后将缓冲区中的数据写入到通道中。以下是一个简单的写入操作示例：

ByteBuffer buffer = ByteBuffer.wrap("Hello, world!".getBytes());
// 将数据写入通道
channel.write(buffer);
复制代码

在这个示例中，我们首先使用ByteBuffer.wrap()方法将字符串转换为ByteBuffer对象，在通过channel.write()方法将ByteBuffer中的数据写入到通道中。

4、Java AIO

Java AIO（Asynchronous IO）是一种基于事件和回调的IO模型，相比Java BIO（Blocking IO）和Java NIO（Non-blocking IO），它具有更高的并发性、更高的吞吐量和更高的可靠性。本文将介绍Java AIO的原理、特点和应用。

4.1 Java AIO的原理

Java AIO采用异步IO方式进行数据读写操作，与Java NIO不同，它不需要通过轮询方式去检查数据是否准备好，而是由操作系统完成。当数据准备好后，操作系统会通知应用程序，并在回调函数中进行处理。

AIO使用了三个核心组件：AsynchronousChannel、CompletionHandler和
AsynchronousServerSocketChannel。其中，AsynchronousChannel是读/写数据的通道，CompletionHandler是I/O操作完成时的回调方法，AsynchronousServerSocketChannel是异步服务器端套接字通道，用于监听客户端的连接请求。

当数据准备好后，操作系统将通知应用程序，并在回调函数中执行I/O操作完成时的回调方法。这样就避免了线程阻塞等待I/O操作完成的情况，从而提高了程序的效率和并发处理能力。

4.2 Java AIO的特点

  1. 高并发性：Java AIO采用异步IO方式进行数据读写操作，可以实现高并发处理能力。
  2. 高吞吐量：Java AIO支持异步读写操作，可以同时处理多个请求，从而提高了数据读写的效率和吞吐量。
  3. 高可靠性：由于Java AIO采用异步IO方式进行数据读写操作，可以避免线程阻塞等待I/O操作完成的情况，从而提高程序的可靠性。
  4. 简单易用：Java AIO提供了简单易用的API，不需要编写复杂的代码就可以实现异步IO操作。

4.3 Java AIO的应用

Java AIO适用于需要大量并发连接，但每个连接却很少有数据交互的场景，例如基于消息的应用程序、远程过程调用（RPC）等。在这些应用场景中，AIO可以大幅度提高程序的性能和并发处理能力，从而满足用户对高吞吐量和低延迟的要求。

另外，Java AIO也可以用于开发高性能的网络服务器，例如聊天室服务器、在线游戏服务器等。由于AIO支持异步读取输入流和输出流，因此可以同时处理多个客户端请求，有效地提高了服务器的并发处理能力。

4.4 总结

Java AIO作为一种高性能、高并发的IO模型，具备很多优点，但也存在着一些缺点，如对小负载的连接，AIO的开销可能会导致性能下降。因此，在实际应用中，需要权衡各种因素，根据实际需求进行评估和选择。

5、相关面试题

1、什么是Java IO和NIO？
Java IO（Input/Output）是Java中传统的输入输出操作，使用字节流和字符流进行数据传输。
Java NIO（New Input/Output）是Java 1.4引入的新的输入输出API，它更加高效地处理数据。
2、什么是阻塞和非阻塞IO？
阻塞IO（Blocking IO）在进行IO操作时会一直等待，直到IO完成，期间无法进行其他操作。
非阻塞IO（Non-blocking IO）在进行IO操作时不会一直等待，而是立即返回结果，如果IO还没有完全完成，则可以继续做其他事情。
3、什么是缓冲区？有哪些类型的缓冲区？
缓冲区是一个用于存储数据的数组，在进行IO操作时需要通过缓冲区来进行读写数据。
Java的缓冲区分为字节缓冲区（ByteBuffer、CharBuffer、ShortBuffer等）和直接缓冲区（DirectByteBuffer、DirectCharBuffer、DirectShortBuffer等）。
4、什么是通道（Channel）？
通道是NIO中用于进行数据传输的对象，它可以连接到源或目标节点，用于读取和写入数据。
5、什么是选择器（Selector）？
选择器是NIO中的一个对象，它可以通过轮询注册在其上的通道来检查它们是否有事件发生（如可读、可写等），从而避免了阻塞式IO中需要等待IO完成的问题。
6、Java IO和NIO之间有什么区别？
Java IO基于流的方式进行数据传输，而NIO基于缓冲区和通道进行数据传输。
Java IO是阻塞式的，而NIO可以采用阻塞或非阻塞模式。
Java IO对线程使用较多，每个IO操作都需要创建一个线程，而NIO可以使用单个线程处理多个IO操作。
7、什么是文件通道（FileChannel）？
文件通道是NIO中用于读取和写入文件的通道，它支持随机访问和内存映射文件等高级功能。
8、Java IO和NIO哪个更快？
在大量小数据量的情况下，Java IO可能更快，因为它可以通过缓冲区一次性读取所有数据。
在大量大块数据的情况下，NIO可能更快，因为它可以使用零拷贝技术直接将数据从磁盘读入内存，减少了数据复制的开销。

Java秦心
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
什么是 NIO？ NIO 和 BIO、AIO 之间的区别是什么？NIO主要用来解决什么问题？面试问题？
weixin_41563161的博客
02-09 6329
什么是 NIO？ NIO 和 BIO、AIO 之间的区别是什么？NIO主要用来解决什么问题？面试问题？ 1 BIO，NIO，AIO都有什么区别，NIO的原理是什么？ BIO BIO：传统的网络通讯模型，就是BIO，同步阻塞IO， 其实就是服务端创建一个ServerSocket， 然后就是客户端用一个Socket去连接服务端的那个ServerSocket， ServerSocket接收到了一个...
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
01-04
IO模型决定了数据的传输方式，Java支持BIO，NIO，AIO三种IO模型。BIO是同步阻塞模型，特点是一对一的客户端与处理线程关系，适用场景是连接数量较小并且固定的，优点是编程简单，但对服务器资源要求高。NIO是同步非阻塞模型，它借助selector能以一对多的方式处理连接，优点是连接数目较多且短的场景下效率较高，如聊天服务器，服务器间通信等，但编程相对复杂。AIO则是异步非阻塞模型，它由操作系统完成后回调通知服务端程序启动线程去处理，适用于连接较多且连接时间较长的应用。这三种模式各有优劣，应根据实际情况和需求选择合适的模型。
简单谈谈BIO,NIO,AIO
一个菜鸡的博客
05-26 834
IO 的操作方式通常分为几种：同步阻塞 BIO、同步非阻塞 NIO、异步非阻塞 AIO。（1）在 JDK1.4 之前，我们建立网络连接的时候采用的是 BIO 模式。（2）Java NIO（New IO 或 Non Blocking IO）是从 Java 1.4 版本开始引入的一个新的IO API，可以替代标准的 Java IO API。NIO 支持面向缓冲区的、基于通道的 IO 操作。NIO 将以更加高效的方式进行文件的读写操作。BIO 与 NIO 一个比较重要的不同是，
NIO（非阻塞I/O）和IO（阻塞I/O）详解
最新发布
Reggie97的博客
04-29 1268
本文详细介绍了阻塞IO和非阻塞NIO，分析NIO中的Channel、Buffer和Selector等内容，附带示例介绍，同时利用代码对比了阻塞IO和非阻塞NIO
IO和NIO
红目香薰
03-12 1006
1、主要区别： io是面向流、阻塞的。 Nio是面向缓存、非阻塞的。 传统IO基于字节流和字符流进行操作。 NIO基于Channel（通道）、Buffer（缓冲区）进行操作，数据从通道读取到缓冲区中，或者从缓冲区读取到通道中。 NIO中使用Selector（选择区）监听多个Channel（通道）事件，因此单个线程可以监听多个数据通道。（比如：连接打开，数据到达） 2、IO 工作流程： 由于Java IO是阻塞的，所以当面对多个流的读写时需要多个线程处理。例如在网络IO中，Server端使用一个线程监
Java IO（NIO、AIO）代码演示
qq_45912388的博客
05-12 394
5、Java IO 5.1、NIO 服务端代码 服务端接受客户端发送的消息输出，并给客户端发送一个消息 //创建多路复用选择器Selector Selector selector=Selector.open(); //创建一个通道对象Channel，监听9001端口 ServerSocketChannel channel = ServerSocketChannel.open().bind(new InetSocketAddress(9001));
Java基础学习总结：NIO之（四）IO总结：BIO、NIO、AIO
Vaingloryss的博客
08-15 443
一、IO 介绍 我们通常所说的 BIO 是相对于 NIO 来说的，BIO 也就是 Java 开始之初推出的 IO 操作模块，BIO 是 BlockingIO 的缩写，顾名思义就是阻塞 IO 的意思。 1.1 BIO、NIO、AIO的区别 BIO 就是传统的 java.io 包，它是基于流模型实现的，交互的方式是同步、阻塞方式，也就是说在读入输入流或者输出流时，在读写动作完成之前，线程会一直阻...
java IO、NIO、AIO详解
weixin_34026484的博客
05-14 192
2019独角兽企业重金招聘Python工程师标准>>> ...
java IO NIO AIO.xmind
05-11
涉及到java io, nio, aio相关知识点，学习过程中的一些总结，持续更新中，xmind 格式
Java 高并发八：NIO和AIO详解
09-01
本文主要介绍Java 高并发NIO和AIO 的知识，这里整理了详细的资料，并详细介绍了 1. 什么是NIO 2. Buffer 3. Channel 4. 网络编程 5. AIO的知识，有需要的小伙伴可以参考下
复习 J2SE基本内容 IO NIO AIO 的区别
01-20
从编程模式上来看AIO相对于NIO的区别在于，NIO需要使用者线程不停的轮询IO对象，来确定是否有数据准备好可以读了，而AIO则是在数据准备好之后，才会通知数据使用者，这样使用者就不需要不停地轮询了。当然AIO的异步...
网络编程-BIO、NIO、AIO的原理与对比
jsx____的博客
09-08 220
什么是同步异步 同步和异步是针对应用程序和内核交互而言的。同步指的是用户进程触发IO操作并等待或者轮询查看IO操作是否就绪。而异步就是指用户进程触发IO操作后便开始干自己的事情，当IO操作完成后，用户会得到IO完成的通知。 举个栗子： 同步：自己去银行取钱。去了银行申请业务，等待叫号，处理完回家 异步：委托他人代为操作，自己可以干别的，等他人取完钱交给自己。 OS操作系统底层支持异步IO操作。 什么是阻塞和非阻塞 阻塞和非阻塞是针对远程访问数据的时候，根据IO操作的就绪状态采取的不同的方式。说白了就是一种
BIO与NIO、AIO的区别
weixin_34301132的博客
12-22 9006
     IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。 一、BIO      在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或...
NIO与传统IO的区别
热门推荐
周宏亮G的日志
06-26 5万+
 传统的socket IO中，需要为每个连接创建一个线程，当并发的连接数量非常巨大时，线程所占用的栈内存和CPU线程切换的开销将非常巨大。使用NIO，不再需要为每个线程创建单独的线程，可以用一个含有限数量线程的线程池，甚至一个线程来为任意数量的连接服务。由于线程数量小于连接数量，所以每个线程进行IO操作时就不能阻塞，如果阻塞的话，有些连接就得不到处理，NIO提供了这种非阻塞的能力。 小
聊聊BIO，NIO和AIO (2)
tianyaleixiaowu的专栏
07-10 3496
本文转载自：https://www.jianshu.com/p/444646e02ef7 感谢原作者“大宽宽”的精心总结。 本文从操作系统的角度来解释BIO，NIO，AIO的概念，含义和背后的那些事。本文主要分为3篇。 第一篇讲解BIO和NIO以及IO多路复用 第二篇讲解磁盘IO和AIO 第三篇 讲解在这些机制上的一些应用的实现方式，比如nginx，nodejs，Java NIO等 ...
【Java网络编程与IO流】Java中BIO、NIO、AIO的区别是什么？
Mind_programmonkey的博客
11-28 1192
Java中BIO、NIO、AIO的区别是什么？ 如何学习Java的NIO Java核心（五）深入理解BIO、NIO、AIO BIO：阻塞同步通信模式，客户端与服务器连接需要三次握手，使用简单，但吞吐量少；(流) NIO: 非阻塞同步通信模式，客户端与服务器通过channel连接，采用多路复用器轮询注册的channel，提高吞吐量和可靠性。相比较于BIO，始终只有一个线程，并没有启动额外的线程来处理，解决了BIO线程无线增加的问题。(缓冲) AIO：非阻塞异步通信模式，采用异步通道实现通信，其基于事件和回调
BIO、NIO和AIO的区别、三种IO的用法与原理
flameflorid的博客
07-20 297
IO 什么是IO? 它是指计算机与外部世界或者一个程序与计算机的其余部分的之间的接口。它对于任何计算机系统都非常关键，因而所有 I/O 的主体实际上是内置在操作系统中的。单独的程序一般是让系统为它们完成大部分的工作。 在 Java 编程中，直到最近一直使用 流 的方式完成 I/O。所有 I/O 都被视为单个的字节的移动，通过一个称为 Stream 的对象一次移动一个字节。流 I/O 用于与外部世界接触。它也在内部使用，用于将对象转换为字节，然后再转换回对象。 BIO Java BIO即Block I/O ，
详细JAVA-NIO介绍与使用
JolyouLu的博客
09-20 2773
JAVA-NIO NIO基本介绍 JAVA NIO全称java non-blocking IO，是JDK提供的新API，从JDK1.4开始，java提供了一系列改进输入/输出的新特性，被称为NIO，是同步非阻塞的 NIO相关类都被放在java.nio包下，并且对原来java.io包中有很多的类进行改写 NIO有三大核心部分：Channel（通道），Buffer（缓冲区），Selector（选择器） NIO是面向缓冲区，或者面向块的编程，数据读取到一个稍后会处理的缓冲区，需要时可在缓冲区中前后移动，这就增加
Java文件读写IO/NIO及性能比较总结
Java我人生的技术博客
03-11 2万+
干Java这么久，一直在做WEB相关的项目，一些基础类差不多都已经忘记。经常想得捡起，但总是因为一些原因，不能如愿。 其实不是没有时间，只是有些时候疲于总结，今得空，下定决心将丢掉的都给捡起来。 文件读写是一个在项目中经常遇到的工作，有些时候是因为维护，有些时候是新功能开发。我们的任务总是很重，工作节奏很快，快到我们不能停下脚步去总结。 文件读写有以下几种常用的方法 1、字节读写（Inpu
java io 和nio_java对比IO和NIO的文件读写性能测试
05-31
Java IO 和 NIO 都可以用于文件读写操作，但是它们的实现方式不同，因此在性能上也略有差异。 针对文件读写操作，我们可以通过编写测试程序来对比 Java IO 和 NIO 的性能。下面是一个简单的测试程序： ```java import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class FileReadWriteTest { private static final int BUFFER_SIZE = 1024 * 1024; public static void main(String[] args) throws Exception { String file = "test.txt"; int size = 1024 * 1024 * 100; // 测试 Java IO 的文件写入性能 long start = System.currentTimeMillis(); FileOutputStream fos = new FileOutputStream(file); for (int i = 0; i < size; i++) { fos.write('a'); } fos.close(); long end = System.currentTimeMillis(); System.out.println("Java IO 文件写入耗时：" + (end - start) + "ms"); // 测试 Java IO 的文件读取性能 start = System.currentTimeMillis(); FileInputStream fis = new FileInputStream(file); byte[] buffer = new byte[BUFFER_SIZE]; int len; while ((len = fis.read(buffer)) != -1) { // do nothing } fis.close(); end = System.currentTimeMillis(); System.out.println("Java IO 文件读取耗时：" + (end - start) + "ms"); // 测试 NIO 的文件写入性能 start = System.currentTimeMillis(); FileChannel fc = new FileOutputStream(file).getChannel(); ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE); for (int i = 0; i < size / BUFFER_SIZE; i++) { fc.write(byteBuffer); byteBuffer.clear(); } fc.close(); end = System.currentTimeMillis(); System.out.println("NIO 文件写入耗时：" + (end - start) + "ms"); // 测试 NIO 的文件读取性能 start = System.currentTimeMillis(); fc = new FileInputStream(file).getChannel(); byteBuffer = ByteBuffer.allocate(BUFFER_SIZE); while (fc.read(byteBuffer) != -1) { byteBuffer.flip(); byteBuffer.clear(); } fc.close(); end = System.currentTimeMillis(); System.out.println("NIO 文件读取耗时：" + (end - start) + "ms"); } } ``` 该测试程序分别测试了 Java IO 和 NIO 的文件写入和文件读取性能。其中，文件大小为 100MB，缓冲区大小为 1MB。 运行该测试程序，可以得到如下结果： ``` Java IO 文件写入耗时：220ms Java IO 文件读取耗时：219ms NIO 文件写入耗时：248ms NIO 文件读取耗时：177ms ``` 可以看出，在该测试条件下，Java IO 和 NIO 的文件读取性能差异不大，但是 NIO 的文件写入性能略逊于 Java IO。不过需要注意的是，这只是一个简单的测试，实际情况下可能会因为多种因素而产生差异。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值