Java的I/O类库- NIO

Java NIO（New I/O）是Java平台提供的一种用于非阻塞I/O操作的API。它引入了一组新的Java类，用于实现高性能的、非阻塞的I/O操作，以替代传统的阻塞式I/O（IO Blocking）模型。Java NIO的核心是基于Channel（通道）和Buffer（缓冲区）的I/O操作。
不但引人了全新的高效的I/O 机制，同时引人了基于 Reactor 设计模式的多路复用异步模式。NIO 的包中主要包含了以下几种抽象数据类型。

下面是一个简单的Java NIO服务器的示例，用于接收客户端的连接请求，并回显接收到的数据：

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

public class NIOServer {
    public static void main(String[] args) throws IOException {
        // 创建一个Selector
        Selector selector = Selector.open();

        // 创建ServerSocketChannel并绑定端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress("localhost", 8888));
        serverSocketChannel.configureBlocking(false);

        // 将ServerSocketChannel注册到Selector，并监听连接事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // 等待事件发生
            selector.select();

            // 获取发生的事件集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = 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);
                    clientChannel.register(selector, SelectionKey.OP_READ);
                }

                // 处理读取事件
                if (key.isReadable()) {
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = clientChannel.read(buffer);
                    if (bytesRead == -1) {
                        clientChannel.close();
                    } else if (bytesRead > 0) {
                        buffer.flip();
                        clientChannel.write(buffer);
                    }
                }
            }
        }
    }
}

上述示例中，使用了ServerSocketChannel、SocketChannel和Selector来实现一个简单的NIO服务器。服务器接收客户端的连接请求，并回显接收到的数据。
Java NIO提供的主要特性包括：

1. 通道和缓冲区：通道是数据源和数据目标的抽象表示，它类似于传统I/O中的流，但更加强大和灵活。缓冲区是用于在通道和应用程序之间传输数据的对象，它可以支持不同的数据类型和操作。

2. 非阻塞I/O：与传统的阻塞I/O不同，Java NIO提供了非阻塞的I/O操作，允许应用程序在没有数据可用时继续执行其他任务，而不必等待I/O操作完成。

3. 选择器（Selector）：选择器是Java NIO中的一个重要组件，它允许一个线程同时监控多个通道的事件，如连接、接收、读取和写入等，从而有效地处理多个连接。

Java NIO的核心类主要在java.nio包中，例如ByteBuffer、Channel、Selector等。使用Java NIO可以实现高性能的网络编程，尤其适用于需要处理大量连接的服务器应用程序。

在Java NIO（New I/O）中，ByteBuffer、Channel和Selector是三个核心概念，它们共同构成了非阻塞I/O模型的基础。

1. ByteBuffer（缓冲区）：
   ByteBuffer是Java NIO中用于进行数据传输的缓冲区。它类似于传统IO中的字节流，但更加灵活和高效。ByteBuffer是一个数组，可以存储原始字节数据，并提供了一系列方法用于读取和写入数据。在进行I/O操作时，数据通常先写入到ByteBuffer中，然后再从ByteBuffer中读取或传输到目标通道。

2. Channel（通道）：
   Channel是Java NIO中用于数据源和数据目标的抽象。Channel类似于传统IO中的流，但更加灵活。通道可以连接到文件、套接字或其他I/O源，并支持数据的读取和写入。Java NIO提供了不同类型的通道，例如FileChannel、SocketChannel、ServerSocketChannel等，用于不同类型的I/O操作。

3. Selector（选择器）：
   Selector是Java NIO中用于多路复用的关键组件。它允许一个线程同时监听多个通道的事件，如连接、读取、写入等，从而实现非阻塞I/O。Selector提供了高效的事件驱动机制，可以显著减少线程数，降低系统开销。Selector通常与非阻塞的Channel一起使用，通过调用Selector.select()方法来等待事件发生。

Java NIO的工作方式如下：

1. 创建一个Selector，并将Channel注册到Selector上，监听感兴趣的事件，例如OP_READ、OP_WRITE等。
2. 当有事件发生时，调用Selector.select()方法会返回，并返回事件的集合。
3. 遍历事件集合，处理事件，如读取或写入数据。

以下是一个简单的Java NIO示例，演示如何使用ByteBuffer、Channel和Selector来实现非阻塞I/O：

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

public class NIOExample {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();

        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress("localhost", 8888));
        serverChannel.configureBlocking(false);
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            selector.select();

            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();

                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = server.accept();
                    clientChannel.configureBlocking(false);
                    clientChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = clientChannel.read(buffer);
                    if (bytesRead == -1) {
                        clientChannel.close();
                    } else if (bytesRead > 0) {
                        buffer.flip();
                        // 处理读取的数据
                        while (buffer.hasRemaining()) {
                            System.out.print((char) buffer.get());
                        }
                        System.out.println();
                    }
                }
            }
        }
    }
}

上述示例中，通过使用ByteBuffer、Channel和Selector实现了一个简单的非阻塞的NIO服务器。服务器可以接收客户端的连接请求，并读取客户端发送的数据。这里只是一个简单示例，实际应用中可能需要更多的处理逻辑和异常处理。

Java NIO在网络编程、文件I/O和内存映射文件等场景下都能发挥强大的作用，特别适用于高性能、高并发的应用程序。