Java IO与NIO性能对比分析 - 摩柯技术社区

Java IO 基础

Java IO 即 Input/Output，是Java提供的一套用于处理输入和输出操作的类库，位于 java.io 包下。它基于流（Stream）的概念，流是一个连续的字节序列，用于在数据源和程序之间传输数据。

字节流与字符流

字节流：字节流以字节（8位）为单位处理数据，主要用于处理二进制数据，例如图像、音频、视频等。字节流的基类是 InputStream 和 OutputStream。
- FileInputStream：用于从文件中读取字节数据。例如：

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();
        }
    }
}

FileOutputStream：用于向文件中写入字节数据。例如：

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

public class ByteStreamWriteExample {
    public static void main(String[] args) {
        String data = "Hello, World!";
        try (OutputStream outputStream = new FileOutputStream("output.txt")) {
            outputStream.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流：字符流以字符（16位，对应Java中的 char 类型）为单位处理数据，主要用于处理文本数据。字符流的基类是 Reader 和 Writer。
- FileReader：用于从文件中读取字符数据。例如：

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();
        }
    }
}

FileWriter：用于向文件中写入字符数据。例如：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class CharacterStreamWriteExample {
    public static void main(String[] args) {
        String data = "Hello, World!";
        try (Writer writer = new FileWriter("output.txt")) {
            writer.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲流

为了提高IO操作的性能，Java IO 提供了缓冲流。缓冲流在内存中设置了缓冲区，减少了对底层设备的直接读写次数。

BufferedInputStream 和 BufferedOutputStream：字节缓冲流。例如，使用 BufferedInputStream 读取文件：

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

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

BufferedReader 和 BufferedWriter：字符缓冲流。例如，使用 BufferedReader 逐行读取文件：

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

public class BufferedCharacterStreamExample {
    public static void main(String[] args) {
        try (Reader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = ((BufferedReader) reader).readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Java NIO 基础

Java NIO（New I/O）是Java 1.4引入的一套新的I/O API，它提供了与传统IO不同的方式来处理输入和输出。NIO基于通道（Channel）和缓冲区（Buffer）的概念，并且支持非阻塞I/O操作。

通道（Channel）

通道是NIO中用于与数据源进行数据传输的对象。与传统IO的流不同，通道既可以用于读操作，也可以用于写操作。

FileChannel：用于文件的读写操作。例如，使用 FileChannel 读取文件：

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

public class FileChannelReadExample {
    public static void main(String[] args) {
        try (FileInputStream fileInputStream = new FileInputStream("example.txt");
             FileChannel fileChannel = fileInputStream.getChannel()) {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            int bytesRead;
            while ((bytesRead = fileChannel.read(byteBuffer)) != -1) {
                byteBuffer.flip();
                while (byteBuffer.hasRemaining()) {
                    System.out.print((char) byteBuffer.get());
                }
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

SocketChannel：用于TCP套接字的读写操作。例如，使用 SocketChannel 连接服务器并发送数据：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class SocketChannelWriteExample {
    public static void main(String[] args) {
        try (SocketChannel socketChannel = SocketChannel.open()) {
            socketChannel.connect(new InetSocketAddress("localhost", 8080));
            String data = "Hello, Server!";
            ByteBuffer byteBuffer = ByteBuffer.wrap(data.getBytes());
            socketChannel.write(byteBuffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲区（Buffer）

缓冲区是NIO中用于存储数据的对象。它本质上是一个数组，并提供了一些额外的状态信息，如容量（capacity）、位置（position）和限制（limit）。

ByteBuffer：最常用的缓冲区类型，用于存储字节数据。可以通过 allocate 方法分配内存：ByteBuffer byteBuffer = ByteBuffer.allocate(1024);。
CharBuffer：用于存储字符数据，例如：CharBuffer charBuffer = CharBuffer.allocate(1024);。

选择器（Selector）

选择器是NIO中实现非阻塞I/O的关键组件。它允许一个线程监控多个通道的I/O事件，如连接建立、数据可读、数据可写等。

Selector 的使用示例：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class SelectorExample {
    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) {
                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);
                        int bytesRead = client.read(buffer);
                        if (bytesRead > 0) {
                            buffer.flip();
                            byte[] data = new byte[buffer.remaining()];
                            buffer.get(data);
                            System.out.println("Received: " + new String(data));
                        }
                    }

                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Java IO 与 NIO 性能对比分析

阻塞与非阻塞
- Java IO：传统IO是阻塞式的。例如，当使用 InputStream 的 read 方法读取数据时，线程会一直阻塞，直到有数据可读或者到达流的末尾。这意味着在等待数据的过程中，线程无法执行其他任务，对于高并发场景不太友好。例如，一个服务器应用使用传统IO处理多个客户端连接时，每个连接都需要一个独立的线程来处理I/O操作，随着客户端数量的增加，线程数量也会急剧增加，导致系统资源消耗过大。
- Java NIO：NIO支持非阻塞式I/O。通过将通道设置为非阻塞模式，read 和 write 方法不会一直阻塞线程。例如，SocketChannel 在非阻塞模式下调用 read 方法时，如果当前没有数据可读，会立即返回 -1，线程可以继续执行其他任务。结合选择器（Selector），一个线程可以监控多个通道的I/O事件，大大提高了系统的并发处理能力。在上述的 SelectorExample 中，一个线程可以处理多个客户端的连接和数据读取，减少了线程的创建和上下文切换开销。
缓冲区与流的处理方式
- Java IO：基于流的方式处理数据，数据是按顺序依次从流中读取或写入。流的操作比较简单直观，但对于大量数据的处理效率相对较低。例如，在读取大文件时，每次从流中读取一个字节或字符，频繁的I/O操作会增加系统开销。而且，传统IO的缓冲区是由缓冲流类（如 BufferedInputStream）提供的，是在流的基础上进行的封装。
- Java NIO：基于缓冲区处理数据，数据先被读入缓冲区，然后再从缓冲区进行处理。缓冲区提供了更灵活的数据操作方式，例如可以通过 flip 方法切换缓冲区的读写模式。在处理大量数据时，NIO可以一次性将较多数据读入缓冲区，减少I/O操作次数。例如，FileChannel 读取文件时，可以使用较大的 ByteBuffer 一次读取多个字节，提高了数据读取效率。而且，NIO的缓冲区是核心概念，通道直接与缓冲区交互。
文件I/O性能对比
- 测试场景：为了对比Java IO和NIO在文件I/O方面的性能，我们进行一个简单的测试：从一个大文件中读取数据并写入到另一个文件中。
- Java IO 实现：

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

public class JavaIOFileCopy {
    public static void main(String[] args) {
        String sourceFilePath = "largeFile.txt";
        String targetFilePath = "copiedFile_IO.txt";
        try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(sourceFilePath));
             BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(targetFilePath))) {
            int data;
            while ((data = inputStream.read()) != -1) {
                outputStream.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Java NIO 实现：

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

public class JavaNIOFileCopy {
    public static void main(String[] args) {
        String sourceFilePath = "largeFile.txt";
        String targetFilePath = "copiedFile_NIO.txt";
        try (FileInputStream fileInputStream = new FileInputStream(sourceFilePath);
             FileOutputStream fileOutputStream = new FileOutputStream(targetFilePath);
             FileChannel sourceChannel = fileInputStream.getChannel();
             FileChannel targetChannel = fileOutputStream.getChannel()) {
            ByteBuffer byteBuffer = ByteBuffer.allocate(8192);
            while (sourceChannel.read(byteBuffer) != -1) {
                byteBuffer.flip();
                targetChannel.write(byteBuffer);
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

性能分析：在上述测试中，NIO通常会表现出更好的性能。因为NIO的 FileChannel 结合 ByteBuffer 可以一次读取和写入较大的数据块，减少了I/O操作的次数。而Java IO虽然使用了缓冲流，但每次读取和写入仍然是基于字节或字符的相对较小的操作。当文件较大时，NIO的优势更加明显。

网络I/O性能对比
- 测试场景：模拟一个简单的网络服务器，接收客户端发送的数据并返回响应。对比Java IO和NIO在处理多个客户端并发连接时的性能。
- Java IO 服务器实现：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class JavaIOServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8080)) {
            while (true) {
                Socket clientSocket = serverSocket.accept();
                new Thread(() -> {
                    try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                         PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
                        String inputLine;
                        while ((inputLine = in.readLine()) != null) {
                            System.out.println("Received: " + inputLine);
                            out.println("Response: " + inputLine);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Java NIO 服务器实现：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Set;

public class JavaNIOServer {
    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) {
                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 byteBuffer = ByteBuffer.allocate(1024);
                        int bytesRead = client.read(byteBuffer);
                        if (bytesRead > 0) {
                            byteBuffer.flip();
                            CharBuffer charBuffer = StandardCharsets.UTF_8.decode(byteBuffer);
                            System.out.println("Received: " + charBuffer.toString());
                            String response = "Response: " + charBuffer.toString();
                            ByteBuffer responseBuffer = StandardCharsets.UTF_8.encode(response);
                            client.write(responseBuffer);
                        }
                    }

                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

性能分析：在高并发网络场景下，NIO具有明显的性能优势。Java IO的服务器为每个客户端连接创建一个新线程来处理I/O操作，随着客户端数量的增加，线程创建和上下文切换的开销会变得非常大。而NIO的服务器使用选择器（Selector），一个线程可以处理多个客户端的连接和I/O事件，大大减少了线程资源的消耗，提高了系统的并发处理能力。

适用场景分析

Java IO 适用场景
- 简单应用场景：对于一些简单的、对性能要求不是特别高的应用，如小型工具程序、本地文件的简单读写等，Java IO的简单易用性使其成为一个不错的选择。例如，一个用于读取配置文件并进行简单处理的小型Java程序，使用Java IO的 FileReader 和 BufferedReader 可以快速实现功能，代码逻辑简单易懂。
- 字符处理为主的场景：当处理的主要是字符数据，并且不需要复杂的缓冲区操作时，Java IO的字符流（如 FileReader、BufferedWriter 等）可以提供方便的字符处理功能。例如，处理纯文本文件的内容替换、追加等操作，Java IO的字符流可以直接操作字符，不需要像NIO那样进行字节到字符的转换等额外操作。
Java NIO 适用场景
- 高并发网络应用：在开发高并发的网络服务器、网络爬虫等应用时，Java NIO的非阻塞I/O和选择器机制可以大大提高系统的并发处理能力。例如，一个面向大量用户的即时通讯服务器，使用NIO可以高效地处理大量客户端的连接、消息收发等操作，减少线程资源的消耗，提高服务器的性能和稳定性。
- 大数据量处理：当需要处理大量数据，如读写大文件、处理海量网络数据时，NIO的缓冲区和通道机制可以更高效地进行数据传输和处理。例如，在进行大数据文件的快速拷贝、数据的高速网络传输等场景下，NIO能够通过一次读取和写入较大的数据块，减少I/O操作次数，从而提高整体性能。

结语

Java IO和NIO各有其特点和适用场景。Java IO简单易用，适用于简单应用和字符处理场景；而Java NIO在高并发和大数据量处理方面表现出色。在实际开发中，需要根据具体的需求和场景来选择合适的I/O方式，以达到最佳的性能和开发效率。通过对两者性能的深入分析和代码示例的实践，开发者可以更好地理解它们的差异，从而在项目中做出更合理的技术选型。