当前位置： 首页 > article >正文

Java NIO基础与实战：如何提升IO操作性能

article 2025/2/23 18:06:50

Java NIO 概述

Java NIO（新 I/O）是 Java 提供的一个更为高效的 I/O 处理框架。Java NIO（New I/O）是对传统 I/O（java.io）模型的改进，它引入了非阻塞 I/O 操作和面向缓冲区的数据读写方式，解决了传统 I/O 模型中的性能瓶颈。NIO 的设计目标是使 I/O 操作更加高效，特别是在大数据量、高并发情况下，能够充分利用操作系统的底层 I/O 多路复用机制。

Java NIO 的核心概念包括：Buffer（缓冲区）、Channel（通道）、Selector（选择器）。

这些组件使得 Java NIO 在处理大量并发连接时，能够减少线程的消耗，提高系统的吞吐量。

Java NIO 与传统 IO（BIO）的区别

区别维度BIDNIO
阻塞与非阻塞传统的阻塞 I/O 模型，线程在进行 I/O 操作时会被阻塞，直到操作完成。在处理多个连接时，可能会创建大量线程，每个线程处理一个连接。这种方式的缺点是线程的开销较大，且响应速度较慢。线程数过多导致上下文切换和内存消耗大，效率低。Java NIO 提供了非阻塞 I/O 模型。在 NIO 中，I/O 操作不会阻塞当前线程，线程可以发起请求并继续执行其他任务。通过选择器（Selector），一个线程可以管理多个通道，从而减少了线程的数量，降低了上下文切换的成本，能够更有效地利用系统资源。
I/O 模每个客户端连接都会占用一个线程，线程会被阻塞直到完成 I/O 操作。使用 Channel 和 Buffer 进行数据传输，通过 Selector 实现单线程管理多个连接。
实现方式通过 InputStream/OutputStream，每个线程处理一个 I/O 操作。通过 Channel 和 Buffer，数据读写通过缓冲区进行，提供了非阻塞的读写方式。

Java NIO 的核心组件

Channel

Channel 是 NIO 中的一个接口，表示可以进行 I/O 操作的对象。Channel 可以进行读取和写入操作。

常用的 Channel 类型有：

  • FileChannel：用于文件 I/O 操作。
  • SocketChannel：用于 TCP 网络 I/O 操作。
  • ServerSocketChannel：用于接收 TCP 客户端连接。
  • DatagramChannel：用于 UDP 网络 I/O 操作。

Channel 是 IO 通讯的通道，类似于 InputStream、OutputStream，但是 Channel 是没有方向性的。

获取方式
// FileInputStream/FileOutputStream
FileInputStream fis = new FileInputStream("example.txt");
FileChannel fileInputChannel = fis.getChannel();

FileOutputStream fos = new FileOutputStream("example.txt");
FileChannel fileOutputChannel = fos.getChannel();

// RandomAccessFile
RandomAccessFile raf = new RandomAccessFile("example.txt", "rw");
FileChannel randomAccessFileChannel = raf.getChannel();

// FileChannel
FileChannel channel = FileChannel.open(Paths.get("example.txt"), StandardOpenOption.READ);

// Socket
Socket socket = new Socket("localhost", 8080);
SocketChannel socketChannel = socket.getChannel();

// ServerSocket
ServerSocket serverSocket = new ServerSocket(8080);
ServerSocketChannel serverSocketChannel = serverSocket.getChannel();

// DatagramSocket
DatagramSocket datagramSocket = new DatagramSocket(8080);
DatagramChannel datagramChannel = DatagramChannel.open(); // 需独立创建
datagramChannel.bind(datagramSocket.getLocalSocketAddress());

Buffer

NIO 中的数据传输是基于缓冲区（Buffer）的。数据读写必须先存入缓冲区，然后通过 Channel 进行传输。

Channel 读取或者写入的数据，都要写到 Buffer 中，才可以被程序操作。

Buffer 有几种类型：ByteBuffer, MappedByteBuffer, CharBuffer, IntBuffer, DoubleBuffer, LongBuffer 等。

Buffer 的主要方法：

  • put()：将数据写入缓冲区。
  • get()：从缓冲区读取数据。
  • flip()：将缓冲区从写模式切换到读模式。
  • clear()：清空缓冲区，其实只是状态的改变，并不会真正清空。
  • compact()：将缓冲区中的未读数据向前移动，便于后续写操作。

因为 Channel 没有方向性，所以 Buffer 为了区分读写，引入了读模式、写模式进行区分。

写模式：新创建的 Buffer 就是写模式、调用 clear 方法清空后。

读模式：调用 flip 方法后。

获取方式
// 创建指定大小的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);

// 获取字符集，假设文件使用 UTF-8 编码
Charset charset = StandardCharsets.UTF_8;

// 通过字符集获取
ByteBuffer encode = charset.encode("Hello, World!");

Selector

Selector 是 NIO 的一个核心组件，允许单线程通过轮询机制来监听多个 Channel 上的事件。Selector 通过轮询的方式检查是否有可用的 I/O 操作，从而避免了每个连接都占用一个线程。

Java NIO 的开发流程

  1. 获取 Channel
  2. 创建 Buffer
  3. 循环的从 Channel 中获取数据，读入到 Buffer 中。进行操作：
    1. channel.read(buffer);
    2. buffer.flip(); //设置读模式
    3. 循环从 buffer 中获取数据。
    4. buffer.get();
    5. buffer.clear(); //设置写模式

Java NIO 的工作流程

Java NIO 的工作流程可以分为以下几个步骤：

  1. 打开 Channel：通过 open() 方法打开相应的 Channel，如 FileChannel、SocketChannel 等。
  2. 配置 Buffer：创建一个 Buffer 用于读写数据，Buffer 的大小通常是固定的，写入的数据首先会被写入 Buffer 中。
  3. 读写操作：通过 Channel 从文件或网络读取数据到 Buffer 中，或者将 Buffer 中的数据写入到 Channel。
  4. Selector 监控：在非阻塞模式下，通过 Selector 监控多个 Channel 的状态。Selector 会返回一个就绪的 Channel，应用程序可以对其进行读写操作。
  5. 关闭 Channel：操作完成后，关闭 Channel 释放资源。

NIO 的主要优点

  • 非阻塞 I/O：传统的 I/O 操作是阻塞的，线程会一直等待数据的读取或写入，而 NIO 支持非阻塞 I/O，线程可以继续执行其他任务，而无需等待 I/O 操作完成。
  • 高并发：通过 Selector，NIO 允许单个线程管理多个 Channel，大大减少了线程的开销，提高了并发处理能力。
  • 高效内存管理：Buffer 直接与内存进行交互，不像传统的 I/O 需要多次数据复制，减少了内存的消耗和处理的延迟。

示例：NIO/BIO 实现文件读取

BIO 实现

BIO（Blocking I/O）模型下，每次读取文件时，线程会被阻塞，直到完成读取操作。在传统的 BIO 中，我们通过 InputStream 来读取文件内容。下面是一个使用 BIO 方式读取文件的例子：

package fun.xuewei.nio.file;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * BIO 读取文件示例
 *
 * @author 薛伟
 */
public class BioFileReader {
    
    public static void main(String[] args) throws IOException {
        // 记录开始时间
        long startTime = System.nanoTime();

        // 使用传统的 BIO 读取文件
        FileInputStream fis = new FileInputStream("example.txt");
        BufferedReader reader = new BufferedReader(new InputStreamReader(fis));

        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line); // 打印每一行
        }

        reader.close();
        fis.close();

        // 记录结束时间
        long endTime = System.nanoTime();
        System.out.println("\n\n\n");
        System.out.println("=============================================================");
        System.out.println("BIO 读取文件耗时: " + (endTime - startTime) / 1000000 + " 毫秒");
        System.out.println("=============================================================");
    }
}

在这段代码中：

  • 使用 BufferedReader 从文件流中逐行读取内容，直到文件结束。
  • 我们使用 System.nanoTime() 来记录开始和结束时间，以便测量执行时间。

NIO 实现

NIO 文件读取的方式使用 FileChannel 和 ByteBuffer，能够通过非阻塞的方式高效地处理 I/O 操作。你之前提供的代码就是一个 NIO 读取文件的示例。

package fun.xuewei.nio.file;

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

/**
 * NIO 读取文件示例
 *
 * @author 薛伟
 */
public class NioFileReader {

    public static void main(String[] args) throws IOException {
        // 记录开始时间
        long startTime = System.nanoTime();

        // 打开文件通道
        FileInputStream fis = new FileInputStream("example.txt");
        FileChannel fileChannel = fis.getChannel();

        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 获取字符集，假设文件使用 UTF-8 编码
        Charset charset = StandardCharsets.UTF_8;

        // 读取文件内容到缓冲区
        while (fileChannel.read(buffer) > 0) {
            buffer.flip(); // 切换读模式
            while (buffer.hasRemaining()) {
                // 将字节缓冲区解码为字符并打印
                System.out.print(charset.decode(buffer).toString());
            }
            buffer.clear(); // 清空缓冲区，准备下次读取
        }

        fileChannel.close();
        fis.close();

        // 记录结束时间
        long endTime = System.nanoTime();
        System.out.println("\n\n\n");
        System.out.println("=============================================================");
        System.out.println("NIO 读取文件耗时: " + (endTime - startTime) / 1000000 + " 毫秒");
        System.out.println("=============================================================");
    }
}

在这段代码中：

  • 使用 FileChannel 和 ByteBuffer 从文件中读取内容。
  • 同样通过 System.nanoTime() 来记录执行时间。

测试并对比执行时间

这两段程序的差异在于文件读取的方式：

  • BIO 使用传统的阻塞式读取方式，一次从文件中读取一行，适合小文件或者连接数较少的场景。
  • NIO 使用 FileChannel 和 ByteBuffer，通过缓冲区和通道的组合进行读取，在处理大文件时能够更高效地读取数据。

分别运行上面两个程序可以得到下面的结果：

=============================================================
BIO 读取文件耗时: 243 毫秒
=============================================================

=============================================================
NIO 读取文件耗时: 59 毫秒
=============================================================

通过执行时间的比较，可以得出以下结论：

  • BIO：每次读取数据时，线程会被阻塞，直到读取完数据。对于每个 I/O 操作，都需要占用一个线程进行阻塞，性能较差。
  • NIO：通过缓冲区和通道的组合，能够在一个线程中高效地读取文件，并且避免了阻塞操作。在读取大文件时，NIO 的优势尤为明显，因为它可以更好地利用 CPU 和内存资源，减少线程的创建和上下文切换。

示例：NIO 实现零拷贝文件复制

在 Java NIO 中，通过利用 FileChannel 和操作系统提供的 零拷贝（Zero-Copy）机制，可以实现高效的文件复制。零拷贝指的是在数据传输过程中，不需要将数据复制到用户空间，而是直接在内核空间进行操作，减少了内存拷贝和 CPU 的消耗。

在文件复制的场景中，使用 FileChannel.transferTo() 或 FileChannel.transferFrom() 可以实现零拷贝。这些方法直接将数据从一个通道传输到另一个通道，避免了中间缓冲区的创建和数据复制。

使用 transferTo() 方法进行零拷贝文件复制。FileChannel.transferTo() 方法允许将文件内容从一个 FileChannel 直接传输到另一个 FileChannel，通常用于文件复制。

示例代码

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public class NioFileCopyZeroCopy {
    public static void main(String[] args) {
        // 源文件路径和目标文件路径
        String sourceFilePath = "source.txt";
        String destFilePath = "destination.txt";

        try (FileInputStream fis = new FileInputStream(sourceFilePath);
             FileOutputStream fos = new FileOutputStream(destFilePath)) {

            // 获取源文件和目标文件的 FileChannel
            FileChannel sourceChannel = fis.getChannel();
            FileChannel destChannel = fos.getChannel();

            // 使用 transferTo 实现零拷贝文件复制
            long position = 0; // 从文件的起始位置开始复制
            long size = sourceChannel.size(); // 获取源文件的大小
            long bytesTransferred = 0;

            // 执行零拷贝：从源文件到目标文件
            while (bytesTransferred < size) {
                bytesTransferred += sourceChannel.transferTo(position + bytesTransferred, size - bytesTransferred, destChannel);
            }

            System.out.println("文件复制完成！");

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

代码解析

  1. 打开文件流和通道：
    • FileInputStream 和 FileOutputStream 被用来读取和写入文件。
    • 通过 fis.getChannel() 获取源文件的 FileChannel，通过 fos.getChannel() 获取目标文件的 FileChannel。
  2. transferTo 实现零拷贝复制：
    • sourceChannel.transferTo(position, size, destChannel) 是 FileChannel 提供的零拷贝复制方法。它会将源文件的内容从指定位置（position）复制到目标通道 destChannel，直到复制完指定大小的数据。
    • position 是文件的起始位置，size 是要复制的字节数。
    • 复制过程中，操作系统会直接在内核空间进行数据传输，减少了用户空间到内核空间的多次数据复制，从而提高了效率。
  3. 循环传输：
    • 在实际操作中，如果文件很大，可能需要分段传输。通过循环传输数据，直到整个文件复制完成。
  4. 关闭资源：
    • 使用 try-with-resources 语法自动关闭文件流和通道，确保资源释放。

零拷贝机制的优势

  • 性能提升：零拷贝减少了用户空间和内核空间之间的多次内存拷贝，降低了 CPU 的使用和内存消耗，特别是在传输大文件时，性能更为显著。
  • 高效数据传输：零拷贝直接在操作系统内核空间进行数据传输，避免了中间缓冲区的创建和数据拷贝过程，提高了数据传输速度。

注意事项

  1. 文件大小：当文件非常大时，零拷贝可以大大提升性能，因为它减少了不必要的内存拷贝操作。
  2. 操作系统支持：零拷贝是操作系统提供的功能，确保操作系统支持零拷贝机制。在 Linux 和 Unix 系统上，通常是默认支持的。Windows 操作系统也支持 transferTo() 和 transferFrom() 方法，但实现细节可能有所不同。
  3. 异常处理：实际使用时，注意添加适当的异常处理逻辑，确保文件流和通道的正确关闭。

示例：NIO/BIO 客户端与服务器通信

BIO 版本：客户端与服务器通信

在 BIO 模型下，每个连接都会在一个独立的线程中进行处理，线程会阻塞直到 I/O 操作完成。以下是使用 BIO 实现的客户端与服务器通信的代码。

BIO 服务器端
package fun.xuewei.nio.network;

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

/**
 * BIO 服务器端
 *
 * @author 薛伟
 */
public class BioServer {
    
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO 服务器启动，等待连接...");
        while (true) {
            // 阻塞直到有客户端连接
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端连接：" + clientSocket.getInetAddress());
            // 获取输入流并读取数据
            BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String message = reader.readLine(); // 阻塞直到收到消息
            System.out.println("收到消息：" + message);
            // 给客户端发送响应
            PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true);
            writer.println("消息已收到");
            // 关闭连接
            clientSocket.close();
        }
    }
}
BIO 客户端
package fun.xuewei.nio.network;

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

/**
 * BIO客户端
 *
 * @author 薛伟
 */
public class BioClient {
    
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8080);
        System.out.println("连接到服务器...");
        // 获取输出流并发送数据
        PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
        writer.println("你好，服务器！");
        // 获取输入流并读取服务器响应
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String response = reader.readLine();
        System.out.println("服务器回应: " + response);
        // 关闭连接
        socket.close();
    }
}

NIO 版本：客户端与服务器通信

在 NIO 模型下，我们使用 SocketChannel 和 ServerSocketChannel 来实现客户端与服务器之间的通信，并且可以通过 Selector 来管理多个连接。以下是使用 NIO 实现的客户端与服务器通信的代码。

NIO 服务器端
package fun.xuewei.nio.network;

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.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;

/**
 * Nio 服务器端
 *
 * @author 薛伟
 */
public class NioServer {

    public static void main(String[] args) throws IOException {
        // 创建 Selector 和 ServerSocketChannel
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        // 绑定端口
        serverSocketChannel.socket().bind(new InetSocketAddress(8080));
        // 注册到 Selector
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NIO 服务器启动，等待连接...");
        // 获取字符集，假设文件使用 UTF-8 编码
        Charset charset = StandardCharsets.UTF_8;
        while (true) {
            // 等待事件发生
            selector.select();
            // 获取所有已准备就绪的 SelectionKey
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                // 处理接收客户端连接
                if (key.isAcceptable()) {
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = serverChannel.accept();
                    clientChannel.configureBlocking(false);
                    // 将客户端连接注册到 Selector
                    clientChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接：" + clientChannel.getRemoteAddress());
                }
                // 处理读取客户端数据
                if (key.isReadable()) {
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(256);
                    int bytesRead = clientChannel.read(buffer);
                    if (bytesRead == -1) {
                        clientChannel.close();
                        System.out.println("客户端断开连接");
                    } else {
                        buffer.flip();
                        // 将字节缓冲区解码为字符并打印
                        String message = charset.decode(buffer).toString();
                        System.out.println("收到消息：" + message);
                        // 给客户端发送响应
                        buffer.clear();
                        String response = "消息已收到";
                        buffer.put(response.getBytes(charset));  // 使用正确的字符集编码
                        buffer.flip();
                        clientChannel.write(buffer);
                    }
                }
            }
        }
    }
}
NIO 客户端
package fun.xuewei.nio.network;

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

/**
 * NIO 客户端
 *
 * @author 薛伟
 */
public class NioClient {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost", 8080));
        // 获取字符集，假设文件使用 UTF-8 编码
        Charset charset = StandardCharsets.UTF_8;
        // 发送消息到服务器
        ByteBuffer buffer = ByteBuffer.allocate(256);
        String message = "你好，NIO 服务器！";
        buffer.put(message.getBytes(charset));  // 使用正确的字符集编码
        buffer.flip();
        socketChannel.write(buffer);
        // 接收服务器响应
        buffer.clear();
        socketChannel.read(buffer);
        buffer.flip();
        // 将字节缓冲区解码为字符并打印
        String response = charset.decode(buffer).toString();
        System.out.println("服务器回应: " + response);
        // 关闭 SocketChannel
        socketChannel.close();
    }
}
总结
  • 在并发请求数量较少时，BIO 和 NIO 性能差距不大。
  • 随着并发请求数增多，BIO 会因为线程过多导致性能下降，而 NIO 通过事件驱动机制，能够较好地处理高并发请求。

实际场景与应用

  • 高并发 Web 服务：NIO 适用于需要处理大量并发连接的场景，例如高并发的 Web 服务器、即时通讯系统、视频流服务等。
  • 大文件传输：NIO 可以高效地处理大文件的读取和写入，避免了传统 I/O 中频繁的阻塞操作。
  • 非阻塞网络服务：如消息队列、数据库连接池等，NIO 提供了一种高效的方式来管理网络连接。

http://www.kler.cn/a/548132.html

相关文章：

  • 【openGauss】6.0.0企业版单节点安装，配置刷新
  • 【鸿蒙HarmonyOS Next实战开发】lottie动画库
  • 【Python爬虫(3)】解锁Python爬虫技能树：深入理解模块与包
  • 20250214在ubuntu20.04下使用obs studio录制外挂的1080p的USB摄像头【下载安装】
  • PDF工具，个人作品，免费分享
  • 教程 | 从零部署到业务融合：DeepSeek R1 私有化部署实战指南
  • （rancher） k8s ingress 屏蔽 nginx版本信息
  • 解读 Flink Source 接口重构后的 KafkaSource
  • SIP中常见的服务器类型
  • Win11配置wsl、ubuntu、docker
  • Leetcode 394 字符串解码
  • DeepSeek崛起：中国AI产业的颠覆者与重构者
  • WEB安全--SQL注入--二次注入
  • haproxy详解笔记
  • 【第9章：计算机视觉实战—9.3 计算机视觉在医疗影像分析中的应用案例】
  • 机器学习实战(3)：线性回归——预测连续变量
  • 恩智浦：将开发文档迁移到DITA/XML
  • AWS Fargate 部署流程图及说明
  • Visual Studio Code支持WSL，直接修改linux/ubuntu中的文件
  • unity 为什么保存场景时要求重新选择文件夹