从Channels、Buffers到Selectors：Java NIO基本操作指南

引言

在计算机领域，输入/输出(I/O)操作是应用程序与外部设备(如文件系统、网络设备等)进行数据交换的关键环节。传统的Java I/O模型是基于阻塞式I/O操作的，即读取和写入操作在完成之前会阻塞当前线程。这种I/O模型在处理低并发、延迟要求不高的场景下表现尚可，但在高并发、实时性要求较高的应用场景中，其性能表现往往不尽如人意。

Java NIO(New Input/Output)是为了解决这些问题而引入的一种高性能、非阻塞I/O库。与传统的Java I/O模型相比，Java NIO提供了许多改进，如通道(Channel)、缓冲区(Buffer)和选择器(Selector)等组件，它们共同构成了Java NIO的基础架构。这种新的I/O模型允许应用程序在单个线程中处理多个I/O操作，从而显著提高了I/O处理的效率和性能。

在现代应用程序中，实时数据处理和通信变得越来越重要。例如，金融交易系统、在线聊天应用、物联网设备等，都对实时性和并发性有着很高的要求。Java NIO正是为了满足这些需求而诞生的。

Java NIO的核心组件

Java NIO库的核心组件包括通道(Channel)、缓冲区(Buffer)和选择器(Selector)。这些组件共同构成了Java NIO的基础架构，并提供了一种高效、非阻塞的I/O处理方式。

通道(Channel)

通道是Java NIO中用于数据传输的基本单位。与传统的Java I/O模型中的流(Stream)不同，通道提供了双向数据传输的能力，即可以用于读取数据，也可以用于写入数据。Java NIO中的通道主要包括以下几种：

• FileChannel：用于文件操作的通道，可以实现文件的读取、写入和内存映射等功能。
• SocketChannel：用于TCP网络操作的通道，提供了非阻塞的网络通信能力。
• ServerSocketChannel：用于TCP服务器端的通道，允许服务器接受客户端连接并与客户端进行通信。
• DatagramChannel：用于UDP网络操作的通道，提供了非阻塞的数据包通信能力。

缓冲区(Buffer)

缓冲区是Java NIO中用于存储数据的容器。它是一个线性数据结构，可以容纳一定数量的数据元素。缓冲区主要用于在通道和应用程序之间传输数据，即数据从通道读取到缓冲区，或从缓冲区写入通道。Java NIO中的缓冲区有以下几种：

• ByteBuffer：用于存储字节数据的缓冲区。
• CharBuffer：用于存储字符数据的缓冲区。
• IntBuffer：用于存储整数数据的缓冲区。
• LongBuffer：用于存储长整数数据的缓冲区。
• FloatBuffer：用于存储浮点数数据的缓冲区。
• DoubleBuffer：用于存储双精度浮点数数据的缓冲区。

选择器(Selector)

选择器是Java NIO中用于处理多个通道的I/O事件的组件。通过使用选择器，应用程序可以在单个线程中同时处理多个通道的I/O操作，从而提高了I/O处理的效率。选择器主要负责监听通道上的事件(如数据可读、数据可写、连接可接受等)，并根据事件的类型执行相应的操作。

这些核心组件共同构成了Java NIO的基础架构，为应用程序提供了一种高性能、非阻塞的I/O处理方式。

Channels和Buffers的基本操作

在Java NIO中，通道(Channel)和缓冲区(Buffer)是数据传输的基本单位。本节将介绍如何使用这两个组件进行基本的I/O操作。

打开和关闭通道

通道的创建取决于通道的类型。例如，要创建一个文件通道(FileChannel)，可以通过以下方式打开一个文件并获取其关联的通道：

RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
FileChannel fileChannel = file.getChannel();

对于网络通道(如SocketChannel和ServerSocketChannel)，可以通过以下方式创建：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("localhost", 8080));
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8080));

关闭通道时，需要调用其close()方法。在通道不再使用时，应确保关闭它以释放底层资源：

fileChannel.close();
socketChannel.close();
serverSocketChannel.close();

从通道中读取数据到缓冲区

从通道读取数据时，首先需要创建一个缓冲区来接收数据。例如，创建一个字节缓冲区(ByteBuffer)：

ByteBuffer buffer = ByteBuffer.allocate(1024);

然后，使用通道的read()方法将数据读取到缓冲区：

int bytesRead = fileChannel.read(buffer);

将数据从缓冲区写入通道

在向通道写入数据之前，需要先将缓冲区翻转(flip)，以将写模式切换为读模式：

buffer.flip();

接下来，使用通道的write()方法将缓冲区中的数据写入通道：

javaCopy codeint bytesWritten = fileChannel.write(buffer);

缓冲区的操作：清空、翻转、重绕等

缓冲区具有多种操作，如下所示：

• 清空(clear)：清空缓冲区，将位置(position)设置为0，将限制(limit)设置为容量(capacity)。清空缓冲区后，可以重新填充数据。
• 翻转(flip)：将缓冲区从写模式切换为读模式。将位置(position)设置为0，将限制(limit)设置为当前位置。
• 重绕(rewind)：将位置(position)设置为0，保持限制(limit)不变。重绕缓冲区后，可以重新读取已经存在的数据。
• 标记(mark)与重置(reset)：通过mark()方法在当前位置设置一个标记。通过reset()方法将位置(position)重置为标记的位置。

这些操作使得缓冲区在不同阶段的I/O操作中可以复用，从而提高了I/O处理的性能。

Selectors的使用

在Java NIO中，选择器(Selector)是用于处理多个通道的I/O事件的组件。通过使用选择器，应用程序可以在单个线程中同时处理多个通道的I/O操作，从而提高了I/O处理的效率。本节将介绍如何使用选择器进行基本的I/O操作。

打开和关闭选择器

要创建一个选择器，可以调用Selector.open()方法：

Selector selector = Selector.open();

关闭选择器时，需要调用其close()方法。在选择器不再使用时，应确保关闭它以释放底层资源：

selector.close();

向选择器注册通道

在使用选择器之前，需要将通道注册到选择器上。可以通过调用通道的register()方法，并指定感兴趣的事件来完成注册。例如，向选择器注册一个可读事件：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
SelectionKey key = socketChannel.register(selector, 
SelectionKey.OP_READ);

注意，需要将通道设置为非阻塞模式，因为选择器只支持非阻塞通道。

监听和处理I/O事件

要监听和处理I/O事件，可以使用选择器的select()方法。这个方法会阻塞当前线程，直到有一个或多个通道的事件准备就绪。然后，可以通过selectedKeys()方法获取已经准备就绪的事件集合，并对其进行遍历和处理：

while (true) {
int readyChannels = selector.select();
if (readyChannels == 0) {
continue;
}
Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isReadable()) {
// 处理可读事件
} else if (key.isWritable()) {
// 处理可写事件
} else if (key.isAcceptable()) {
// 处理连接可接受事件
} else if (key.isConnectable()) {
// 处理连接完成事件
}
keyIterator.remove();
}
}

在处理完事件后，需要调用keyIterator.remove()方法将事件从已选择键集合中移除，以避免重复处理。

取消键和关闭通道

在处理完成通道的I/O操作后，可以通过调用键(SelectionKey)的cancel()方法将其从选择器中取消。同时，应确保关闭通道以释放底层资源：

key.cancel();
socketChannel.close();

通过以上步骤，可以使用选择器监听和处理多个通道的I/O事件，从而实现高性能、非阻塞的I/O处理。在实际项目中，选择器通常与通道和缓冲区一起使用，以提供更灵活、高效的网络通信和文件操作功能。

文件操作与内存映射文件

Java NIO提供了高效的文件操作功能，如文件通道(FileChannel)和内存映射文件(Memory-Mapped File)。这些功能使得文件I/O处理更加高效、灵活。本节将介绍如何使用这些功能进行基本的文件操作。

使用FileChannel读写文件

FileChannel提供了对文件的读、写和映射访问。要使用FileChannel，可以通过以下方式获取与文件关联的FileChannel：

RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
FileChannel fileChannel = file.getChannel();

接下来，可以使用fileChannel.read()和fileChannel.write()方法读写文件：

ByteBuffer buffer = ByteBuffer.allocate(1024);
// 读取文件
int bytesRead = fileChannel.read(buffer);
// 写入文件
buffer.flip();
int bytesWritten = fileChannel.write(buffer);

内存映射文件

内存映射文件是一种将文件或文件的一部分直接映射到内存中的技术。这使得应用程序可以直接在内存中操作文件，从而大大提高了文件操作的速度。要创建内存映射文件，可以通过FileChannel的map()方法实现：

MappedByteBuffer mappedBuffer = 
fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());

接下来，可以像操作普通缓冲区一样操作内存映射文件：

// 读取数据
byte data = mappedBuffer.get();
// 写入数据
mappedBuffer.put((byte) 42);

文件锁定

FileChannel还支持文件锁定功能，可以防止其他进程同时修改文件。要锁定文件，可以调用fileChannel.lock()方法：

FileLock lock = fileChannel.lock();

解锁文件时，需要调用FileLock的release()方法：

lock.release();

关闭FileChannel

完成文件操作后，需要关闭FileChannel以释放底层资源：

fileChannel.close();

通过使用FileChannel和内存映射文件，Java NIO提供了高效、灵活的文件操作功能，使得文件I/O处理更加高效。在实际项目中，这些功能可以与通道、缓冲区和选择器等其他组件一起使用，提供强大的I/O处理能力。

Java NIO与Java NIO.2

Java NIO和Java NIO.2都是用于提高I/O性能和灵活性的库。Java NIO引入了通道、缓冲区、选择器等组件，以支持高效、非阻塞的I/O处理。Java NIO.2在Java NIO的基础上增加了对文件系统的更强大支持，如异步文件I/O、文件系统通知等。本节将分别介绍Java NIO和Java NIO.2的主要功能。

Java NIO的主要功能

以下是Java NIO库提供的主要功能：

• 通道(Channel)：用于在字节缓冲区和实体(如文件、套接字)之间传输数据的通道。
• 缓冲区(Buffer)：提供了对基本数据类型的缓冲区支持，用于存储和操作数据。
• 选择器(Selector)：用于处理多个通道的I/O事件，支持单线程处理多个连接。
• 非阻塞I/O：通过通道和选择器支持非阻塞I/O操作，提高了I/O处理的效率。
• 文件操作：支持高效的文件操作，如文件通道(FileChannel)和内存映射文件(Memory-Mapped File)。

Java NIO.2的主要功能

Java NIO.2是Java 7中引入的一个新库，也称为JSR-203。它在Java NIO的基础上增加了对文件系统的更强大支持。以下是Java NIO.2提供的主要功能：

• 异步文件I/O(Asynchronous File I/O)：支持异步地读取、写入和处理文件，提高了文件操作的效率。
• 文件系统API(File System API)：提供了对文件系统的抽象访问，允许应用程序与不同类型的文件系统进行交互。
• 文件属性和文件权限：支持访问和修改文件属性和文件权限，提供了更丰富的文件操作功能。
• 文件系统通知(Watch Service)：允许应用程序监听文件系统事件，如文件的创建、修改和删除等。
• 符号链接和硬链接支持：支持创建和操作文件系统中的符号链接和硬链接。

Java NIO与Java NIO.2的关系

Java NIO.2是在Java NIO的基础上发展而来的。虽然它们都属于Java的输入/输出库，但Java NIO.2主要关注文件系统操作的扩展和改进。Java NIO和Java NIO.2可以一起使用，以提供更强大的I/O处理能力。在实际项目中，可以根据需要选择合适的库和组件来实现高性能、灵活的I/O处理。

使用Java NIO构建简单的文件传输应用

在这个实战案例中，我们将演示如何使用Java NIO构建一个简单的文件传输应用。我们将创建一个基于NIO的服务器和客户端，服务器将接收客户端发送的文件并将其保存到本地。

服务器端实现

创建并配置ServerSocketChannel和Selector

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.bind(new InetSocketAddress(8080));
Selector selector = Selector.open();
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

事件监听和处理

while (true) {
selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey selectedKey = keyIterator.next();
keyIterator.remove();
if (selectedKey.isAcceptable()) {
// 处理连接可接受事件
ServerSocketChannel server = (ServerSocketChannel) selectedKey.channel();
SocketChannel client = server.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
} else if (selectedKey.isReadable()) {
// 处理可读事件
SocketChannel client = (SocketChannel) selectedKey.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
Path outputPath = Paths.get("received_file.txt");
FileChannel outputChannel = FileChannel.open(outputPath, 
StandardOpenOption.CREATE, StandardOpenOption.WRITE, 
StandardOpenOption.APPEND);
while (client.read(buffer) > 0) {
buffer.flip();
outputChannel.write(buffer);
buffer.clear();
}
outputChannel.close();
client.close();
System.out.println("File received and saved.");
}
}
}

客户端实现

创建并配置SocketChannel
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("localhost", 8080));

发送文件

while (!socketChannel.finishConnect()) {
// 等待连接完成
}
Path inputFile = Paths.get("file_to_send.txt");
FileChannel inputChannel = FileChannel.open(inputFile, 
StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (inputChannel.read(buffer) > 0) {
buffer.flip();
socketChannel.write(buffer);
buffer.clear();
}
inputChannel.close();
socketChannel.close();
System.out.println("File sent.");

在这个实战案例中，我们使用Java NIO构建了一个简单的文件传输应用。服务器端接收来自客户端的文件并将其保存到本地。当然，这个示例仅用于演示目的，实际应用中可能需要考虑更多细节，如错误处理、并发、安全等。

总结

NIO绝对是大多数程序员不想染指的东西，实际项目可以使用Netty或者Mina来实现NIO。