90. 文件读写的 NIO 实现

一、NIO 概述

NIO 与传统 IO 的区别

1. 基本概念

• 传统 IO（BIO）：基于**流（Stream）**模型，数据按字节顺序单向传输，读写是阻塞的（Blocking）。
• NIO（New IO）：基于**通道（Channel）和缓冲区（Buffer）**模型，支持非阻塞（Non-blocking）和选择器（Selector）机制，数据可双向传输。

2. 核心差异

特性	传统 IO (BIO)	NIO
数据流方向	单向（输入流/输出流）	双向（Channel 可读可写）
阻塞模式	阻塞式（线程等待 IO 完成）	支持非阻塞（立即返回结果）
数据单位	字节/字符流	缓冲区（Buffer）
多路复用	需多线程处理多个连接	单线程通过 Selector 管理多通道
性能	高延迟，线程资源消耗大	低延迟，高吞吐量

3. 使用场景

• 传统 IO：适合简单、低并发的文件操作或网络通信（如小文件读写）。
• NIO：适合高并发、高吞吐场景（如聊天服务器、文件传输服务）。

4. 代码示例对比

传统 IO 读取文件

try (InputStream in = new FileInputStream("file.txt")) {
    int data;
    while ((data = in.read()) != -1) { // 阻塞读取
        System.out.print((char) data);
    }
}

NIO 读取文件

try (FileChannel channel = FileChannel.open(Paths.get("file.txt"))) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    while (channel.read(buffer) != -1) { // 非阻塞读取（需配置）
        buffer.flip();
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
        buffer.clear();
    }
}

5. 注意事项

• NIO 复杂性：需手动管理缓冲区（flip()/clear()）和选择器，代码更复杂。
• 传统 IO 资源消耗：每个连接需独立线程，不适合高并发。
• NIO 适用性：对低并发小文件操作，传统 IO 可能更高效。

---

NIO 的核心组件

Buffer（缓冲区）

• 定义：Buffer 是 NIO 中用于存储数据的容器，本质上是一块内存区域，支持数据的读写操作。
• 核心属性：
  • capacity：缓冲区容量（固定大小）。
  • position：当前读写位置。
  • limit：可读写数据的边界。
  • mark：临时标记位置（可通过 reset() 恢复）。
• 常见类型：ByteBuffer（最常用）、CharBuffer、IntBuffer 等。
• 使用场景：所有 Channel 的读写操作都必须通过 Buffer 完成。
• 示例代码：

  ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配堆内存
  buffer.put("Hello".getBytes()); // 写入数据
  buffer.flip(); // 切换为读模式
  while (buffer.hasRemaining()) {
      System.out.print((char) buffer.get()); // 逐个字节读取
  }
  

Channel（通道）

• 定义：Channel 是 NIO 中用于传输数据的双向管道（可读可写），类比传统 IO 的流，但支持异步和非阻塞操作。
• 常见实现：
  • FileChannel：文件读写。
  • SocketChannel / ServerSocketChannel：TCP 网络通信。
  • DatagramChannel：UDP 通信。
• 特点：
  • 数据必须通过 Buffer 传输。
  • 支持分散（Scatter）和聚集（Gather）操作（读写多个 Buffer）。
• 示例代码（文件复制）：

  try (FileChannel src = FileChannel.open(Path.of("src.txt"));
       FileChannel dest = FileChannel.open(Path.of("dest.txt"), StandardOpenOption.CREATE)) {
      src.transferTo(0, src.size(), dest); // 零拷贝高效传输
  }
  

Selector（选择器）

• 定义：Selector 是 NIO 实现多路复用的核心组件，允许单线程监听多个 Channel 的 IO 事件（如连接、读、写）。
• 核心机制：
  • 通过 SelectionKey 注册事件（OP_READ、OP_WRITE 等）。
  • select() 方法阻塞等待就绪的 Channel。
• 使用场景：高并发网络服务器（如聊天室、游戏服务器）。
• 示例代码（简易服务器）：

  Selector selector = Selector.open();
  ServerSocketChannel server = ServerSocketChannel.open();
  server.bind(new InetSocketAddress(8080));
  server.configureBlocking(false);
  server.register(selector, SelectionKey.OP_ACCEPT); // 注册接受连接事件
  
  while (true) {
      selector.select(); // 阻塞直到有事件
      Set<SelectionKey> keys = selector.selectedKeys();
      for (SelectionKey key : keys) {
          if (key.isAcceptable()) {
              SocketChannel client = server.accept();
              client.configureBlocking(false);
              client.register(selector, SelectionKey.OP_READ); // 注册读事件
          }
          // 处理其他事件...
      }
  }
  

注意事项

1. Buffer 模式切换：写转读需调用 flip()，读转写需调用 clear() 或 compact()。
2. Channel 非阻塞：需显式调用 configureBlocking(false)。
3. Selector 空轮询：JDK 的 select() 可能因 Bug 立即返回，需手动处理（或使用 Netty 等框架）。

---

NIO 的非阻塞特性

概念定义

NIO（New I/O）的非阻塞特性指的是在进行 I/O 操作时，线程不会被阻塞，可以继续执行其他任务。与传统的阻塞 I/O 不同，非阻塞 I/O 通过轮询机制或事件驱动的方式检查 I/O 操作是否就绪，从而避免了线程的等待。

核心组件

1. Selector：用于监听多个 Channel 的事件（如连接就绪、读就绪、写就绪）。
2. Channel：支持非阻塞操作的 I/O 通道（如 SocketChannel、ServerSocketChannel）。
3. Buffer：数据读写的中转缓冲区。

使用场景

• 高并发服务器（如聊天服务器、游戏服务器）。
• 需要同时处理大量连接的场景（如文件传输、实时通信）。
• 避免线程阻塞，提高资源利用率。

非阻塞 vs 阻塞

特性	非阻塞 I/O	阻塞 I/O
线程状态	无需等待，可执行其他任务	线程挂起，等待操作完成
资源占用	更高效（单线程多连接）	需要多线程支持
适用场景	高并发	低并发或简单任务

示例代码

// 非阻塞 SocketChannel 示例
try (SocketChannel socketChannel = SocketChannel.open()) {
    socketChannel.configureBlocking(false); // 设置为非阻塞模式
    socketChannel.connect(new InetSocketAddress("example.com", 80));

    while (!socketChannel.finishConnect()) {
        // 可以在这里执行其他任务
        System.out.println("连接未就绪，继续其他操作...");
    }

    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int bytesRead = socketChannel.read(buffer); // 非阻塞读取
    if (bytesRead == -1) {
        System.out.println("读取完成");
    }
} catch (IOException e) {
    e.printStackTrace();
}

常见误区

1. 性能误解：非阻塞不总是比阻塞快，高并发时优势更明显。
2. 事件处理遗漏：未正确处理 Selector 的事件（如 OP_READ、OP_WRITE）可能导致数据丢失。
3. 缓冲区管理：未正确重置 Buffer（如 flip()、clear()）会导致读写错误。

注意事项

• 非阻塞模式下，connect()、read()、write() 可能返回部分结果或不立即完成。
• 使用 Selector 时需注意事件循环的效率，避免空轮询。
• 多线程环境下需确保 Channel 和 Buffer 的线程安全。

---

二、Buffer 缓冲区

Buffer 的基本结构

Buffer 是 Java NIO 中用于高效读写数据的核心组件，本质上是一块内存区域，通常包装了基本类型数组（如 byte[]）。其核心操作通过三个关键属性控制：position、limit 和 capacity。

核心属性

1. Capacity（容量）

   • Buffer 的固定大小，创建时指定，不可修改。
   • 表示底层数组的总长度（如 ByteBuffer.allocate(1024) 的容量为 1024）。

2. Position（当前位置）

   • 初始值为 0，表示下一个读写操作的起始索引。
   • 写模式：每写入一个数据，position 自增 1（指向下一个可写位置）。
   • 读模式：调用 flip() 后重置为 0，每读取一个数据，position 自增 1。

3. Limit（上限）

   • 写模式：初始等于 capacity，表示最多能写入的数据量。
   • 读模式：flip() 后设置为写模式时的 position 值，表示可读取的数据边界。

状态转换示例

ByteBuffer buffer = ByteBuffer.allocate(10); // capacity=10, position=0, limit=10

// 写入数据
buffer.put((byte) 1); // position=1, limit=10
buffer.put((byte) 2); // position=2, limit=10

// 切换为读模式
buffer.flip(); // position=0, limit=2 (原position值), capacity=10

// 读取数据
byte a = buffer.get(); // position=1, limit=2
byte b = buffer.get(); // position=2, limit=2

注意事项

1. 读写切换必须显式调用 flip() 或 rewind()，否则 position 和 limit 不会重置。
2. clear() 不会清空数据，仅重置 position=0、limit=capacity，为重新写入做准备。
3. compact() 保留未读数据：将未读数据移动到 Buffer 头部，position 指向剩余空间起始位置。

常见误区

• 直接操作底层数组：通过 array() 获取数组时需确保 Buffer 非只读，且需考虑 position 偏移。
• 越界访问：position 超过 limit 会抛出 BufferUnderflowException 或 BufferOverflowException。

---

常用 Buffer 类型

在 Java NIO 中，Buffer 是数据读写的核心容器，用于在通道（Channel）和程序之间传输数据。以下是几种常用的 Buffer 类型：

ByteBuffer

• 定义：用于处理字节数据的缓冲区，是 NIO 中最常用的 Buffer 类型。
• 特点：
  • 可以存储任意类型的二进制数据（如文件、网络数据）。
  • 支持直接内存（allocateDirect）和堆内存（allocate）分配。
  • 提供 put() 和 get() 方法读写字节。
• 使用场景：
  • 文件 I/O 操作（如 FileChannel 读写）。
  • 网络数据传输（如 SocketChannel）。
• 示例代码：

  ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配堆内存
  buffer.put((byte) 10); // 写入字节
  buffer.flip(); // 切换为读模式
  byte b = buffer.get(); // 读取字节
  

CharBuffer

• 定义：用于处理字符数据的缓冲区，基于 CharSequence 接口实现。
• 特点：
  • 支持字符编码（如 UTF-8）和解码。
  • 提供 put() 和 get() 方法读写字符。
• 使用场景：
  • 文本文件读写（需配合 Charset 编解码）。
  • 字符串处理（如正则表达式匹配）。
• 示例代码：

  CharBuffer buffer = CharBuffer.allocate(100);
  buffer.put("Hello"); // 写入字符
  buffer.flip();
  char c = buffer.get(); // 读取字符
  

IntBuffer / LongBuffer / FloatBuffer / DoubleBuffer

• 定义：分别用于处理 int、long、float、double 类型数据的缓冲区。
• 特点：
  • 提供类型化的 put() 和 get() 方法（如 putInt()、getDouble()）。
  • 适合处理数值型数据，避免手动转换。
• 使用场景：
  • 数值计算（如矩阵运算）。
  • 二进制协议解析（如网络协议中的数值字段）。
• 示例代码：

  IntBuffer buffer = IntBuffer.allocate(10);
  buffer.put(100); // 写入 int
  buffer.flip();
  int num = buffer.get(); // 读取 int
  

MappedByteBuffer

• 定义：ByteBuffer 的子类，通过内存映射文件（Memory-Mapped File）直接操作文件数据。
• 特点：
  • 文件内容直接映射到虚拟内存，读写效率极高。
  • 适合大文件操作（无需频繁 I/O）。
• 使用场景：
  • 大文件随机访问（如数据库文件）。
  • 高频读写场景（如日志处理）。
• 示例代码：

  FileChannel channel = FileChannel.open(Paths.get("data.txt"), StandardOpenOption.READ);
  MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
  byte b = buffer.get(); // 直接读取文件内容
  

注意事项

1. 模式切换：Buffer 需通过 flip() 切换读写模式，否则可能导致数据错误。
2. 容量限制：Buffer 大小固定，写入超出容量会抛出 BufferOverflowException。
3. 直接内存：ByteBuffer.allocateDirect() 分配的内存不受 JVM 垃圾回收管理，需谨慎使用以避免内存泄漏。

---

Buffer 的分配方式

在 Java NIO 中，Buffer 是用于高效读写数据的核心组件之一。Buffer 的分配方式主要有两种：allocate 和 wrap。

allocate 方法

allocate 方法用于分配一个新的缓冲区，并指定其容量。分配后的缓冲区是堆内存缓冲区，即在 JVM 堆上分配内存。

语法

ByteBuffer buffer = ByteBuffer.allocate(capacity);

• capacity：缓冲区的容量（单位：字节）。

特点

1. 分配的是堆内存，受 JVM 垃圾回收管理。
2. 适用于常规的 I/O 操作。
3. 分配后，缓冲区的所有字节初始化为 0。

示例

ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配 1KB 的缓冲区

wrap 方法

wrap 方法用于包装现有的字节数组，将其转换为 ByteBuffer。这种方式不会分配新的内存，而是直接使用现有的数组。

语法

ByteBuffer buffer = ByteBuffer.wrap(byteArray);

• byteArray：要包装的字节数组。

特点

1. 直接使用现有数组，不分配新内存。
2. 缓冲区的修改会直接影响原数组。
3. 适用于已有数据需要转换为 Buffer 的场景。

示例

byte[] data = new byte[1024];
ByteBuffer buffer = ByteBuffer.wrap(data); // 包装现有数组

注意事项

1. allocate vs allocateDirect：

   • allocate 分配的是堆内存，而 allocateDirect 分配的是直接内存（不受 JVM 垃圾回收管理，适合高频 I/O）。
   • wrap 仅适用于堆内存的字节数组。

2. 缓冲区的读写模式：

   • 无论是 allocate 还是 wrap，分配的缓冲区初始处于写模式，可以通过 flip() 切换为读模式。

3. 性能考虑：

   • wrap 适用于已有数据的快速转换，而 allocate 适用于需要独立缓冲区的场景。

代码对比

// 分配新缓冲区
ByteBuffer allocatedBuffer = ByteBuffer.allocate(1024);

// 包装现有数组
byte[] data = new byte[1024];
ByteBuffer wrappedBuffer = ByteBuffer.wrap(data);

---

Buffer 的读写操作（put/get）

概念定义

Buffer 是 Java NIO 中的一个核心组件，用于高效地读写数据。它本质上是一个固定大小的内存块，可以存储特定类型的数据（如 ByteBuffer、CharBuffer 等）。Buffer 的读写操作主要通过 put() 和 get() 方法实现。

核心方法

1. put()：将数据写入 Buffer。
   • put(byte b)：写入单个字节。
   • put(byte[] src)：写入字节数组。
   • put(ByteBuffer src)：从另一个 Buffer 写入数据。
2. get()：从 Buffer 读取数据。
   • get()：读取单个字节。
   • get(byte[] dst)：读取数据到字节数组。
   • get(byte[] dst, int offset, int length)：读取指定长度的数据到数组的指定位置。

使用场景

• 文件读写：通过 FileChannel 和 Buffer 实现高效文件操作。
• 网络通信：在 SocketChannel 中传输数据。
• 数据处理：对内存中的数据进行批量操作。

示例代码

import java.nio.ByteBuffer;

public class BufferExample {
    public static void main(String[] args) {
        // 分配一个容量为 10 的 ByteBuffer
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 写入数据
        buffer.put((byte) 'A');
        buffer.put((byte) 'B');
        buffer.put((byte) 'C');

        // 切换为读模式
        buffer.flip();

        // 读取数据
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
        // 输出: ABC
    }
}

注意事项

1. 读写模式切换：
   • 写入数据后需调用 flip() 切换为读模式。
   • 读取数据后需调用 clear() 或 compact() 切换为写模式。
2. 越界检查：
   • 读写时需检查 remaining() 或 hasRemaining()，避免 BufferUnderflowException 或 BufferOverflowException。
3. 直接缓冲区：
   • 使用 allocateDirect() 分配的直接缓冲区性能更高，但创建成本较高，适合长期使用的大缓冲区。

常见误区

• 未切换模式：直接读取刚写入的 Buffer 会导致数据错误（需先 flip()）。
• 忽略位置指针：多次读写时需注意 position 和 limit 指针的变化。

---

Buffer 的翻转（flip）与清空（clear）

概念定义

• flip()：将 Buffer 从写模式切换到读模式。它将 limit 设置为当前 position，然后将 position 重置为 0。
• clear()：将 Buffer 重置为写模式。它将 position 设为 0，limit 设为 capacity，但不会真正清空数据，只是标记可覆盖。

使用场景

• flip()：写入数据后，需要读取 Buffer 时调用（如 channel.write(buffer) 后要 channel.read(buffer)）。
• clear()：读取完数据后，需要重新写入时调用（如循环读写时复用 Buffer）。

注意事项

1. flip() 后未读完数据：若未读完直接写入，剩余数据会被新数据覆盖。此时可用 compact() 压缩剩余数据到 Buffer 头部。
2. clear() 的“伪清空”：数据仍在内存中，只是逻辑上可覆盖，敏感数据需手动覆写。
3. 重复调用 flip()：连续调用会逐步缩小可读范围（因 limit 被设为前一次的 position）。

示例代码

ByteBuffer buffer = ByteBuffer.allocate(1024);

// 写入数据后翻转
buffer.put("Hello".getBytes());
buffer.flip();  // 切换为读模式，position=0, limit=5

// 读取数据后清空
while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get());
}
buffer.clear();  // 切换为写模式，position=0, limit=1024

---

三、Channel 通道

Channel 的基本概念

定义

Channel（通道）是 Java NIO 中的一个核心组件，用于在字节缓冲区（ByteBuffer）和数据源/目标（如文件、套接字等）之间传输数据。它类似于传统 I/O 中的流（Stream），但支持双向读写和非阻塞操作。

核心特点

1. 双向性：可以同时进行读/写（如 FileChannel 支持 read() 和 write()）。
2. 非阻塞模式（需配合 Selector）：适用于高并发场景。
3. 直接操作缓冲区：数据通过 ByteBuffer 传输，减少内存拷贝。

常见实现类

• FileChannel：文件读写
• SocketChannel/ServerSocketChannel：TCP 网络通信
• DatagramChannel：UDP 通信

基础示例（文件拷贝）

try (FileChannel srcChannel = FileChannel.open(Path.of("source.txt"));
     FileChannel destChannel = FileChannel.open(Path.of("target.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    srcChannel.transferTo(0, srcChannel.size(), destChannel); // 零拷贝优化
}

注意事项

1. 资源释放：必须调用 close() 或使用 try-with-resources。
2. 线程安全：多数 Channel 实现非线程安全，需自行同步。
3. 缓冲区管理：读写前需正确翻转（flip()）或清空（clear()）ByteBuffer。

与传统 I/O 的对比

特性	Channel (NIO)	Stream (IO)
方向	双向	单向（Input/Output）
阻塞	可非阻塞	仅阻塞
性能优化	零拷贝（如 transferTo）	无

---

主要 Channel 类型

在 Java NIO 中，Channel 是用于 I/O 操作的抽象接口，代表与实体（如文件、网络套接字等）的连接。以下是几种核心的 Channel 实现：

FileChannel

• 定义：用于文件的读写操作，支持随机访问文件内容。
• 特点：
  • 通过 FileInputStream、FileOutputStream 或 RandomAccessFile 的 getChannel() 方法获取。
  • 支持内存映射文件（map() 方法），直接操作堆外内存提升性能。
  • 提供文件锁（lock()/tryLock()）机制。
• 示例代码：

  try (FileChannel channel = new RandomAccessFile("test.txt", "rw").getChannel()) {
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      channel.read(buffer); // 读取文件到缓冲区
  }
  

SocketChannel

• 定义：用于 TCP 网络通信的客户端通道，支持非阻塞模式。
• 特点：
  • 通过 SocketChannel.open() 创建，需调用 connect() 连接服务端。
  • 配合 Selector 实现多路复用（如高并发服务器）。
• 示例代码：

  SocketChannel channel = SocketChannel.open();
  channel.connect(new InetSocketAddress("localhost", 8080));
  ByteBuffer buffer = ByteBuffer.wrap("Hello".getBytes());
  channel.write(buffer); // 发送数据
  

ServerSocketChannel

• 定义：监听 TCP 连接的服务器端通道，接受客户端连接请求。
• 特点：
  • 通过 ServerSocketChannel.open() 创建，绑定端口后调用 accept() 接收连接。
  • 返回的 SocketChannel 对象用于与客户端通信。
• 示例代码：

  ServerSocketChannel server = ServerSocketChannel.open();
  server.bind(new InetSocketAddress(8080));
  SocketChannel client = server.accept(); // 阻塞等待连接
  

DatagramChannel

• 定义：用于 UDP 协议的无连接网络通信。
• 特点：
  • 通过 DatagramChannel.open() 创建，可调用 send()/receive() 收发数据包。
  • 不保证数据顺序和可靠性。
• 示例代码：

  DatagramChannel channel = DatagramChannel.open();
  channel.bind(new InetSocketAddress(9090));
  ByteBuffer buffer = ByteBuffer.allocate(1024);
  channel.receive(buffer); // 接收数据包
  

注意事项

1. 资源释放：Channel 需调用 close() 或使用 try-with-resources 确保释放。
2. 缓冲区操作：读写前需正确设置 Buffer 的 position 和 limit。
3. 非阻塞模式：SocketChannel/ServerSocketChannel 需配置 configureBlocking(false) 才能配合 Selector 使用。

---

Channel 的打开与关闭

概念定义

在 Java NIO 中，Channel 是用于 I/O 操作的抽象接口，类似于传统 I/O 中的流（Stream），但支持双向读写（读和写可以在同一个 Channel 中完成）。Channel 必须显式打开和关闭，以确保资源正确释放。

主要实现类

• FileChannel：用于文件读写。
• SocketChannel 和 ServerSocketChannel：用于 TCP 网络通信。
• DatagramChannel：用于 UDP 网络通信。

打开 Channel

不同 Channel 的打开方式不同：

1. FileChannel
   通过 FileInputStream、FileOutputStream 或 RandomAccessFile 获取：

   // 通过 FileInputStream 打开（只读）
   FileInputStream fis = new FileInputStream("file.txt");
   FileChannel readChannel = fis.getChannel();
   
   // 通过 FileOutputStream 打开（只写）
   FileOutputStream fos = new FileOutputStream("file.txt");
   FileChannel writeChannel = fos.getChannel();
   
   // 通过 RandomAccessFile 打开（读写模式）
   RandomAccessFile raf = new RandomAccessFile("file.txt", "rw");
   FileChannel rwChannel = raf.getChannel();
   

2. SocketChannel 和 ServerSocketChannel
   直接通过静态方法打开：

   // 客户端 SocketChannel
   SocketChannel socketChannel = SocketChannel.open();
   socketChannel.connect(new InetSocketAddress("localhost", 8080));
   
   // 服务端 ServerSocketChannel
   ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
   serverSocketChannel.bind(new InetSocketAddress(8080));
   

3. DatagramChannel
   类似网络 Channel：

   DatagramChannel datagramChannel = DatagramChannel.open();
   

关闭 Channel

Channel 必须显式关闭以释放系统资源，通常通过 close() 方法实现：

channel.close();

注意事项

1. 资源泄漏风险
   未关闭 Channel 会导致文件句柄或网络连接泄漏。推荐使用 try-with-resources 语法自动关闭：

   try (FileChannel channel = FileChannel.open(Paths.get("file.txt"))) {
       // 操作 Channel
   } // 自动关闭
   

2. 关闭顺序
   如果 Channel 是通过流（如 FileInputStream）获取的，关闭 Channel 也会关闭底层流，反之亦然。避免重复关闭。

3. 非阻塞模式下的关闭
   网络 Channel（如 SocketChannel）在非阻塞模式下，关闭时可能仍有未完成的操作，需确保数据已处理完毕。

示例代码

// FileChannel 示例（读写文件）
try (FileChannel channel = FileChannel.open(Paths.get("test.txt"), 
     StandardOpenOption.READ, StandardOpenOption.WRITE)) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    channel.read(buffer); // 读取数据
    buffer.flip();
    channel.write(buffer); // 写入数据
} // 自动关闭

// SocketChannel 示例
try (SocketChannel socketChannel = SocketChannel.open(
     new InetSocketAddress("localhost", 8080))) {
    ByteBuffer buffer = ByteBuffer.wrap("Hello".getBytes());
    socketChannel.write(buffer);
} // 自动关闭

总结

• Channel 是 NIO 的核心组件，需显式管理生命周期。
• 使用 try-with-resources 确保资源释放。
• 根据类型选择正确的打开方式（文件、网络等）。

---

Channel 与 Buffer 的交互

基本概念

• Channel：NIO 中用于数据传输的通道，支持双向读写（如文件、网络套接字）。
• Buffer：数据容器，本质是一块内存区域，用于 Channel 读写时的数据暂存。

核心交互流程

1. 写入数据（Channel → Buffer）

   FileChannel channel = FileChannel.open(Paths.get("test.txt"), StandardOpenOption.READ);
   ByteBuffer buffer = ByteBuffer.allocate(1024);
   int bytesRead = channel.read(buffer); // 数据从 Channel 写入 Buffer
   

2. 读取数据（Buffer → Channel）

   buffer.flip(); // 切换为读模式
   FileChannel outChannel = FileChannel.open(Paths.get("output.txt"), StandardOpenOption.WRITE);
   outChannel.write(buffer); // 数据从 Buffer 写入 Channel
   

关键操作

• flip()：写模式 → 读模式（重置 position 为 0）
• clear() / compact()：读模式 → 写模式（前者清空整个 Buffer，后者保留未读数据）
• rewind()：重置 position 为 0 重新读取

注意事项

1. 模式切换必须显式调用（如忘记 flip() 会导致读取到空数据）
2. Buffer 需初始化容量（过小会导致多次读写，过大浪费内存）
3. 非阻塞模式下（如 SocketChannel），read() 可能返回 0，需配合 Selector 使用

典型应用场景

• 大文件分块读写（避免一次性加载内存）
• 网络通信中的非阻塞数据传输
• 内存映射文件（MappedByteBuffer）的高性能操作

---

四、文件读写操作

FileChannel 的打开方式

1. 通过 FileInputStream/FileOutputStream 打开

• 定义：通过传统的文件输入/输出流获取 FileChannel，适用于文件读写操作。
• 特点：
  • 通过 FileInputStream 打开的通道只读。
  • 通过 FileOutputStream 打开的通道只写。
• 示例代码：

  // 只读通道
  try (FileInputStream fis = new FileInputStream("test.txt");
       FileChannel readChannel = fis.getChannel()) {
      // 读取操作
  }
  
  // 只写通道
  try (FileOutputStream fos = new FileOutputStream("test.txt");
       FileChannel writeChannel = fos.getChannel()) {
      // 写入操作
  }
  

2. 通过 RandomAccessFile 打开

• 定义：通过 RandomAccessFile 获取 FileChannel，支持读写且可随机访问文件。
• 特点：
  • 通过 RandomAccessFile 打开的通道可设置为读写模式（"rw"）。
  • 支持文件指针的随机定位（position() 方法）。
• 示例代码：

  try (RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
       FileChannel channel = raf.getChannel()) {
      // 读写操作
      channel.position(10); // 移动文件指针
  }
  

3. 通过 Path 和 Files 工具类打开

• 定义：Java 7+ 引入的 NIO.2 API，通过 Files.newByteChannel() 或 Path 直接打开通道。
• 特点：
  • 支持更灵活的参数配置（如 StandardOpenOption）。
  • 可指定读写模式、文件创建选项等。
• 示例代码：

  Path path = Paths.get("test.txt");
  
  // 只读通道
  try (FileChannel readChannel = FileChannel.open(path, StandardOpenOption.READ)) {
      // 读取操作
  }
  
  // 读写通道（文件不存在时创建）
  try (FileChannel writeChannel = FileChannel.open(
          path,
          StandardOpenOption.READ,
          StandardOpenOption.WRITE,
          StandardOpenOption.CREATE)) {
      // 读写操作
  }
  

4. 注意事项

1. 资源释放：必须通过 try-with-resources 或手动调用 close() 关闭通道，避免资源泄漏。
2. 模式限制：
   • FileInputStream/FileOutputStream 的通道仅支持单一读写模式。
   • RandomAccessFile 和 FileChannel.open() 支持读写混合模式。
3. 并发安全：多个线程操作同一通道时需同步（如通过 FileLock）。

---

FileChannel 概述

FileChannel 是 Java NIO 中用于文件读写的通道类，属于 java.nio.channels 包。它提供了高性能的文件 I/O 操作，支持随机访问文件、文件锁等功能，比传统的 FileInputStream/FileOutputStream 更高效。

核心特点

1. 非阻塞模式（需配合 Selector 使用）
2. 内存映射文件（MappedByteBuffer）
3. 直接传输（transferTo/transferFrom）
4. 文件锁定（lock/tryLock）

创建 FileChannel

// 方式1：通过 RandomAccessFile
RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
FileChannel channel1 = raf.getChannel();

// 方式2：通过文件流
FileInputStream fis = new FileInputStream("test.txt");
FileChannel channel2 = fis.getChannel();

读取文件示例

try (FileChannel channel = FileChannel.open(Paths.get("test.txt"), StandardOpenOption.READ)) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    
    while (channel.read(buffer) > 0) {
        buffer.flip();  // 切换为读模式
        while (buffer.hasRemaining()) {
            System.out.print((char)buffer.get());
        }
        buffer.clear();  // 清空缓冲区准备下一次读取
    }
}

高效读取技巧

1. 直接缓冲区（减少拷贝次数）：

   ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
   

2. 内存映射文件（适合大文件）：

   MappedByteBuffer mappedBuffer = channel.map(
       FileChannel.MapMode.READ_ONLY, 0, channel.size());
   

注意事项

1. 读取后必须调用 buffer.flip() 切换为读模式
2. 通道使用后需要关闭（推荐 try-with-resources）
3. 直接缓冲区分配成本较高，适合长期重用
4. 文件位置指针可通过 position() 方法控制

性能对比

操作方式	吞吐量	内存占用	适用场景
传统IO	低	低	小文件简单操作
FileChannel	高	中等	大文件随机访问
内存映射	最高	高	超大文件只读操作

---

FileChannel 写入文件

概念定义

FileChannel 是 Java NIO 中的一个核心类，用于对文件进行高效的读写操作。它提供了比传统 I/O（如 FileOutputStream）更灵活、更高性能的文件操作方式，支持随机访问、内存映射文件等特性。

使用场景

1. 大文件处理：适用于需要高效读写大文件的场景。
2. 随机访问：支持从文件的任意位置读写数据。
3. 高性能需求：通过零拷贝技术（如 transferTo/transferFrom）提升传输效率。

核心方法

1. write(ByteBuffer src)：将缓冲区数据写入文件。
2. write(ByteBuffer src, long position)：从指定位置写入数据。
3. transferFrom(ReadableByteChannel src, long position, long count)：从其他通道直接传输数据。
4. transferTo(long position, long count, WritableByteChannel target)：将数据传输到其他通道。

示例代码

import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileChannelWriteExample {
    public static void main(String[] args) {
        String filePath = "example.txt";
        String content = "Hello, FileChannel!";

        try (RandomAccessFile file = new RandomAccessFile(filePath, "rw");
             FileChannel channel = file.getChannel()) {

            // 将字符串转换为字节缓冲区
            ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());

            // 写入文件
            channel.write(buffer);
            System.out.println("数据写入完成！");

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

注意事项

1. 缓冲区管理：确保 ByteBuffer 已正确填充数据（flip() 或 wrap()）。
2. 资源释放：使用 try-with-resources 自动关闭通道和文件句柄。
3. 线程安全：FileChannel 是线程安全的，但多个线程操作同一位置需同步。
4. 性能优化：对大文件使用 DirectByteBuffer 减少内存拷贝。

常见误区

1. 未清空缓冲区：写入后未调用 buffer.clear() 可能导致后续写入错误。
2. 忽略返回值：write() 返回实际写入的字节数，需检查是否完全写入。
3. 通道未关闭：手动管理资源时忘记关闭通道会导致资源泄漏。

高级用法

// 从指定位置写入
channel.write(buffer, 100);

// 强制将数据刷到磁盘（确保持久化）
channel.force(true);

---

文件复制的高效实现（NIO）

NIO 文件复制的核心机制

Java NIO 通过 FileChannel 和缓冲区（ByteBuffer）实现高效文件复制，核心优势在于：

1. 零拷贝技术：FileChannel.transferTo/From() 方法利用操作系统底层优化，减少数据在用户态和内核态之间的拷贝次数
2. 直接缓冲区：通过 allocateDirect() 创建的缓冲区可直接与 I/O 设备交互，避免 JVM 堆内存的额外拷贝

关键代码实现

public static void nioCopy(String source, String target) throws IOException {
    try (FileChannel inChannel = new FileInputStream(source).getChannel();
         FileChannel outChannel = new FileOutputStream(target).getChannel()) {
        
        // 方式1：transferTo（推荐，利用零拷贝）
        inChannel.transferTo(0, inChannel.size(), outChannel);
        
        // 方式2：手动缓冲（适合需要处理数据的场景）
        // ByteBuffer buffer = ByteBuffer.allocateDirect(8192);
        // while(inChannel.read(buffer) != -1) {
        //     buffer.flip();
        //     outChannel.write(buffer);
        //     buffer.clear();
        // }
    }
}

性能优化要点

1. 缓冲区大小：经验值为 8KB-1MB（过小导致频繁IO，过大浪费内存）
2. 直接缓冲区：大文件操作时使用 allocateDirect()，但创建成本较高
3. 文件大小检测：超过 2GB 的文件需要分多次传输（transferTo 单次最多传输 2GB）

与传统 IO 对比

指标	NIO	传统IO
拷贝次数	1-2次（零拷贝）	3-4次
CPU占用	低	较高
大文件处理	优势明显	性能下降显著

注意事项

1. 目标文件存在时会自动覆盖
2. 传输过程中不会自动创建父目录
3. 网络文件传输时建议结合 AsynchronousFileChannel 实现非阻塞
4. 异常处理需同时捕获 IOException 和 FileSystemException

---

文件锁（FileLock）的使用

概念定义

文件锁（FileLock）是Java NIO中用于控制多个进程或线程对同一文件并发访问的机制。它允许程序锁定文件的某一部分或整个文件，防止其他进程或线程同时修改，确保数据一致性。

使用场景

1. 多线程/多进程共享文件：当多个线程或进程需要读写同一文件时，避免数据竞争。
2. 数据库或日志文件操作：确保事务的原子性，防止文件被破坏。
3. 临时文件保护：防止其他进程删除或修改正在使用的临时文件。

常见误区与注意事项

1. 锁的范围：文件锁可以是共享锁（读锁）或独占锁（写锁），需根据场景选择。
2. 锁的粒度：可以锁定整个文件或文件的某一部分（通过position和size指定）。
3. 锁的释放：必须显式调用release()或关闭关联的FileChannel，否则可能导致资源泄漏。
4. 跨进程锁：文件锁在不同JVM或操作系统进程间可能表现不同，需测试验证。
5. 非阻塞锁：尝试获取锁时，可以指定是否阻塞（tryLock()为非阻塞，lock()为阻塞）。

示例代码

import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;

public class FileLockExample {
    public static void main(String[] args) throws Exception {
        // 1. 打开文件并获取FileChannel
        RandomAccessFile file = new RandomAccessFile("test.txt", "rw");
        FileChannel channel = file.getChannel();

        try {
            // 2. 尝试获取独占锁（非阻塞）
            FileLock lock = channel.tryLock();
            if (lock != null) {
                System.out.println("Lock acquired successfully.");
                
                // 3. 执行文件操作
                // ...（读写文件内容）
                
                // 4. 释放锁
                lock.release();
            } else {
                System.out.println("File is locked by another process.");
            }
        } finally {
            // 5. 关闭资源
            channel.close();
            file.close();
        }
    }
}

锁的类型

1. 共享锁（读锁）：多个进程可同时获取，适用于只读操作。

   FileLock sharedLock = channel.lock(0, Long.MAX_VALUE, true);
   

2. 独占锁（写锁）：仅允许一个进程获取，适用于写入操作。

   FileLock exclusiveLock = channel.lock(0, Long.MAX_VALUE, false);
   

操作系统差异

• Windows：文件锁是强制性的，其他进程无法绕过。
• Linux/Unix：文件锁通常是建议性的，需进程主动检查锁。

---

五、NIO 高级特性

内存映射文件（MappedByteBuffer）

概念定义

内存映射文件（MappedByteBuffer）是 Java NIO 提供的一种高效文件读写机制，通过将文件直接映射到内存地址空间，实现文件与内存的直接交互。它属于 java.nio 包，是 ByteBuffer 的子类。

核心原理

1. 操作系统级映射：通过 FileChannel.map() 方法将文件区域映射到虚拟内存，由操作系统负责底层数据同步。
2. 零拷贝优化：避免了传统 I/O 中数据从内核缓冲区到用户空间的拷贝过程。
3. 堆外内存：数据存储在 JVM 堆外内存（Direct Buffer），不受 GC 影响。

使用场景

• 大文件随机访问（如数据库文件）
• 高频读写操作（如日志处理）
• 进程间共享数据（通过文件映射）

关键方法

// 创建内存映射
FileChannel channel = FileChannel.open(Paths.get("data.txt"), StandardOpenOption.READ);
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

// 读写操作
buffer.get();  // 读取数据
buffer.put((byte)123);  // 写入数据（需READ_WRITE模式）

注意事项

1. 模式选择：

   • READ_ONLY：只读映射
   • READ_WRITE：可修改（修改会同步到文件）
   • PRIVATE：写时复制（修改不影响原文件）

2. 资源释放：

   • 映射缓冲区本身不需要关闭
   • 底层通道需要显式关闭
   • 通过 Cleaner 机制释放堆外内存（或调用 ((DirectBuffer)buffer).cleaner().clean()）

3. 性能陷阱：

   • 小文件映射可能不如传统 I/O 高效
   • 频繁映射/解除映射会产生开销

示例代码（文件复制）

try (FileChannel inChannel = FileChannel.open(Paths.get("source.txt"), StandardOpenOption.READ);
     FileChannel outChannel = FileChannel.open(Paths.get("target.txt"), 
         StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
    
    MappedByteBuffer inBuffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
    MappedByteBuffer outBuffer = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());
    
    outBuffer.put(inBuffer);  // 直接内存拷贝
}

常见误区

1. 认为立即持久化：修改后需调用 buffer.force() 强制刷盘
2. 忽略大小限制：单个映射区域不超过 Integer.MAX_VALUE 字节
3. 线程安全问题：多线程操作需自行同步

---

分散（Scatter）与聚集（Gather）

概念定义

分散（Scatter）和聚集（Gather）是 Java NIO 中用于高效读写数据的两种操作模式：

• 分散（Scatter）：从单个通道（Channel）读取数据到多个缓冲区（Buffer）。
• 聚集（Gather）：将多个缓冲区的数据写入到单个通道。

使用场景

1. 分散读取：适用于需要将数据按固定格式拆分处理的场景（如协议解析）。
2. 聚集写入：适用于需要合并多个数据块后统一发送的场景（如文件分块上传）。

核心类与方法

• ScatteringByteChannel：支持分散读取的通道接口，核心方法是 read(ByteBuffer[] dsts)。
• GatheringByteChannel：支持聚集写入的通道接口，核心方法是 write(ByteBuffer[] srcs)。

示例代码

// 分散读取示例
try (FileChannel channel = FileChannel.open(Paths.get("data.txt"))) {
    ByteBuffer header = ByteBuffer.allocate(10);
    ByteBuffer body = ByteBuffer.allocate(100);
    ByteBuffer[] buffers = { header, body };
    
    channel.read(buffers); // 数据依次填充到header和body
} 

// 聚集写入示例
try (FileChannel channel = FileChannel.open(Paths.get("output.txt"), 
                                           StandardOpenOption.WRITE)) {
    ByteBuffer header = ByteBuffer.wrap("HEADER".getBytes());
    ByteBuffer body = ByteBuffer.wrap("BODY".getBytes());
    ByteBuffer[] buffers = { header, body };
    
    channel.write(buffers); // 依次写入header和body的内容
}

注意事项

1. 缓冲区顺序：数据按数组顺序处理，前一个缓冲区填满才会处理下一个。
2. 动态调整：可通过 Buffer.remaining() 检查未填充空间。
3. 性能优势：减少内存拷贝次数，比传统IO操作更高效。

常见误区

• 误认为缓冲区大小必须固定（实际可动态调整）。
• 忽略缓冲区切换时的 flip() 操作（写入前需切换为读模式）。

---

Selector 多路复用机制

核心概念

Selector 是 Java NIO 的核心组件之一，用于监控多个 Channel 的 I/O 事件（如读、写、连接）。通过单线程轮询多个 Channel，实现高效的 I/O 多路复用。

文件读写场景下的优势

1. 非阻塞处理：避免线程因等待 I/O 操作而阻塞。
2. 单线程管理多通道：减少线程切换开销，适合高并发文件操作。
3. 事件驱动：仅在 Channel 就绪时触发操作，减少无效轮询。

关键组件

1. Selector：事件监听器。
2. SelectableChannel：需注册到 Selector 的通道（如 FileChannel 需转为非阻塞模式）。
3. SelectionKey：绑定 Channel 与感兴趣的事件（OP_READ/OP_WRITE）。

使用步骤（代码示例）

// 1. 创建 Selector
Selector selector = Selector.open();

// 2. 打开 FileChannel 并设置为非阻塞模式（需通过 FileInputStream/FileOutputStream）
FileChannel channel = new RandomAccessFile("test.txt", "rw").getChannel();
channel.configureBlocking(false);

// 3. 注册 Channel 到 Selector，监听读事件
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

// 4. 事件循环
while (true) {
    int readyChannels = selector.select(); // 阻塞直到有事件
    if (readyChannels == 0) continue;

    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> iter = selectedKeys.iterator();

    while (iter.hasNext()) {
        SelectionKey currentKey = iter.next();
        if (currentKey.isReadable()) {
            FileChannel ch = (FileChannel) currentKey.channel();
            ByteBuffer buf = ByteBuffer.allocate(1024);
            ch.read(buf); // 非阻塞读取
            buf.flip();
            System.out.println(new String(buf.array()));
        }
        iter.remove(); // 必须手动移除已处理的 Key
    }
}

注意事项

1. 非阻塞模式限制：FileChannel 默认阻塞，需通过 RandomAccessFile 获取并调用 configureBlocking(false)。
2. 事件类型选择：文件读写通常关注 OP_READ 和 OP_WRITE，但需注意频繁的写就绪事件可能造成空轮询。
3. 资源释放：操作完成后需关闭 Selector 和 Channel。

适用场景

• 需要同时监控多个大文件的读写进度。
• 高并发小文件处理（如日志收集）。
• 与其他网络 I/O 混合使用的场景（如 FTP 服务器）。

---

六、异常处理与资源释放

NIO 操作中的常见异常

IOException

• 定义：基础 I/O 异常，表示底层读写失败（如文件损坏、权限不足等）。
• 常见场景：
  • 文件被其他进程占用时尝试写入。
  • 磁盘空间不足。
• 示例代码：

  try (FileChannel channel = FileChannel.open(Paths.get("test.txt"))) {
      channel.read(ByteBuffer.allocate(1024));
  } catch (IOException e) {
      System.err.println("文件读取失败: " + e.getMessage());
  }
  

ClosedChannelException

• 定义：尝试操作已关闭的通道时抛出。
• 注意事项：
  • 需确保通道在操作前未调用 close()。
  • 多线程环境下需同步通道状态。

NonReadableChannelException / NonWritableChannelException

• 定义：通道未以对应模式打开时（如只读通道尝试写入）。
• 修复方式：

  // 正确打开可写通道
  FileChannel channel = FileChannel.open(Paths.get("data.txt"), StandardOpenOption.WRITE);
  

BufferOverflowException / BufferUnderflowException

• 定义：
  • BufferOverflow：写入超过缓冲区容量。
  • BufferUnderflow：读取时剩余数据不足。
• 示例：

  ByteBuffer buffer = ByteBuffer.allocate(10);
  buffer.put(new byte[15]); // 抛出BufferOverflowException
  

OverlappingFileLockException

• 定义：尝试锁定已由当前线程/进程锁定的文件区域。
• 场景：未释放锁前重复调用 FileChannel.lock()。

AsynchronousCloseException

• 定义：其他线程关闭通道时，当前线程正在阻塞操作（如 read()）。
• 多线程建议：使用 Selector 替代阻塞式操作。

FileSystemException（NIO.2 专属）

• 定义：文件系统相关异常（如文件不存在、路径冲突）。
• 子类：
  • NoSuchFileException：文件路径无效。
  • AccessDeniedException：权限不足。

---

正确关闭 Channel 和释放 Buffer

概念定义

在 Java NIO 中，Channel 是数据源和数据目标之间的连接通道，Buffer 是存储数据的容器。正确关闭和释放资源是避免内存泄漏和资源耗尽的关键。

使用场景

• 文件读写操作完成后
• 网络通信结束时
• 任何使用 Channel 和 Buffer 的 NIO 操作完成后

注意事项

1. 关闭顺序：先关闭 Channel，再处理 Buffer。
2. 异常处理：确保在 finally 块中执行关闭操作。
3. Buffer 清理：调用 clear() 或 compact() 方法释放 Buffer 内存（非必须，但建议）。

示例代码

FileChannel channel = null;
ByteBuffer buffer = null;
try {
    channel = FileChannel.open(Paths.get("file.txt"), StandardOpenOption.READ);
    buffer = ByteBuffer.allocate(1024);
    // 读写操作...
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (channel != null) {
            channel.close(); // 1. 先关闭 Channel
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    if (buffer != null) {
        buffer.clear(); // 2. 清理 Buffer（非必须，但建议）
    }
}

常见误区

1. 忽略关闭：未关闭 Channel 会导致文件句柄泄漏。
2. 错误顺序：先释放 Buffer 再关闭 Channel 可能引发未定义行为。
3. 重复关闭：多次调用 close() 方法可能抛出异常，需通过判空避免。

最佳实践

• 使用 try-with-resources（Java 7+）自动关闭资源：

try (FileChannel channel = FileChannel.open(Paths.get("file.txt"))) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    // 操作...
} // 自动关闭 Channel

---

try-with-resources 的应用

概念定义

try-with-resources 是 Java 7 引入的一种语法结构，用于自动管理资源（如文件流、数据库连接等）。它确保在 try 块执行完毕后，资源会被自动关闭，无需手动调用 close() 方法。

核心特点

1. 自动关闭：资源会在 try 块结束时自动调用 close()。
2. 简洁性：减少 finally 块的冗余代码。
3. 支持多资源：可以在 try 中声明多个资源，用分号分隔。

使用场景

适用于所有实现了 AutoCloseable 或 Closeable 接口的资源，例如：

• 文件读写（FileInputStream、FileOutputStream）
• 数据库连接（Connection、Statement）
• 网络连接（Socket）

语法格式

try (ResourceType resource = new ResourceType()) {
    // 使用资源
} catch (Exception e) {
    // 异常处理
}

示例代码

import java.io.*;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        // 自动关闭 FileInputStream 和 FileOutputStream
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意事项

1. 资源顺序：多个资源按声明顺序反向关闭（后声明的先关闭）。
2. 异常处理：如果 try 块和 close() 都抛出异常，close() 的异常会被抑制，可通过 Throwable.getSuppressed() 获取。
3. 不可重用：资源在 try 块结束后已关闭，不可再次使用。

与传统方式的对比

传统方式（手动关闭）：

FileInputStream fis = null;
try {
    fis = new FileInputStream("input.txt");
    // 使用资源
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

try-with-resources 显著简化了代码，避免了资源泄漏的风险。

---

七、性能优化建议

Buffer 大小的选择策略

1. 概念定义

Buffer 是 NIO 中用于存储数据的临时容器，其大小直接影响 I/O 操作的性能。合理选择 Buffer 大小可以平衡内存占用和吞吐量。

2. 常见选择策略

2.1 默认大小（4KB-8KB）

• 适合大多数场景
• 平衡内存和性能
• Java NIO 默认 DirectBuffer 大小通常为 4KB

2.2 大文件处理（64KB-1MB）

• 适合大文件传输
• 减少系统调用次数
• 示例：视频文件传输

2.3 小数据量（512B-2KB）

• 适合高频小数据
• 减少内存浪费
• 示例：网络聊天应用

3. 选择依据

3.1 硬件因素

• 磁盘块大小（通常4KB）
• 网络MTU（通常1500B）

3.2 性能测试

// 测试不同Buffer大小的吞吐量
for (int size : new int[]{1024, 4096, 8192, 16384}) {
    ByteBuffer buffer = ByteBuffer.allocateDirect(size);
    // 执行I/O操作并计时
}

4. 注意事项

1. 过小会导致：

   • 频繁系统调用
   • 增加CPU负载

2. 过大会导致：

   • 内存浪费
   • 延迟增加（填满buffer才处理）

3. 特殊场景：

   • SSL/TLS需要额外16KB空间
   • 压缩/加密需要更大buffer

5. 最佳实践

• 从4KB开始测试
• 根据实际负载调整
• 考虑使用动态buffer（如Netty的AdaptiveRecvByteBufAllocator）

---

直接缓冲区（DirectBuffer）的概念

直接缓冲区（DirectBuffer）是 Java NIO 中一种特殊的内存分配方式，它直接在操作系统的本地内存（堆外内存）中分配空间，而不是在 JVM 堆内存中。通过 ByteBuffer.allocateDirect() 方法创建。

直接缓冲区的使用场景

1. 高性能 I/O 操作

直接缓冲区避免了数据在 JVM 堆内存和本地内存之间的拷贝，适合频繁的 I/O 操作（如文件读写、网络传输）。例如：

FileChannel channel = FileChannel.open(Paths.get("file.txt"), StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocateDirect(1024); // 直接缓冲区
channel.read(buffer);

2. 与本地代码交互

当通过 JNI 调用本地库（如 C/C++ 代码）时，直接缓冲区可以减少内存拷贝开销，因为本地代码可以直接访问堆外内存。

3. 大内存数据处理

处理大型文件或需要长期驻留内存的数据时，直接缓冲区可以避免 GC 对堆内存的压力。

注意事项

1. 分配成本高：直接缓冲区的创建和销毁比堆缓冲区更耗时。
2. 内存管理：需要手动监控和释放，避免堆外内存泄漏（通过 Cleaner 机制回收）。
3. 不适合小数据量：对于小型或短期数据，堆缓冲区（ByteBuffer.allocate()）效率更高。

示例代码

// 创建直接缓冲区
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

// 写入数据
directBuffer.put("Hello, DirectBuffer!".getBytes());
directBuffer.flip();

// 读取数据
while (directBuffer.hasRemaining()) {
    System.out.print((char) directBuffer.get());
}

---

避免频繁的内存分配

概念定义

在NIO文件读写中，频繁的内存分配指的是在每次I/O操作时都创建新的缓冲区（ByteBuffer等）对象。这会导致以下问题：

• JVM垃圾回收压力增大
• 内存碎片化
• 性能下降

使用场景

1. 高频文件读写操作
2. 网络通信中的数据传输
3. 需要重复处理大量数据的应用

优化方案

1. 缓冲区复用

// 创建可复用的直接缓冲区
ByteBuffer buffer = ByteBuffer.allocateDirect(8192);  // 8KB缓冲区

void processFile(FileChannel channel) throws IOException {
    buffer.clear();  // 复用前清空
    while(channel.read(buffer) != -1) {
        buffer.flip();
        // 处理数据...
        buffer.clear();
    }
}

2. 使用缓冲区池

// 简单的缓冲区池实现
public class BufferPool {
    private final Queue<ByteBuffer> pool = new ConcurrentLinkedQueue<>();
    private final int bufferSize;
    
    public BufferPool(int bufferSize, int initialCount) {
        this.bufferSize = bufferSize;
        for(int i=0; i<initialCount; i++) {
            pool.add(ByteBuffer.allocateDirect(bufferSize));
        }
    }
    
    public ByteBuffer borrowBuffer() {
        ByteBuffer buffer = pool.poll();
        return buffer != null ? buffer : ByteBuffer.allocateDirect(bufferSize);
    }
    
    public void returnBuffer(ByteBuffer buffer) {
        buffer.clear();
        pool.offer(buffer);
    }
}

注意事项

1. 线程安全：多线程环境下需要确保缓冲区的线程安全
2. 缓冲区大小：应根据实际业务需求选择合适大小
3. 内存泄漏：确保借出的缓冲区最终被归还
4. 直接缓冲区：对于大量数据传输，优先考虑DirectBuffer

性能对比

方案	内存分配次数	GC压力	吞吐量
每次新建	高	大	低
缓冲区复用	低	小	高
缓冲池	极低	极小	最高

---