MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java 输入输出流的性能优化

2023-03-103.9k 阅读

Java 输入输出流的性能优化

1. 理解 Java 输入输出流基础

在 Java 中，输入输出（I/O）流是处理数据输入与输出的核心机制。Java 的 I/O 流类库十分庞大，它基于字节流和字符流两种基本类型构建。字节流以 InputStream 和 OutputStream 为基类，用于处理二进制数据；字符流则以 Reader 和 Writer 为基类，主要处理字符数据，它们会自动处理字符编码转换。

例如，下面是一个简单的从文件读取字节数据并输出的示例：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ByteStreamExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("example.txt")) {
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

而使用字符流读取文件内容的示例如下：

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class CharacterStreamExample {
    public static void main(String[] args) {
        try (Reader reader = new FileReader("example.txt")) {
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 缓冲流的使用与性能提升

2.1 缓冲字节流

BufferedInputStream 和 BufferedOutputStream 是字节流的缓冲实现。它们内部维护一个缓冲区，减少了实际的 I/O 操作次数。当从 BufferedInputStream 读取数据时，它会一次性从底层输入流读取多个字节到缓冲区，后续的读取操作优先从缓冲区获取数据。同样，BufferedOutputStream 会先将数据写入缓冲区，当缓冲区满或者调用 flush() 方法时，才将数据真正写入到底层输出流。

以下是使用 BufferedInputStream 和 BufferedOutputStream 进行文件复制的示例：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedByteStreamCopy {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("source.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("destination.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

相比直接使用 FileInputStream 和 FileOutputStream，缓冲流大大减少了系统调用的次数，从而提升了性能。特别是在处理大文件时，性能提升更为显著。

2.2 缓冲字符流

BufferedReader 和 BufferedWriter 是字符流的缓冲实现。它们同样通过缓冲区来提高读写效率。BufferedReader 提供了更方便的读取方法，如 readLine()，可以按行读取文本数据。BufferedWriter 则提供了 newLine() 方法来写入平台相关的换行符。

下面是一个使用 BufferedReader 和 BufferedWriter 逐行读取并写入文件的示例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedCharacterStreamExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("source.txt"));
             BufferedWriter bw = new BufferedWriter(new FileWriter("destination.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这种按行处理的方式不仅提高了效率，也使得代码更加简洁和易读。在处理文本文件时，缓冲字符流是非常常用的选择。

3. 高效的字节数组操作

3.1 使用合适大小的字节数组

在从输入流读取数据或者向输出流写入数据时，合理选择字节数组的大小对性能有影响。如果字节数组过小，会导致频繁的读取或写入操作，增加系统开销；如果字节数组过大，虽然减少了操作次数，但可能会占用过多的内存。

一般来说，对于大多数 I/O 操作，8192 字节（8KB）是一个比较合适的默认大小。以下是一个使用 8KB 字节数组进行文件复制的示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class ByteArrayCopy {
    public static void main(String[] args) {
        byte[] buffer = new byte[8192];
        try (InputStream inputStream = new FileInputStream("source.txt");
             OutputStream outputStream = new FileOutputStream("destination.txt")) {
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通过使用合适大小的字节数组，我们在减少系统调用次数和避免过多内存占用之间达到了一个较好的平衡。

3.2 直接字节数组操作

在某些情况下，我们可能需要对字节数组进行直接操作，而不是每次都通过流的方法逐个字节处理。例如，在进行数据校验或者加密解密操作时，直接对字节数组进行计算可以提高效率。

假设我们要对一个文件的内容进行简单的异或加密，并且直接在字节数组上操作：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class XorEncryption {
    private static final byte KEY = 0x42;

    public static void main(String[] args) {
        byte[] buffer = new byte[8192];
        try (InputStream inputStream = new FileInputStream("source.txt");
             OutputStream outputStream = new FileOutputStream("encrypted.txt")) {
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                for (int i = 0; i < length; i++) {
                    buffer[i] ^= KEY;
                }
                outputStream.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这种直接在字节数组上进行操作的方式避免了频繁的流操作，提高了处理速度。

4. 字符编码与性能

4.1 正确选择字符编码

在处理字符流时，字符编码的选择至关重要。不同的编码方式在存储和处理字符时的效率不同。常见的字符编码如 UTF - 8、UTF - 16、ISO - 8859 - 1 等各有特点。

UTF - 8 是一种变长编码，对于 ASCII 字符只需要一个字节，而对于其他字符可能需要 2 - 4 个字节。它是目前互联网上最常用的编码方式，具有很好的兼容性。UTF - 16 则是定长编码，每个字符占用 2 个字节（对于一些补充字符需要 4 个字节）。ISO - 8859 - 1 是单字节编码，只能表示 256 个字符，主要用于西欧语言。

在选择字符编码时，要根据实际需求来决定。如果处理的文本主要是 ASCII 字符，UTF - 8 是一个很好的选择，因为它在存储和传输方面都比较高效。如果需要处理大量的非 ASCII 字符，并且对处理速度有较高要求，UTF - 16 可能更合适，尽管它会占用更多的空间。

4.2 避免不必要的编码转换

在处理字符流时，尽量避免不必要的编码转换。每次编码转换都需要消耗一定的 CPU 资源和时间。例如，如果一个文件是以 UTF - 8 编码保存的，并且我们知道这个编码格式，就应该直接以 UTF - 8 编码读取和写入，而不是先转换为其他编码再处理。

以下是一个以指定编码读取和写入文件的示例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class EncodingExample {
    public static void main(String[] args) {
        String encoding = "UTF - 8";
        try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileReader("source.txt"), encoding));
             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileWriter("destination.txt"), encoding))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通过明确指定编码，我们避免了潜在的不必要编码转换，从而提高了性能。

5. NIO（New I/O）与性能优化

5.1 NIO 概述

Java NIO 是从 JDK 1.4 开始引入的新的 I/O 包，它提供了与传统 I/O 不同的操作方式。NIO 基于通道（Channel）和缓冲区（Buffer）进行操作，与传统 I/O 的流模型不同。通道是双向的，可以同时进行读和写操作，而缓冲区则用于存储数据。

NIO 还引入了选择器（Selector）的概念，它允许单线程处理多个通道，实现了非阻塞 I/O 操作。这在处理大量并发连接时非常有用，可以显著提高系统的性能和可扩展性。

5.2 使用 NIO 进行文件操作

下面是一个使用 NIO 进行文件复制的示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileCopy {
    public static void main(String[] args) {
        try (FileChannel sourceChannel = new FileInputStream("source.txt").getChannel();
             FileChannel targetChannel = new FileOutputStream("destination.txt").getChannel()) {
            ByteBuffer buffer = ByteBuffer.allocate(8192);
            while (sourceChannel.read(buffer) != -1) {
                buffer.flip();
                targetChannel.write(buffer);
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们通过 FileChannel 获取通道，并使用 ByteBuffer 作为缓冲区。数据从源通道读取到缓冲区，然后通过缓冲区写入目标通道。这种方式在处理大文件时通常比传统的流方式更高效。

5.3 NIO 非阻塞 I/O

NIO 的非阻塞 I/O 特性使得我们可以在单线程中处理多个 I/O 操作，避免了线程阻塞带来的性能开销。下面是一个简单的 NIO 非阻塞 I/O 示例，监听一个端口并处理客户端连接：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NonBlockingNIOServer {
    public static void main(String[] args) {
        try (Selector selector = Selector.open();
             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
            serverSocketChannel.bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            while (true) {
                selector.select();
                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);
                        int bytesRead = client.read(buffer);
                        if (bytesRead > 0) {
                            buffer.flip();
                            // 处理读取到的数据
                            buffer.clear();
                        } else if (bytesRead == -1) {
                            client.close();
                        }
                    }
                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们通过 Selector 监听多个通道的事件（如连接请求和数据可读）。当有事件发生时，通过 SelectionKey 来判断事件类型并进行相应处理。这种非阻塞的方式大大提高了系统在高并发情况下的性能。

6. 关闭流资源的最佳实践

6.1 使用 try - with - resources

在 Java 7 及以上版本，推荐使用 try - with - resources 语句来管理流资源。try - with - resources 会自动关闭在 try 块中声明的资源，无论是否发生异常。这避免了手动关闭资源时可能出现的遗漏或异常处理不当的问题。

例如，前面的文件复制示例可以改写为如下更简洁且安全的形式：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TryWithResourcesCopy {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("source.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("destination.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通过 try - with - resources，我们确保了 BufferedInputStream 和 BufferedOutputStream 在使用完毕后会被正确关闭，无论 try 块中是否发生异常。

6.2 手动关闭流的注意事项

在 Java 7 之前，或者在一些特殊情况下需要手动关闭流时，要注意关闭的顺序。一般来说，应该先关闭外层流，再关闭内层流。例如，如果使用了 BufferedInputStream 包装 FileInputStream，应该先关闭 BufferedInputStream，再关闭 FileInputStream。

以下是手动关闭流的示例：

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ManualCloseExample {
    public static void main(String[] args) {
        InputStream fileInputStream = null;
        BufferedInputStream bufferedInputStream = null;
        try {
            fileInputStream = new FileInputStream("example.txt");
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            int data;
            while ((data = bufferedInputStream.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedInputStream != null) {
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在手动关闭流时，要注意在 finally 块中进行关闭操作，并处理可能抛出的 IOException。正确的关闭顺序和异常处理可以确保资源被正确释放，避免资源泄漏。

7. 性能监测与分析

7.1 使用 Java 自带工具

Java 提供了一些工具来监测和分析 I/O 性能，如 jconsole 和 jvisualvm。jconsole 是一个图形化工具，可以实时监测 Java 应用程序的性能指标，包括 I/O 操作的统计信息。jvisualvm 功能更为强大，它不仅可以监测性能，还可以进行线程分析、堆转储分析等。

要使用 jconsole，可以在命令行中输入 jconsole，然后选择要监测的 Java 进程。在 jconsole 的界面中，可以查看各种性能指标，如线程活动、内存使用情况以及 I/O 操作的次数和时间等。

7.2 自定义性能监测

除了使用 Java 自带工具，我们还可以在代码中自定义性能监测逻辑。例如，通过记录操作开始和结束的时间来计算 I/O 操作的耗时。

以下是一个在文件复制操作中监测性能的示例：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class PerformanceMonitoring {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("source.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("destination.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("File copy took " + (endTime - startTime) + " milliseconds");
    }
}

通过这种方式，我们可以准确地知道特定 I/O 操作所花费的时间，从而评估性能优化的效果。

通过以上对 Java 输入输出流性能优化的各个方面的探讨，我们可以根据具体的应用场景，选择合适的优化策略，提高程序的 I/O 性能，使得程序在处理数据输入输出时更加高效和稳定。无论是选择合适的流类型、使用缓冲流、优化字节数组操作，还是利用 NIO 的特性，都需要根据实际需求和系统资源来综合考虑。同时，正确的资源管理和性能监测也是优化过程中不可或缺的部分。