NIO--选择器（Selector）

╰半橙微兮° 2021-08-26 22:06 417阅读 0赞

### 选择器（Selector） ###

选择器(Selector) 是 SelectableChannle 对象的多路复用器，Selector 可 以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector 可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心。

SelectableChannle 的结构如下图:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]

### 选择器的使用 ###

创建Selector：

通过调用Selector.open()方法创建一个Selector。

//创建选择器
    Selector selector = Selector.open();

向选择器注册通道：

SelectableChannel.register(Selector sel, int ops)

//创建一个Socket套接字
    Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9898);
    
    //获取SocketChannel
    SocketChannel channel = socket.getChannel();
    
    //创建选择器
    Selector selector = Selector.open();
    
    //将SocketChannel切换到非阻塞模式
    channel.configureBlocking(false);
    
    //向Selector注册Channel
    SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

当调用 register(Selector sel, int ops) 将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数 ops 指定。

可以监听的事件类型(可使用 SelectionKey 的四个常量表示):

*  读 : SelectionKey.OP\_READ (1)
 *  写 : SelectionKey.OP\_WRITE (4)
 *  连接:SelectionKey.OP\_CONNECT (8)
 *  接收 : SelectionKey.OP\_ACCEPT (16)

若注册时不止监听一个事件，则可以使用“位或”操作符连接。

//注册『监听事件』
    int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

### SelectionKey ###

表示 SelectableChannel 和 Selector 之间的注册关系。每次向 选择器注册通道时就会选择一个事件(选择键)。选择键包含两个表示为整 数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操 作。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]

### Selector的常用方法 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]

SocketChannel：

Java NIO 中的SocketChannel是一个连接到TCP网络套接字的通道。

*  打开SocketChannel
 *  读写数据
 *  关闭SocketChannel

ServerSocketChannel：

Java NIO中的ServerSocketChannel是一个可以监听新进来的TCP连接的通道，就像标准IO中的ServerSocket一样。

DatagramChannel：

Java NIO中的DatagramChannel是一个能收发UDP包的通道。

*  打开DatagramChannel
 *  接收/发送数据

### 测试 ###

SocketChannel:

package com.atguigu.nio;
    
    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.Date;
    import java.util.Iterator;
    import java.util.Scanner;
    
    import org.junit.Test;
    
    /* * 一、使用 NIO 完成网络通信的三个核心： * * 1. 通道（Channel）：负责连接 * * java.nio.channels.Channel 接口： * |--SelectableChannel * |--SocketChannel * |--ServerSocketChannel * |--DatagramChannel * * |--Pipe.SinkChannel * |--Pipe.SourceChannel * * 2. 缓冲区（Buffer）：负责数据的存取 * * 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况 * */
    public class TestNonBlockingNIO { 
    	
    	//客户端
    	@Test
    	public void client() throws IOException{ 
    		//1. 获取通道
    		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
    		
    		//2. 切换非阻塞模式
    		sChannel.configureBlocking(false);
    		
    		//3. 分配指定大小的缓冲区
    		ByteBuffer buf = ByteBuffer.allocate(1024);
    		
    		//4. 发送数据给服务端
    		Scanner scan = new Scanner(System.in);
    		
    		while(scan.hasNext()){ 
    			String str = scan.next();
    			buf.put((new Date().toString() + "\n" + str).getBytes());
    			buf.flip();
    			sChannel.write(buf);
    			buf.clear();
    		}
    		
    		//5. 关闭通道
    		sChannel.close();
    	}
    
    	//服务端
    	@Test
    	public void server() throws IOException{ 
    		//1. 获取通道
    		ServerSocketChannel ssChannel = ServerSocketChannel.open();
    		
    		//2. 切换非阻塞模式
    		ssChannel.configureBlocking(false);
    		
    		//3. 绑定连接
    		ssChannel.bind(new InetSocketAddress(9898));
    		
    		//4. 获取选择器
    		Selector selector = Selector.open();
    		
    		//5. 将通道注册到选择器上, 并且指定“监听接收事件”
    		ssChannel.register(selector, SelectionKey.OP_ACCEPT);
    		
    		//6. 轮询式的获取选择器上已经“准备就绪”的事件
    		while(selector.select() > 0){ 
    			
    			//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
    			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
    			
    			while(it.hasNext()){ 
    				//8. 获取准备“就绪”的是事件
    				SelectionKey sk = it.next();
    				
    				//9. 判断具体是什么事件准备就绪
    				if(sk.isAcceptable()){ 
    					//10. 若“接收就绪”，获取客户端连接
    					SocketChannel sChannel = ssChannel.accept();
    					
    					//11. 切换非阻塞模式
    					sChannel.configureBlocking(false);
    					
    					//12. 将该通道注册到选择器上
    					sChannel.register(selector, SelectionKey.OP_READ);
    				}else if(sk.isReadable()){ 
    					//13. 获取当前选择器上“读就绪”状态的通道
    					SocketChannel sChannel = (SocketChannel) sk.channel();
    					
    					//14. 读取数据
    					ByteBuffer buf = ByteBuffer.allocate(1024);
    					
    					int len = 0;
    					while((len = sChannel.read(buf)) > 0 ){ 
    						buf.flip();
    						System.out.println(new String(buf.array(), 0, len));
    						buf.clear();
    					}
    				}
    				
    				//15. 取消选择键 SelectionKey
    				it.remove();
    			}
    		}
    	}
    }

DatagramChannel:

package com.atguigu.nio;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.DatagramChannel;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.util.Date;
    import java.util.Iterator;
    import java.util.Scanner;
    
    import org.junit.Test;
    
    public class TestNonBlockingNIO2 { 
    	
    	@Test
    	public void send() throws IOException{ 
    		DatagramChannel dc = DatagramChannel.open();
    		
    		dc.configureBlocking(false);
    		
    		ByteBuffer buf = ByteBuffer.allocate(1024);
    		
    		Scanner scan = new Scanner(System.in);
    		
    		while(scan.hasNext()){ 
    			String str = scan.next();
    			buf.put((new Date().toString() + ":\n" + str).getBytes());
    			buf.flip();
    			dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
    			buf.clear();
    		}
    		
    		dc.close();
    	}
    	
    	@Test
    	public void receive() throws IOException{ 
    		DatagramChannel dc = DatagramChannel.open();
    		
    		dc.configureBlocking(false);
    		
    		dc.bind(new InetSocketAddress(9898));
    		
    		Selector selector = Selector.open();
    		
    		dc.register(selector, SelectionKey.OP_READ);
    		
    		while(selector.select() > 0){ 
    			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
    			
    			while(it.hasNext()){ 
    				SelectionKey sk = it.next();
    				
    				if(sk.isReadable()){ 
    					ByteBuffer buf = ByteBuffer.allocate(1024);
    					
    					dc.receive(buf);
    					buf.flip();
    					System.out.println(new String(buf.array(), 0, buf.limit()));
    					buf.clear();
    				}
    			}
    			
    			it.remove();
    		}
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]: /images/20210813/be32d74f56bd45f8a99d3ed28ee70ec5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]: /images/20210813/254f417bae394a8489fff9679d4b1f21.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]: /images/20210813/dbd28bfe505945c782ce3230db374f9a.png