java NIO 详解

Java NIO（New I/O）详解

Java NIO（New I/O）是 Java 1.4 引入的一套新的 I/O API，用于替代传统的阻塞式 I/O（即 BIO）。NIO 提供了非阻塞、高效的 I/O 操作，尤其适合需要处理大量连接的高性能场景，例如网络编程、文件操作等。

---

1. NIO 的核心概念

Java NIO 的主要特性包括 缓冲区（Buffer）、通道（Channel） 和 选择器（Selector）。这些组件共同实现了非阻塞 I/O 和高效的数据处理。

1.1 阻塞 I/O 与非阻塞 I/O 的对比

特性	阻塞 I/O（BIO）	非阻塞 I/O（NIO）
模型	每个线程处理一个连接。	单线程处理多个连接。
阻塞性	调用方法会阻塞线程，直到操作完成。	调用方法立即返回，线程可继续执行其他任务。
性能	大量连接时需要创建多线程，资源消耗大。	单线程即可处理高并发连接，资源效率高。
适用场景	小规模连接，编程简单。	高并发连接，性能要求高。

---

2. NIO 的核心组件

2.1 缓冲区（Buffer）

• Buffer 是一个容器，存储数据，代替传统 I/O 的 byte[] 或 char[]。
• 工作原理：
  • 数据的读写都通过 Buffer 完成。
  • 使用了指针（position、limit 和 capacity）来跟踪读写位置。

Buffer 的重要属性

1. capacity：容量，Buffer 最大能容纳的元素数量，初始化后不能改变。
2. position：当前读写的位置。
3. limit：限制，Buffer 中可以读写的范围。
4. mark：标记，用于记录某个位置，可以通过 reset() 恢复到标记位置。

Buffer 的工作流程

1. 写模式：写入数据后，调用 flip() 切换到读模式。
2. 读模式：读取数据后，调用 clear() 或 compact() 切换到写模式。

Buffer 的常用子类

• ByteBuffer：处理字节数据。
• CharBuffer：处理字符数据。
• IntBuffer、FloatBuffer 等：处理基本数据类型。

---

2.2 通道（Channel）

• Channel 是双向的，可以同时读写数据，而传统的 Stream 只能单向操作。
• 常用通道：
  • FileChannel：用于文件操作。
  • SocketChannel：用于网络通信。
  • ServerSocketChannel：用于监听 TCP 连接。
  • DatagramChannel：用于 UDP 通信。

Channel 的特点

• 通道与缓冲区结合使用。
• 支持非阻塞模式（如 SocketChannel 和 DatagramChannel）。

---

2.3 选择器（Selector）

• Selector 是 NIO 的核心，用于监听多个通道的事件（如连接、读写）。
• 特点：
  • 单线程即可管理多个通道，提高效率。
  • 事件驱动机制，减少线程阻塞。

Selector 支持的事件

事件类型	描述
OP_ACCEPT	接收连接事件（ServerSocketChannel）。
OP_CONNECT	连接就绪事件（SocketChannel）。
OP_READ	读事件（数据可读）。
OP_WRITE	写事件（数据可写）。

---

3. NIO 的工作原理

3.1 文件操作

示例：使用 FileChannel 复制文件

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

public class FileChannelExample {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("input.txt");
        FileOutputStream fos = new FileOutputStream("output.txt");

        FileChannel inputChannel = fis.getChannel();
        FileChannel outputChannel = fos.getChannel();

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        while (inputChannel.read(buffer) != -1) {
            buffer.flip(); // 切换到读模式
            outputChannel.write(buffer);
            buffer.clear(); // 清空缓冲区，切换到写模式
        }

        inputChannel.close();
        outputChannel.close();
        fis.close();
        fos.close();
    }
}

---

3.2 网络操作

示例：SocketChannel 客户端

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

public class NIOClient {
    public static void main(String[] args) throws Exception {
        SocketChannel client = SocketChannel.open();
        client.connect(new InetSocketAddress("localhost", 8080));

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("Hello, NIO!".getBytes());
        buffer.flip(); // 切换到读模式

        client.write(buffer);
        client.close();
    }
}

示例：ServerSocketChannel 服务端

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class NIOServer {
    public static void main(String[] args) throws Exception {
        ServerSocketChannel server = ServerSocketChannel.open();
        server.bind(new InetSocketAddress(8080));
        server.configureBlocking(false); // 设置为非阻塞模式

        System.out.println("Server started...");

        while (true) {
            SocketChannel client = server.accept();
            if (client != null) {
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                client.read(buffer);
                buffer.flip();
                System.out.println("Received: " + new String(buffer.array(), 0, buffer.limit()));
                client.close();
            }
        }
    }
}

---

3.3 多路复用

示例：Selector 的使用

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

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

        System.out.println("Server started...");

        while (true) {
            selector.select(); // 阻塞，直到有事件触发
            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();

            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                keys.remove();

                if (key.isAcceptable()) {
                    SocketChannel client = serverChannel.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("Accepted connection from: " + client.getRemoteAddress());
                } else if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = client.read(buffer);
                    if (bytesRead > 0) {
                        buffer.flip();
                        System.out.println("Received: " + new String(buffer.array(), 0, buffer.limit()));
                    } else if (bytesRead == -1) {
                        client.close();
                    }
                }
            }
        }
    }
}

---

4. NIO 的优缺点

4.1 优点

1. 高并发性能：
   • 通过单线程管理多个通道，减少线程创建和上下文切换的开销。
2. 非阻塞操作：
   • 提高线程利用率，避免线程长期阻塞。
3. 灵活性高：
   • 提供 Buffer 和 Channel 等更底层的操作能力。

4.2 缺点

1. 开发复杂度较高：
   • 需要管理缓冲区、通道和选择器，代码复杂度较高。
2. 适用场景有限：
   • 不适合小规模、简单的 I/O 操作。

---

5. NIO 的适用场景

1. 高并发网络服务：
   • 如聊天室、在线游戏、Web 服务器。
2. 高性能文件处理：
   • 如大文件的复制、传输。
3. 实时数据流：
   • 如股票行情、日志流分析。

---

6. 总结

Java NIO 提供了一套高效的非阻塞 I/O API，结合 Buffer、Channel 和 Selector 的机制，在高并发场景中具有明显的性能优势。虽然开发复杂度较传统 BIO 高，但在现代应用中（如高性能服务器、文件传输等）是不可或缺的工具。通过合理使用 NIO，可以显著提高 Java 应用的性能和扩展性。