三.Netty入门到超神系列-Java NIO 三大核心(selector,channel,buffer)

Bertha 。 2022-09-01 12:53 108阅读 0赞

# 前言 #

上一章节我们理解了Java NIO三大核心，以及重点讲解了Buffer的原理和几个使用场景，其中也用到了channel。这一章我们来理解一下selector,结合channel来做一个c/s通信。

# 理解Selector 和 Channel #

Selector 选择器，也叫多路复用器，可以同时处理多个客户端连接，多路复用器采用轮询机制来选择有读写事件的客户端链接进行处理。

通过 Selector ，一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这解决了传统同步阻塞 I/O 一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

由于它的读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。

这里在整理一下它的工作原理，如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ0OTQxNDg_size_16_color_FFFFFF_t_70]  
Selector ：多路复用器(也叫选择器)的作用就是提供给SocketChannel通道来注册，然后Selector会轮询的去监听通道通道的读写事件从而做出相应的IO处理，它 的工作流程如下：

1.  首先需要创建一个ServerSocketChannel，它类似于(ServerSocket)需要指定一个监听的IP和Port。需要注意的是ServerSocketChannel为了兼容BIO，默认是阻塞的，可以通过ServerSocketChannel\#configureBlocking(false)来指定为NIO模式。
    
    通过ServerSocketChannel 可以获取一个客户端的SocketChannel ,客户端的SocketChannel 需要注册到Selector上,然后每个通道都会对应一个SelectionKey
2.  选择器可以通过Selector.open() 创建，然后将 ServerSocketChannel 注册给Selector 。选择器的 Selector\#select() 方法 可以选择有事件的通道(SocketChannel )，并返回已就绪的通道数量.事件类型包括：“连接”，“接收” ，“读”,“写”。
3.  如果 Selector\#select() 返回值大于0代表某些通道有事件发生，可以通过 selector.selectedKeys() 来得到所有有事件通道的SelectionKey。
    
    然后可以通过SelectionKey方向拿到SocketChannel ， 从而将SocketChannel 中的数据读取到Buffer中，完成IO操作。

## ServerSocketChannel ##

ServerSocketChannel 是服务端用来用来监听客户端Socket链接，通过accept方法可以获取客户端SocketChannel，从而将 SocketChannel 注册到Selector，相关方法如下

*  open : 创建一个 ServerSocketChannel 通道
 *  bind(SocketAddress local）：设置服务器端监听的地址和端口号
 *  configureBlocking(boolean block) ： 设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
 *  accept() ：接受一个连接，返回代表这个连接的通道对象SocketChannel
 *  register(Selector sel, int ops)： 把当前通道注册到选择器，并设置监听事件

## SocketChannel ##

一个客户端链接服务端就会产生通道：ServerChannel ，需要注册到Selector，被Selector监听通道的读写事件。ServerChannel 负责具体的读写，把缓冲区的数据写入通道，或者把通道中的数据写入缓冲区。

*  open() ： 得到一个 SocketChannel 通道
 *  configureBlocking(boolean block)：设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
 *  connect(SocketAddress remote) ：连接远程服务器，通过SocketAddress 指定IP和端口
 *  finishConnect()： 如果connect连接失败，就要通过finishConnect方法完成连接操作
 *  write(ByteBuffer src) ： 把ByteBuffer中的数据，往通道里写
 *  read(ByteBuffer dst) ：从通道里读数据，写入ByteBuffer
 *  register(Selector sel, int ops, Object att): 把该通道注册到selector,并设置监听事件(OPS)，最后一个参数可以设置共享数据，该方法会返回一个 SelectionKey ，这个key对应了该通道。
 *  close() ：关闭通道

## SelectionKey ##

当 ServerChannel 注册到Selector就会产生SelectionKey ， 通过SelectionKey可以反向获得SocketChannel通道对象，从而进行IO读写操作。

*  selector(): 通过SelectionKey 获取得到与之关联的 Selector 对象
 *  channel()：得到与之关联的通道
 *  attachment()：得到与之关联的共享数据
 *  interestOps(int ops)：设置或改变监听事件
 *  isAcceptable()：是否可以 accept，“接收就绪”事件
 *  isReadable()：是否可以读
 *  isWritable()：是否可以写

事件包括：

SelectionKey.OP_CONNECT : 值 16，连接就绪 ，比如：一个 channel连接到一个服务器
    	SelectionKey.OP_ACCEPT ： 值 8，接收就绪，比如：ServerSocketChannel准备好接入新的连接
    	SelectionKey.OP_READ ：值 1，“读就绪”，通道有可以读数据可以说是
    	SelectionKey.OP_WRITE ： 值 4 ，“写就绪” ，等待写数据的通道可以说

## Selector ##

负责采用轮询方式监听通道，当通道有读写事件就进行IO操作。

*  open() ：得到一个选择器对象
 *  select(long timeout)：选择有事件的通道，将其对应的 SelectionKey 加入到内部集合中，返回通道的数量
 *  selectedKeys() ： 从内部集合中得到所有有事件 SelectionKey
 *  keys() : 从内部集合中得到所有SelectionKey
 *  close：关闭选择器

# 综合案例 #

使用selector ，ServerSocketChannel，SocketChannel完成一个 C/S 案例，

## 服务端代码 ##

//通道
    @Test
    public void serverSocketChannelTest() throws IOException { 
    
       //创建服务端通道
       ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    
       //socket监听地址和端口
       SocketAddress socketAddress = new InetSocketAddress("127.0.0.1",5000);
    
       //和某个SocketAddress绑定
       serverSocketChannel.bind(socketAddress);
    
       //NIO默认采用阻塞，为了兼容BIO
       serverSocketChannel.configureBlocking(false);
    
       //创建选择器
       Selector selector = Selector.open();
    
       //通道注册到选择器,事件类型为：OP_ACCEPT “接受”
       serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    
       //==选择器轮询=======================================================================
    
       while(true){ 
           //select,选择有事件的通道，返回有事件发生通道的key的个数 ,超时时间 1s
           if(selector.select(1000) == 0){ 
               System.out.println("无连接...轮询等待...\");
               continue;
           }
           //有事件发生,得到有事件的通道的key的集合
           Set<SelectionKey> selectionKeys = selector.selectedKeys();
           Iterator<SelectionKey> iterator = selectionKeys.iterator();
           //遍历key的集合
           while (iterator.hasNext()){ 
               //拿到每个通道的key
               SelectionKey key = iterator.next();
               //如果当前通道事件是： OP_ACCEPT ,就注册通道
               if(key.isAcceptable()){ 
                   //接收一个socketChannel
                   SocketChannel socketChannel = serverSocketChannel.accept();
                   System.out.println("客户端链接成功...");
                   socketChannel.configureBlocking(false);
                   //把socketChannel注册到选择器 ，并给通道绑定一个buffer
                   socketChannel.register(selector, SelectionKey.OP_READ,ByteBuffer.allocate(1024));
               }
    
               //如果通道事件是： OP_READ,说明通道有数据
               if(key.isReadable()){ 
                   //通过key得到SocketChannel
                   SocketChannel channel = (SocketChannel)key.channel();
                   //得到channel绑定的buffer
                   ByteBuffer byteBuffer = (ByteBuffer)key.attachment();
                   //从通道把数据读取到buffer
                   channel.read(byteBuffer);
    
                   System.out.println(new String(byteBuffer.array()));
               }
               //删除当前key
               iterator.remove();
           }
       }
    }

## 客户端代码 ##

//通道
        @Test
        public void socketChannelTest() throws IOException { 
    		//创建一个SocketChannel
            SocketChannel socketChannel = SocketChannel.open();
    
    		//使用非阻塞模式
            socketChannel.configureBlocking(false);
    
    		//链接的地址和端口
            InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 5000);
    		//尝试链接，如果使用的异步，那么需要使用 socketChannel.finishConnect() 来确保连接成功。
            if(!socketChannel.connect(inetSocketAddress)){ 
            	//如果没链接成功，会通过while循环，直到 finishConnect 链接成功，跳出while
                while(!socketChannel.finishConnect()){ 
                    System.out.println("还未完成链接...等待中...");
                }
            }
    
            //链接成功，把数据写出去
            socketChannel.write(ByteBuffer.wrap("你好".getBytes()));
            System.out.println("向服务端发送数据...");
            //防止客户端结束，所以使用read()阻塞
            System.in.read();
        }

# 总结 #

本篇文章介绍了Selector ,ServerSocketChannel ，SocketChannel的作用，场景API，和三种的工作原理，并通过一个C/S综合案例来演示三者之间的关系。

文章结束，希望对你有所帮助，你的鼓励是我最大的动力，如果喜欢，请不要吝啬你的一键三连哦！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ0OTQxNDg_size_16_color_FFFFFF_t_70]: /images/20220829/7d7ec5d04f4e42818629e36be2421f0b.png