Java 输入输出流的配置优化
2022-07-306.8k 阅读
Java 输入输出流基础回顾
在深入探讨 Java 输入输出流的配置优化之前，我们先来回顾一下其基础概念。Java 的输入输出流（I/O Streams）是一种用于在程序和外部设备（如文件、网络连接等）之间传输数据的机制。
字节流与字符流
- 字节流：主要用于处理二进制数据，以字节（8 位）为单位进行数据传输。字节输入流的基类是
InputStream，字节输出流的基类是OutputStream。例如，FileInputStream和FileOutputStream用于文件的字节读写操作。try { FileInputStream fis = new FileInputStream("example.txt"); int data; while ((data = fis.read()) != -1) { System.out.print((char) data); } fis.close(); } catch (IOException e) { e.printStackTrace(); } - 字符流：用于处理文本数据，以字符（16 位，对应
char类型）为单位进行数据传输。字符输入流的基类是Reader，字符输出流的基类是Writer。比如，FileReader和FileWriter用于文件的字符读写。try { FileReader fr = new FileReader("example.txt"); int charData; while ((charData = fr.read()) != -1) { System.out.print((char) charData); } fr.close(); } catch (IOException e) { e.printStackTrace(); }
缓冲流的优化配置
缓冲字节流
- BufferedInputStream 和 BufferedOutputStream：缓冲字节流通过在内存中设置缓冲区，减少了对底层设备的 I/O 操作次数，从而提高了数据传输效率。
try { FileInputStream fis = new FileInputStream("largeFile.bin"); BufferedInputStream bis = new BufferedInputStream(fis); FileOutputStream fos = new FileOutputStream("outputFile.bin"); BufferedOutputStream bos = new BufferedOutputStream(fos); int data; while ((data = bis.read()) != -1) { bos.write(data); } bis.close(); bos.close(); } catch (IOException e) { e.printStackTrace(); } - 缓冲区大小的选择：
BufferedInputStream和BufferedOutputStream的构造函数可以接受一个int类型的参数，用于指定缓冲区的大小。默认情况下，缓冲区大小为 8192 字节（8KB）。对于大多数场景，这个默认值已经足够，但在处理非常大的文件或者对性能要求极高的场景下，需要根据实际情况调整缓冲区大小。// 设置缓冲区大小为 16KB BufferedInputStream bis = new BufferedInputStream(fis, 16 * 1024);
缓冲字符流
- BufferedReader 和 BufferedWriter：与缓冲字节流类似，缓冲字符流
BufferedReader和BufferedWriter也通过缓冲区来提高字符数据的读写效率。BufferedReader提供了一些方便的方法，如readLine()，可以逐行读取文本数据。try { FileReader fr = new FileReader("example.txt"); BufferedReader br = new BufferedReader(fr); FileWriter fw = new FileWriter("output.txt"); BufferedWriter bw = new BufferedWriter(fw); String line; while ((line = br.readLine()) != null) { bw.write(line); bw.newLine(); } br.close(); bw.close(); } catch (IOException e) { e.printStackTrace(); } - 缓冲区大小调整：
BufferedReader和BufferedWriter的构造函数同样可以接受一个int类型的参数来指定缓冲区大小。对于文本文件，根据文件的平均行长度和文件大小来调整缓冲区大小可能会获得更好的性能。例如，如果文件的行长度较长，可以适当增大缓冲区大小。// 设置缓冲区大小为 10240 字符（10KB） BufferedReader br = new BufferedReader(fr, 10 * 1024);
数据流的优化配置
DataInputStream 和 DataOutputStream
- 基本数据类型的读写：
DataInputStream和DataOutputStream用于读取和写入基本数据类型（如int、float、boolean等）以及字符串数据。它们提供了类型安全的读写方法，使得在不同平台之间传输数据更加可靠。try { FileOutputStream fos = new FileOutputStream("dataFile.dat"); DataOutputStream dos = new DataOutputStream(fos); dos.writeInt(42); dos.writeFloat(3.14f); dos.writeBoolean(true); dos.writeUTF("Hello, World!"); dos.close(); FileInputStream fis = new FileInputStream("dataFile.dat"); DataInputStream dis = new DataInputStream(fis); int intValue = dis.readInt(); float floatValue = dis.readFloat(); boolean boolValue = dis.readBoolean(); String strValue = dis.readUTF(); System.out.println("Int: " + intValue); System.out.println("Float: " + floatValue); System.out.println("Boolean: " + boolValue); System.out.println("String: " + strValue); dis.close(); } catch (IOException e) { e.printStackTrace(); } - 性能优化点：在使用
DataInputStream和DataOutputStream时，由于它们是基于字节流的，建议将其与缓冲流结合使用，以减少 I/O 操作次数。例如：FileOutputStream fos = new FileOutputStream("dataFile.dat"); BufferedOutputStream bos = new BufferedOutputStream(fos); DataOutputStream dos = new DataOutputStream(bos); // 进行数据写入操作 dos.close();
ObjectInputStream 和 ObjectOutputStream
- 对象的序列化与反序列化：
ObjectInputStream和ObjectOutputStream用于对象的序列化（将对象转换为字节流）和反序列化（将字节流恢复为对象）。要使一个类可序列化，它必须实现Serializable接口。import java.io.*; class Person implements Serializable { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } } public class ObjectSerializationExample { public static void main(String[] args) { try { FileOutputStream fos = new FileOutputStream("person.obj"); ObjectOutputStream oos = new ObjectOutputStream(fos); Person person = new Person("Alice", 30); oos.writeObject(person); oos.close(); FileInputStream fis = new FileInputStream("person.obj"); ObjectInputStream ois = new ObjectInputStream(fis); Person deserializedPerson = (Person) ois.readObject(); System.out.println(deserializedPerson); ois.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } } } - 优化建议：在序列化对象时，尽量减少对象中的 transient 字段（不会被序列化的字段），因为这些字段在反序列化时需要额外的处理。另外，对于频繁进行对象序列化和反序列化的场景，可以考虑使用自定义的序列化方法，通过实现
writeObject和readObject方法来优化性能。例如，如果对象中有一些复杂的属性，在序列化时可以对其进行简化处理，在反序列化时再恢复。
基于 NIO 的优化配置
Java NIO 概述
Java NIO（New I/O）是 Java 1.4 引入的一套新的 I/O 库，它提供了与传统 I/O 不同的方式来处理数据。NIO 基于通道（Channel）和缓冲区（Buffer）进行操作，支持非阻塞 I/O 操作，适用于高并发的网络应用场景。
通道与缓冲区
- 通道（Channel）：通道是一种可以进行读写操作的对象，类似于传统 I/O 中的流，但通道是双向的，既可以读也可以写，而流通常是单向的（输入流或输出流）。常见的通道类型有
FileChannel用于文件 I/O，SocketChannel和ServerSocketChannel用于网络 I/O。try { FileOutputStream fos = new FileOutputStream("example.txt"); FileChannel fc = fos.getChannel(); ByteBuffer buffer = ByteBuffer.wrap("Hello, NIO!".getBytes()); fc.write(buffer); fc.close(); } catch (IOException e) { e.printStackTrace(); } - 缓冲区（Buffer）：缓冲区是一个用于存储数据的容器，NIO 中的缓冲区主要有
ByteBuffer、CharBuffer、IntBuffer等。缓冲区有四个重要的属性：容量（capacity）、位置（position）、限制（limit）和标记（mark）。在使用缓冲区时，需要注意这些属性的变化。例如，在写入数据时，position 会增加，当要读取数据时，需要调用flip()方法将 position 重置为 0 并设置 limit 为当前 position 的值。ByteBuffer buffer = ByteBuffer.allocate(1024); buffer.put("Hello".getBytes()); buffer.flip(); byte[] data = new byte[buffer.limit()]; buffer.get(data); System.out.println(new String(data));
非阻塞 I/O 与选择器（Selector）
- 非阻塞 I/O：传统的 I/O 操作是阻塞的，即当进行读写操作时，线程会一直等待操作完成。而 NIO 的非阻塞 I/O 允许线程在 I/O 操作未完成时继续执行其他任务。例如，
SocketChannel可以设置为非阻塞模式：try { SocketChannel socketChannel = SocketChannel.open(); socketChannel.configureBlocking(false); socketChannel.connect(new InetSocketAddress("example.com", 80)); while (!socketChannel.finishConnect()) { // 可以执行其他任务 } ByteBuffer buffer = ByteBuffer.allocate(1024); socketChannel.read(buffer); socketChannel.close(); } catch (IOException e) { e.printStackTrace(); } - 选择器（Selector）：选择器是 NIO 中实现多路复用 I/O 的关键组件。它可以监听多个通道的事件（如连接就绪、读就绪、写就绪等），使得一个线程可以管理多个通道。在高并发的网络应用中，使用选择器可以显著减少线程的数量，从而提高系统的性能和可扩展性。
try { Selector selector = Selector.open(); ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.configureBlocking(false); serverSocketChannel.bind(new InetSocketAddress(8080)); serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); while (true) { int readyChannels = selector.select(); if (readyChannels == 0) continue; Set<SelectionKey> selectedKeys = selector.selectedKeys(); Iterator<SelectionKey> keyIterator = selectedKeys.iterator(); while (keyIterator.hasNext()) { SelectionKey key = keyIterator.next(); if (key.isAcceptable()) { ServerSocketChannel server = (ServerSocketChannel) key.channel(); SocketChannel client = server.accept(); client.configureBlocking(false); client.register(selector, SelectionKey.OP_READ); } else if (key.isReadable()) { SocketChannel client = (SocketChannel) key.channel(); ByteBuffer buffer = ByteBuffer.allocate(1024); client.read(buffer); buffer.flip(); System.out.println(new String(buffer.array())); } keyIterator.remove(); } } } catch (IOException e) { e.printStackTrace(); }
输入输出流在不同场景下的优化策略
文件 I/O 场景
- 小文件读写：对于小文件（通常指文件大小在几十 KB 以内），直接使用
FileInputStream和FileOutputStream或者FileReader和FileWriter可能就足够了，因为缓冲流的额外开销在这种情况下可能不划算。但如果文件内容需要频繁读取或写入，还是建议使用缓冲流来减少 I/O 操作次数。// 小文件读取示例 try { FileReader fr = new FileReader("smallFile.txt"); int charData; while ((charData = fr.read()) != -1) { System.out.print((char) charData); } fr.close(); } catch (IOException e) { e.printStackTrace(); } - 大文件读写：处理大文件时，缓冲流是必不可少的。根据文件的类型（二进制文件或文本文件）选择合适的缓冲流，并且合理调整缓冲区大小。对于超大文件，可以考虑使用 NIO 的
FileChannel进行读写，因为它提供了更高效的文件操作方式，如内存映射文件（MappedByteBuffer），可以将文件的一部分直接映射到内存中，从而减少 I/O 操作。try { FileInputStream fis = new FileInputStream("largeFile.bin"); FileChannel fc = fis.getChannel(); MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size()); byte[] data = new byte[(int) fc.size()]; mbb.get(data); fc.close(); } catch (IOException e) { e.printStackTrace(); }
网络 I/O 场景
- 客户端 - 服务器通信：在客户端 - 服务器的网络通信中，使用 NIO 的非阻塞 I/O 和选择器可以显著提高性能。客户端和服务器可以通过
SocketChannel和ServerSocketChannel进行通信，并且可以根据业务需求选择合适的缓冲区大小。例如，在处理实时数据传输（如视频流、音频流）时，缓冲区大小需要根据数据的帧率和码率进行调整。// 客户端示例 try { SocketChannel socketChannel = SocketChannel.open(); socketChannel.configureBlocking(false); socketChannel.connect(new InetSocketAddress("server.com", 8080)); while (!socketChannel.finishConnect()) { // 可以执行其他任务 } ByteBuffer buffer = ByteBuffer.wrap("Hello, Server!".getBytes()); socketChannel.write(buffer); buffer.clear(); socketChannel.read(buffer); buffer.flip(); System.out.println(new String(buffer.array())); socketChannel.close(); } catch (IOException e) { e.printStackTrace(); } - 高并发网络应用：对于高并发的网络应用，如 Web 服务器，选择器的使用尤为重要。通过一个选择器管理多个通道，可以避免创建大量的线程，从而降低系统资源的消耗。同时，合理设置缓冲区大小和调整 I/O 操作的策略（如批量读写）可以进一步提高性能。例如，在处理 HTTP 请求时，可以将请求数据先读入缓冲区，然后再进行解析，避免多次 I/O 操作。
输入输出流优化的性能测试与评估
性能测试工具
- JMH（Java Microbenchmark Harness）：JMH 是一个专门用于 Java 代码性能测试的工具。它可以帮助我们精确测量不同 I/O 配置下的性能指标，如吞吐量、延迟等。以下是一个使用 JMH 测试缓冲流和非缓冲流性能的示例：
import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.runner.Runner; import org.openjdk.jmh.runner.RunnerException; import org.openjdk.jmh.runner.options.Options; import org.openjdk.jmh.runner.options.OptionsBuilder; import java.io.*; import java.util.concurrent.TimeUnit; @BenchmarkMode(Mode.Throughput) @OutputTimeUnit(TimeUnit.SECONDS) @Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) @Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) @Fork(1) public class IOPerformanceTest { private static final String TEST_FILE = "test.txt"; @Benchmark public void testBufferedStream() throws IOException { try (FileInputStream fis = new FileInputStream(TEST_FILE); BufferedInputStream bis = new BufferedInputStream(fis); FileOutputStream fos = new FileOutputStream("output.txt"); BufferedOutputStream bos = new BufferedOutputStream(fos)) { int data; while ((data = bis.read()) != -1) { bos.write(data); } } } @Benchmark public void testUnbufferedStream() throws IOException { try (FileInputStream fis = new FileInputStream(TEST_FILE); FileOutputStream fos = new FileOutputStream("output.txt")) { int data; while ((data = fis.read()) != -1) { fos.write(data); } } } public static void main(String[] args) throws RunnerException { Options opt = new OptionsBuilder() .include(IOPerformanceTest.class.getSimpleName()) .build(); new Runner(opt).run(); } } - 自定义性能测试代码：除了使用专业工具，我们也可以编写自定义的性能测试代码来简单评估不同 I/O 配置的性能。例如，通过记录开始时间和结束时间来计算数据传输的时间，从而得到吞吐量。
import java.io.*; public class CustomIOPerformanceTest { private static final String TEST_FILE = "test.txt"; public static void main(String[] args) { long startTime, endTime; try { startTime = System.currentTimeMillis(); try (FileInputStream fis = new FileInputStream(TEST_FILE); BufferedInputStream bis = new BufferedInputStream(fis); FileOutputStream fos = new FileOutputStream("output.txt"); BufferedOutputStream bos = new BufferedOutputStream(fos)) { int data; while ((data = bis.read()) != -1) { bos.write(data); } } endTime = System.currentTimeMillis(); System.out.println("Buffered Stream Time: " + (endTime - startTime) + " ms"); startTime = System.currentTimeMillis(); try (FileInputStream fis = new FileInputStream(TEST_FILE); FileOutputStream fos = new FileOutputStream("output.txt")) { int data; while ((data = fis.read()) != -1) { fos.write(data); } } endTime = System.currentTimeMillis(); System.out.println("Unbuffered Stream Time: " + (endTime - startTime) + " ms"); } catch (IOException e) { e.printStackTrace(); } } }
性能评估指标
- 吞吐量（Throughput）：吞吐量是指单位时间内能够传输的数据量，通常以字节/秒（Byte/s）或位/秒（Bit/s）为单位。在性能测试中，较高的吞吐量意味着更高效的 I/O 操作。例如，在文件拷贝操作中，吞吐量越高，拷贝所需的时间就越短。
- 延迟（Latency）：延迟是指从发起 I/O 操作到操作完成所经历的时间。对于一些对实时性要求较高的应用（如实时通信、游戏服务器等），延迟是一个非常关键的指标。通过优化 I/O 配置，如使用非阻塞 I/O 和合适的缓冲区大小，可以降低延迟。
- 资源消耗：除了吞吐量和延迟，资源消耗也是评估 I/O 性能的重要方面。这包括内存使用、CPU 占用等。例如，不合理的缓冲区大小可能会导致内存浪费，而频繁的 I/O 操作可能会使 CPU 占用过高。在优化 I/O 配置时，需要在提高性能的同时，尽量减少资源的消耗。
总结
通过对 Java 输入输出流的深入理解和优化配置，我们可以显著提高程序在文件 I/O 和网络 I/O 等场景下的性能。从基础的字节流和字符流，到缓冲流、数据流以及基于 NIO 的优化，每一种方式都有其适用场景和优化要点。在实际应用中，需要根据具体的业务需求和数据特点，选择合适的 I/O 配置，并通过性能测试工具来评估和验证优化效果。不断优化 I/O 操作，不仅可以提升程序的运行效率，还能更好地满足用户对高性能应用的需求。