Java `Non-Blocking I/O (NIO)` `Selector` `ByteBuffer` 异步网络编程 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位观众老爷，今天咱们聊聊Java NIO，让你的网络程序跑得飞起！别害怕，NIO听起来高大上，其实就是给Java的I/O操作开了个挂，让它能异步处理，效率蹭蹭往上涨。

开场白：传统IO的痛点

先说说传统的IO，也就是java.io包里的那些家伙。它们有个特点，就是阻塞。啥意思？就像你去餐厅吃饭，服务员（线程）一次只能服务一个客人，如果客人点了份佛跳墙，得等半天才能做好，服务员就得一直等着，啥也干不了。这就是阻塞，线程啥也干不了，只能等着IO操作完成。

这种方式，如果连接数一多，服务器就容易崩溃。就像餐厅来了几百号人，就那么几个服务员，全都等着做佛跳墙，那可不得乱套嘛！

NIO：异步非阻塞的救星

NIO就是来解决这个问题的。它引入了三个核心概念：

Channel (通道)：可以理解为连接，但它和传统的IO流不一样，它是双向的，可以同时读写。
Buffer (缓冲区)：数据读写的中转站。数据从Channel读到Buffer，或者从Buffer写到Channel。
Selector (选择器)：最重要的角色，它就像一个交通警察，可以监控多个Channel的IO事件，比如连接建立、数据可读、数据可写等等。

NIO的精髓就在于Selector。它可以让你用一个线程同时管理多个Channel，当某个Channel上有事件发生时，Selector会通知你，你就可以去处理这个Channel上的数据。就像服务员有了千里眼，知道哪个客人点的菜好了，就去端菜，不用傻等。

NIO的优势：

特性	传统IO (Blocking IO)	NIO (Non-Blocking IO)
工作模式	阻塞	非阻塞
并发处理	单线程处理单个连接	单线程处理多个连接
资源占用	连接数增加，线程数也增加	连接数增加，线程数基本不变
适用场景	连接数少，并发低的场景	连接数多，并发高的场景

NIO核心组件详解

Channel (通道)

Channel是NIO进行IO操作的主要接口。常见的Channel实现包括：
- FileChannel：用于文件IO。
- SocketChannel：用于TCP网络IO。
- ServerSocketChannel：用于监听TCP连接。
- DatagramChannel：用于UDP网络IO。
Channel必须配置成非阻塞模式，才能配合Selector使用。
Buffer (缓冲区)

Buffer是NIO读写数据的容器。常见的Buffer实现包括：
- ByteBuffer：字节缓冲区，最常用的Buffer。
- CharBuffer：字符缓冲区。
- IntBuffer：整数缓冲区。
- LongBuffer：长整数缓冲区。
- FloatBuffer：浮点数缓冲区。
- DoubleBuffer：双精度浮点数缓冲区。
- ShortBuffer：短整数缓冲区。
Buffer有一些重要的属性：
- capacity：缓冲区的最大容量。
- position：下一个要读或写的元素的索引。
- limit：缓冲区中有效数据的末尾索引。
Buffer的常用方法：
- allocate(int capacity)：创建一个指定容量的Buffer。
- put(byte b)：向Buffer中写入一个字节。
- get()：从Buffer中读取一个字节。
- flip()：将Buffer从写模式切换到读模式。
- clear()：清空Buffer，准备写入新的数据。
- rewind()：重置position为0，可以重新读取Buffer中的数据。
- compact()：将未读取的数据移动到Buffer的开头，position设置为未读取数据的末尾，limit设置为capacity。
Selector (选择器)

Selector是NIO的核心，它可以监控多个Channel的IO事件。

Selector的常用方法：
- open()：创建一个Selector。
- register(SelectableChannel channel, int ops)：将一个Channel注册到Selector上，并指定要监控的事件类型。ops可以是以下几种：
  - SelectionKey.OP_CONNECT：连接事件。
  - SelectionKey.OP_ACCEPT：接受连接事件。
  - SelectionKey.OP_READ：读事件。
  - SelectionKey.OP_WRITE：写事件。
- select()：阻塞等待，直到至少有一个Channel发生了注册的事件。
- select(long timeout)：阻塞等待，最多等待timeout毫秒，直到至少有一个Channel发生了注册的事件。
- selectNow()：立即返回，如果没有Channel发生了注册的事件，则返回0。
- selectedKeys()：返回所有发生了事件的SelectionKey的集合。
- close()：关闭Selector。

NIO编程实战：一个简单的Echo服务器

咱们来写一个简单的Echo服务器，它可以接收客户端发来的数据，然后原封不动地返回给客户端。

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.util.Iterator;
import java.util.Set;

public class EchoServer {

    private static final int PORT = 8080;
    private static final int BUFFER_SIZE = 1024;

    public static void main(String[] args) throws IOException {
        // 1. 创建ServerSocketChannel，并监听指定端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式

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

        // 3. 将ServerSocketChannel注册到Selector上，监听ACCEPT事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Echo server started on port " + PORT);

        while (true) {
            // 4. 阻塞等待，直到至少有一个Channel发生了注册的事件
            selector.select();

            // 5. 获取所有发生了事件的SelectionKey的集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            // 6. 遍历SelectionKey集合，处理发生的事件
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                keyIterator.remove(); // 移除处理过的Key

                if (key.isAcceptable()) {
                    // 7. 处理ACCEPT事件，接受客户端连接
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = server.accept();
                    clientChannel.configureBlocking(false); // 设置为非阻塞模式
                    clientChannel.register(selector, SelectionKey.OP_READ); // 注册READ事件
                    System.out.println("Accepted connection from: " + clientChannel.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 8. 处理READ事件，读取客户端数据
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
                    int bytesRead = clientChannel.read(buffer);

                    if (bytesRead > 0) {
                        // 9. 将Buffer从写模式切换到读模式
                        buffer.flip();

                        // 10. 读取Buffer中的数据，并打印到控制台
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        String message = new String(data);
                        System.out.println("Received: " + message + " from " + clientChannel.getRemoteAddress());

                        // 11. 将数据写回客户端
                        clientChannel.write(ByteBuffer.wrap(data)); // Echo back to the client
                    } else if (bytesRead == -1) {
                        // 12. 客户端关闭连接
                        System.out.println("Client disconnected: " + clientChannel.getRemoteAddress());
                        clientChannel.close();
                    }
                }
            }
        }
    }
}

代码解释：

创建ServerSocketChannel: 创建ServerSocketChannel，绑定端口，并设置为非阻塞模式。这是监听客户端连接的基础。
创建Selector: 创建Selector，它是NIO的核心，用于监控Channel的IO事件。
注册ServerSocketChannel: 将ServerSocketChannel注册到Selector上，监听ACCEPT事件。ACCEPT事件表示有新的客户端连接请求。
主循环: 进入主循环，不断轮询Selector，等待事件发生。
Selector.select(): selector.select() 方法会阻塞，直到至少有一个Channel发生了注册的事件，或者超时。
获取SelectedKeys: selector.selectedKeys() 方法返回所有发生了事件的SelectionKey的集合。
处理ACCEPT事件: 如果SelectionKey是ACCEPT事件，表示有新的客户端连接请求。
- 接受客户端连接：通过server.accept() 接受客户端连接，返回一个SocketChannel。
- 配置SocketChannel：将SocketChannel设置为非阻塞模式，并注册到Selector上，监听READ事件。READ事件表示客户端有数据可读。
处理READ事件: 如果SelectionKey是READ事件，表示客户端有数据可读。
- 读取数据：通过clientChannel.read(buffer) 从SocketChannel读取数据到Buffer中。
- 处理数据：将Buffer从写模式切换到读模式，然后读取Buffer中的数据，并打印到控制台。
- 写回数据：将数据写回客户端。
- 关闭连接：如果bytesRead 等于 -1，表示客户端关闭连接，需要关闭SocketChannel。
ByteBuffer的使用: 重点理解Buffer的flip() 方法，它将Buffer从写模式切换到读模式，以便读取Buffer中的数据。
异常处理: 代码中省略了异常处理，实际开发中需要添加适当的异常处理代码。

编译和运行:

保存代码为EchoServer.java。
编译代码：javac EchoServer.java
运行代码：java EchoServer

客户端代码 (可以使用Telnet测试):

打开终端。
输入 telnet localhost 8080
输入一些文本，然后按回车键。
服务器会将你输入的文本原封不动地返回给你。

NIO的进阶技巧

多路复用: Selector实现了IO多路复用，可以同时监控多个Channel的IO事件，提高服务器的并发处理能力。
零拷贝: NIO可以使用transferTo() 和 transferFrom() 方法实现零拷贝，减少数据在内核空间和用户空间之间的拷贝，提高IO效率。
Direct Buffer: 可以使用ByteBuffer.allocateDirect() 创建Direct Buffer，Direct Buffer直接在堆外内存中分配空间，减少数据拷贝，提高IO效率。

NIO的坑和注意事项

Buffer的理解: Buffer的使用是NIO的难点，需要理解Buffer的capacity、position、limit 等属性的含义，以及flip()、clear()、rewind()、compact() 等方法的作用。
Selector的线程安全: Selector不是线程安全的，如果在多个线程中使用同一个Selector，需要进行同步处理。
空轮询: Selector可能会出现空轮询的bug，导致CPU占用率过高。需要采取一些措施来解决空轮询的问题，比如升级JDK版本，或者使用一些开源的NIO框架。
复杂性: NIO编程比传统的IO编程要复杂一些，需要理解NIO的各种概念和API，才能写出高效稳定的NIO程序。

NIO框架推荐

如果不想自己从头开始写NIO程序，可以使用一些开源的NIO框架，比如：

Netty: 一个非常流行的NIO框架，提供了丰富的API和功能，可以快速构建高性能的网络应用程序。
Mina: 另一个流行的NIO框架，和Netty类似，也提供了丰富的API和功能。
Grizzly: GlassFish服务器使用的NIO框架，也可以单独使用。

这些框架已经封装了NIO的底层细节，让你只需要关注业务逻辑，而不用担心NIO的各种坑。

总结

NIO是Java提高网络编程效率的利器。掌握NIO的原理和使用方法，可以让你构建出高性能、高并发的网络应用程序。虽然NIO的学习曲线比较陡峭，但只要你坚持学习和实践，就能掌握NIO的精髓，让你的网络程序跑得飞起！

这次的讲座就到这里，希望对大家有所帮助。下次有机会咱们再聊聊Netty，看看它如何简化NIO编程。祝大家编程愉快！

发表回复 取消回复

发表回复取消回复