NIO 三大核心-Selector

基本介绍：

• Java的NIO， 用非阻塞的 I/O 方式。可以用一个线程，处理多个客户端连接，就会用到Selector(选择器)
• Selector 能够检测多个注册的通道上是否有事件发生（注意：多个Channel 以事件的方式可以注册到同一个Selector）, 如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求
• 只有在连接真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程
• 避免了多线程之间的上下文切换导致的开销
• Netty 的 IO 线程 NioEventLoop 聚合了Selector(选择器 也叫 多路复用器)，可以同时并发处理成百上千客户端连接
• 当线程从某客户端socket通道进行读写数据时，若没有数据可用，该线程可以进行其他任务
• 线程通常将非阻塞IO的空闲时间用于在其他通道上执行IO操作，所以单独的线程可以管理多个输入和输出通道
• 由于读写操作都是非阻塞的，这就可以充分提升IO线程的运行效率，避免由于频繁I/O阻塞导致的线程挂起
• 一个I/O线程可以并发处理N个客户端连接和读写操作，这从根本上解决了传统同步阻塞I/O-连接-线程模型，架构的性能、弹性伸缩能力和可靠性都得到极大的提升

 selector 相关方法

方法	说明
public static Selector open()	得到一个选择器对象
public abstract Set<SelectionKey> selectedKeys()	从内部集合中得到所有的SelectionKey
public abstract int select(long timeout)	监控所有注册的通道，当其中有IO操作可以进行时，将对应的SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
public abstract int select()	阻塞
public abstract Selector wakeup()	唤醒Selector
public abstract int selectNow()	不阻塞，立即返回

NIO 网络编程关系梳理：

•  当客户端连接时，会通过 ServerSocketChannel 得到对应的 SocketChannel 
• 将socketChannel 注册到 Selector 上 （ register(Selector sel, int ops) ） 一个selector上可以注册多个SocketChannel
• 注册后返回一个SelectionKey, 会和该Selector关联（ 集合 ）
• Selector 进行监听 select 方法，返回有事件发生的通道的个数
• 进一步得到各个 SelectionKey ( 有事件发生 )
• 再通过 SelectionKey 反向获取 SocketChannel （ channel() ）
• 可以通过 得到的channel, 完成业务处理

Server 端示例代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

/**
 * @author doubily
 */
public class NIOServer {
    public static void main(String[] args) throws IOException {

        // 创建ServerSocketChannel -> ServerSocket
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        // 得到一个Selector 对象
        Selector selector = Selector.open();

        // 绑定一个端口, 在服务器端监听
        serverSocketChannel.socket().bind(new InetSocketAddress(9527));

        // 设置为非阻塞
        serverSocketChannel.configureBlocking(false);

        // 把serverSocketChannel 注册到 selector 关心事件为 OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 循环等待客户端连接
        while(true) {
            // 等待一秒 没有事件发生
            if (selector.select(1000) == 0) {
                System.out.println("服务器等待了1秒, 无连接");
                continue;
            }

            // 如果返回的 > 0, 表示已经获取到关注的事件  就获取到相关的 selectionKey 集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();

            // 通过selectionKeys 反向获取通道
            Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
            while (keyIterator.hasNext()) {
                // 获取到SelectKey
                SelectionKey key = keyIterator.next();

                // 根据key 对应的通道发生的事件做不同的处理
                // 有新的客户端连接
                if (key.isAcceptable()) {
                    // 给该客户端生成一个socketChannel, accept 非阻塞
                    SocketChannel socketChannel = serverSocketChannel.accept();

                    System.out.println("客户端连接成功 生成了一个socketChannel:" + socketChannel.hashCode());
                    socketChannel.configureBlocking(false);

                    // 将socketChanel 注册到 selector, 关注事件为读，同时给该 socketChannel 关联一个buffer
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }

                if (key.isReadable()) {
                    // 通过key 反向获取到对应的 channel
                    SocketChannel channel = (SocketChannel) key.channel();

                    // 获取到该channel 关联的buffer
                    ByteBuffer buffer = (ByteBuffer)key.attachment();
                    channel.read(buffer);

                    System.out.println("客户端发送数据为：" + new String(buffer.array()) );
                }

                // 手动从集合中移除当前的selectionKey, 防止重复操作
                keyIterator.remove();
            }
        }
    }
}

Client 端示例代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 * @author doubily
 */
public class NIOClient {
    public static void main(String[] args) throws IOException {
        // 得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();

        // 设置非阻塞
        socketChannel.configureBlocking(false);

        // 提供服务端的IP 和 端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 9527);

        // 连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("因为连接需要事件,客户端不会阻塞, 可以做其他工作..");
            }
        }

        // 如果连接成功就发送数据
        String str = "hello, NIO~";
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_8));

        // 发送数据, 将buffer 输入写入 channel
        socketChannel.write(buffer);

        System.in.read();
    }
}

SelectionKey 相关方法和属性：

方法/属性	说明
public abstract Selector selector();	得到与之关联的Selector 对象
public abstract SelectableChannel channel();	得到与之关联的通道
public final Object attachment();	得到与之关联的共享数据
public abstract SelectionKey interestOps(int ops):	设置或改变监听事件
public final boolean isAcceptable();	是否可以 accept
public final boolean isReadable();	是否可以读
public final boolean isWritable();	是否可以写
OP ACCEPT	有新的网络连接可以 accept，值为 16
OP_CONNECT	代表连接已经建立，值为 8
OP READ	代表读操作，值为 1
OP WRITE	代表写操作，值为 4