经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
Java IO 与 NIO：高效的输入输出操作探究
来源：cnblogs　　作者：flydean　　时间：2023/10/17 11:02:15　　对本文有异议

引言

输入输出（IO）是任何编程语言中的核心概念，而在Java中，IO操作更是应用程序成功运行的基石。随着计算机系统变得越来越复杂，对IO的要求也日益增加。在本文中，我们将探讨Java IO和非阻塞IO（NIO）的重要性以及如何在Java中实现高效的输入输出操作。

传统IO（阻塞IO）

传统IO是大多数开发人员熟悉的IO模型，其中主要涉及InputStream和OutputStream。通过传统IO，您可以轻松地进行文件读写和网络通信。让我们看一下传统IO的一个示例：

  1. import java.io.*;
  2. public class TraditionalIOExample {
  3.     public static void main(String[] args) {
  4.         try {
  5.             // 打开文件
  6.             InputStream input = new FileInputStream("example.txt");
  7.             OutputStream output = new FileOutputStream("output.txt");
  9.             // 读取和写入数据
  10.             int data;
  11.             while ((data = input.read()) != -1) {
  12.                 output.write(data);
  13.             }
  15.             // 关闭文件
  16.             input.close();
  17.             output.close();
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }

传统IO简单易用，但在某些情况下，它可能会阻塞程序的执行，特别是在处理大量并发请求时。

Java NIO简介

Java NIO（New I/O）引入了新的IO模型，主要由通道（Channels）和缓冲区（Buffers）组成。NIO提供了非阻塞和多路复用的特性，使其成为处理大量并发连接的理想选择。让我们了解一下NIO的核心概念。

NIO通道与缓冲区

NIO中，通道是数据传输的管道，而缓冲区则是数据的容器。通过通道和缓冲区，您可以实现高效的文件和网络操作。下面是一个简单的NIO示例：

  1. import java.nio.ByteBuffer;
  2. import java.nio.channels.FileChannel;
  3. import java.io.RandomAccessFile;
  4. public class NIOExample {
  5.     public static void main(String[] args) {
  6.         try {
  7.             RandomAccessFile file = new RandomAccessFile("example.txt", "r");
  8.             FileChannel channel = file.getChannel();
  9.             ByteBuffer buffer = ByteBuffer.allocate(1024);
  11.             while (channel.read(buffer) != -1) {
  12.                 buffer.flip();  // 切换为读模式
  13.                 while (buffer.hasRemaining()) {
  14.                     System.out.print((char) buffer.get());
  15.                 }
  16.                 buffer.clear();  // 清空缓冲区，切换为写模式
  17.             }
  19.             channel.close();
  20.             file.close();
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
  25. }

NIO的通道和缓冲区模型允许您更灵活地管理数据，以及处理大规模数据传输。

选择IO类型的考虑

在选择传统IO或NIO时，需要考虑性能需求、复杂性和应用场景。传统IO简单易用，适用于大多数情况。而NIO更适用于需要处理大量并发连接的高性能应用，如网络服务器和数据传输。

NIO的非阻塞特性

NIO的非阻塞特性主要通过选择器（Selector）和通道的非阻塞模式实现。这允许程序同时管理多个通道，而不必等待每个通道的数据可用。以下是一个NIO非阻塞IO的示例：

  1. import java.nio.channels.Selector;
  2. import java.nio.channels.ServerSocketChannel;
  3. import java.nio.channels.SocketChannel;
  4. public class NIOSelectorExample {
  5.     public static void main(String[] args) {
  6.         try {
  7.             Selector selector = Selector.open();
  8.             ServerSocketChannel serverSocket = ServerSocketChannel.open();
  9.             serverSocket.configureBlocking(false);
  10.             serverSocket.register(selector, SelectionKey.OP_ACCEPT);
  12.             while (true) {
  13.                 int readyChannels = selector.select();
  14.                 if (readyChannels == 0) continue;
  16.                 Set<SelectionKey> selectedKeys = selector.selectedKeys();
  17.                 Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
  18.                 while (keyIterator.hasNext()) {
  19.                     SelectionKey key = keyIterator.next();
  20.                     if (key.isAcceptable()) {
  21.                         // 处理连接
  22.                     } else if (key.isReadable()) {
  23.                         // 处理读取
  24.                     }
  25.                     keyIterator.remove();
  26.                 }
  27.             }
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  32. }

NIO的非阻塞特性允许程序同时处理多个通道，从而提高了应用程序的响应性。

IO和NIO的性能对比

性能对比是选择IO类型的关键因素之一。传统IO在处理少量并发请求时可能表现良好，但在高并发情况下可能出现性能瓶颈。NIO通过非阻塞和多路复用等特性提供更好的性能。性能测试和案例研究可以帮助开发人员了解哪种IO类型适合他们的应用。

IO（传统IO）和NIO（非阻塞IO）在性能方面存在显著差异，尤其在处理大量并发连接时。以下是一个具体的代码和实例，用于比较IO和NIO的性能。

性能测试目标： 我们将模拟一个简单的HTTP服务器，它将响应客户端请求并返回一个固定的响应（"Hello, World!"）。我们将使用IO和NIO两种不同的方式实现此服务器，然后进行性能测试。

IO实现：

  1. import java.io.*;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  5. public class IoHttpServer {
  6.     public static void main(String[] args) {
  7.         try (ServerSocket serverSocket = new ServerSocket(8080)) {
  8.             while (true) {
  9.                 Socket clientSocket = serverSocket.accept();
  10.                 handleRequest(clientSocket);
  11.             }
  12.         } catch (IOException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  17.     private static void handleRequest(Socket clientSocket) throws IOException {
  18.         BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
  19.         BufferedWriter out = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
  20.         String request = in.readLine();
  21.         out.write("HTTP/1.1 200 OK\r\n\r\nHello, World!\r\n");
  22.         out.flush();
  23.         clientSocket.close();
  24.     }
  25. }

NIO实现：

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.*;
  5. import java.util.Iterator;
  6. import java.util.Set;
  8. public class NioHttpServer {
  9.     public static void main(String[] args) {
  10.         try {
  11.             ServerSocketChannel serverChannel = ServerSocketChannel.open();
  12.             serverChannel.socket().bind(new InetSocketAddress(8080));
  13.             serverChannel.configureBlocking(false);
  15.             Selector selector = Selector.open();
  16.             serverChannel.register(selector, SelectionKey.OP_ACCEPT);
  18.             while (true) {
  19.                 selector.select();
  20.                 Set<SelectionKey> selectedKeys = selector.selectedKeys();
  21.                 Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
  23.                 while (keyIterator.hasNext()) {
  24.                     SelectionKey key = keyIterator.next();
  25.                     keyIterator.remove();
  27.                     if (key.isAcceptable()) {
  28.                         ServerSocketChannel server = (ServerSocketChannel) key.channel();
  29.                         SocketChannel clientChannel = server.accept();
  30.                         clientChannel.configureBlocking(false);
  31.                         clientChannel.register(selector, SelectionKey.OP_READ);
  32.                     } else if (key.isReadable()) {
  33.                         SocketChannel clientChannel = (SocketChannel) key.channel();
  34.                         ByteBuffer buffer = ByteBuffer.allocate(1024);
  35.                         clientChannel.read(buffer);
  36.                         buffer.flip();
  37.                         byte[] bytes = new byte[buffer.remaining()];
  38.                         buffer.get(bytes);
  39.                         String request = new String(bytes);
  41.                         String response = "HTTP/1.1 200 OK\r\n\r\nHello, World!\r\n";
  42.                         ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
  43.                         clientChannel.write(responseBuffer);
  44.                         clientChannel.close();
  45.                     }
  46.                 }
  47.             }
  48.         } catch (IOException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52. }

性能测试： 我们将使用Apache Benchmark工具（ab）来测试这两个HTTP服务器的性能，模拟1000个并发请求，每个请求重复1000次。

  1. ab -n 100000 -c 1000 http://localhost:8080/

性能测试结果： 在这个简单的性能测试中，NIO的实现通常会比传统IO的实现更具竞争力。由于NIO的非阻塞特性，它能够更好地处理大量并发请求，减少线程阻塞和上下文切换。

需要注意的是，性能测试结果受多个因素影响，包括硬件、操作系统和代码优化。因此，实际性能可能会因环境而异。然而，通常情况下，NIO在高并发场景下表现更出色。

总之，通过上述性能测试，我们可以看到NIO相对于传统IO在处理大量并发请求时的性能表现更为出色。因此，在需要高性能和可伸缩性的应用中，NIO通常是更好的选择。

实际应用场景

最后，我们将探讨一些实际应用场景，包括文件复制、HTTP服务器和套接字通信。这些场景演示了如何有效地应用IO和NIO来满足特定需求。

当涉及到Java中的IO和NIO的实际应用时，我们可以探讨一些常见的使用场景和示例代码。以下是几个实际应用的示例：

1. 文件复制

文件复制是一个常见的IO任务，它可以使用传统IO和NIO来实现。以下是一个使用传统IO的文件复制示例：

  1. import java.io.*;
  3. public class FileCopyUsingIO {
  4.     public static void main(String[] args) {
  5.         try (InputStream inputStream = new FileInputStream("input.txt");
  6.              OutputStream outputStream = new FileOutputStream("output.txt")) {
  8.             byte[] buffer = new byte[1024];
  9.             int bytesRead;
  10.             while ((bytesRead = inputStream.read(buffer)) != -1) {
  11.                 outputStream.write(buffer, 0, bytesRead);
  12.             }
  13.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  17. }

这段代码使用InputStream和OutputStream进行文件复制。

以下是一个使用NIO的文件复制示例：

  1. import java.io.IOException;
  2. import java.nio.ByteBuffer;
  3. import java.nio.channels.FileChannel;
  4. import java.nio.file.Path;
  5. import java.nio.file.StandardOpenOption;
  6. import java.nio.file.StandardCopyOption;
  7. import java.nio.file.FileSystems;
  9. public class FileCopyUsingNIO {
  10.     public static void main(String[] args) {
  11.         try {
  12.             Path source = FileSystems.getDefault().getPath("input.txt");
  13.             Path target = FileSystems.getDefault().getPath("output.txt");
  14.             FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ);
  15.             FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
  17.             ByteBuffer buffer = ByteBuffer.allocate(1024);
  18.             int bytesRead;
  19.             while ((bytesRead = sourceChannel.read(buffer)) != -1) {
  20.                 buffer.flip();
  21.                 while (buffer.hasRemaining()) {
  22.                     targetChannel.write(buffer);
  23.                 }
  24.                 buffer.clear();
  25.             }
  27.             sourceChannel.close();
  28.             targetChannel.close();
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

这段代码使用NIO中的FileChannel和ByteBuffer来实现文件复制。

2. HTTP服务器

创建一个简单的HTTP服务器也是一个常见的应用场景，可以使用NIO来处理多个并发连接。以下是一个使用NIO的简单HTTP服务器示例：

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.ServerSocketChannel;
  5. import java.nio.channels.SocketChannel;
  7. public class SimpleHttpServer {
  8.     public static void main(String[] args) {
  9.         try {
  10.             ServerSocketChannel serverChannel = ServerSocketChannel.open();
  11.             serverChannel.socket().bind(new InetSocketAddress(8080));
  13.             while (true) {
  14.                 SocketChannel clientChannel = serverChannel.accept();
  16.                 ByteBuffer buffer = ByteBuffer.allocate(1024);
  17.                 clientChannel.read(buffer);
  18.                 buffer.flip();
  19.                 // 处理HTTP请求
  20.                 // ...
  22.                 clientChannel.write(buffer);
  23.                 clientChannel.close();
  24.             }
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }

这段代码创建一个简单的HTTP服务器，使用NIO中的ServerSocketChannel和SocketChannel处理客户端请求。

3. 套接字通信

套接字通信是在网络编程中常见的应用，可以使用NIO来实现非阻塞的套接字通信。以下是一个使用NIO的简单套接字通信示例：

  1. import java.io.IOException;
  2. import java.nio.ByteBuffer;
  3. import java.nio.channels.SocketChannel;
  4. import java.net.InetSocketAddress;
  6. public class SocketCommunication {
  7.     public static void main(String[] args) {
  8.         try {
  9.             SocketChannel clientChannel = SocketChannel.open(new InetSocketAddress("localhost", 8080));
  11.             ByteBuffer buffer = ByteBuffer.allocate(1024);
  12.             String message = "Hello, Server!";
  13.             buffer.put(message.getBytes());
  14.             buffer.flip();
  15.             clientChannel.write(buffer);
  17.             buffer.clear();
  18.             clientChannel.read(buffer);
  19.             buffer.flip();
  20.             // 处理从服务器接收的数据
  21.             // ...
  23.             clientChannel.close();
  24.         } catch (IOException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28. }

这段代码创建一个客户端套接字通信，使用NIO的SocketChannel来与服务器进行非阻塞通信。

这些示例代表了Java中IO和NIO的实际应用场景，从文件复制到HTTP服务器和套接字通信。这些示例演示了如何使用Java的IO和NIO来处理各种输入输出任务。

总结

通过本文，我们深入探讨了Java中的IO和NIO，以及它们的应用。了解如何选择合适的IO类型和使用适当的工具，可以帮助开发人员实现高效的输入输出操作，提高应用程序的性能和可伸缩性。鼓励读者在实际开发中深入研究和应用IO和NIO，以满足不同应用的需求。

更多内容请参考 www.flydean.com

最通俗的解读，最深刻的干货，最简洁的教程，众多你不知道的小技巧等你来发现！

欢迎关注我的公众号:「程序那些事」,懂技术，更懂你！

原文链接：https://www.cnblogs.com/flydean/p/17768946.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号