NIO系列（二）——Channel通道复制和Selector选择器

以你之姓@ 2022-06-13 02:11 276阅读 0赞

## Channel通道 ##

NIO通过通道来读写数据

Channel有以下实现类

FileChannel：文件读写通道。

DatagramChannel：通过UDP读写网络中的数据。

SocketChannel：通过TCP读写网络中的数据。

ServerSocketChannel：监听新进来的TCP连接，对每个新进来的连接都会创建一个SocketChannel。

Channel读取数据的方式与Buffer相似，也存在position定位。如定位末尾

fileChannel.position(fileChannel.size())

### 通道的数据复制 ###

通道之间，可以通过transferTo、transferFrom来进行数据的复制。

transferTo(position, count, toChannel);

数据传输到toChannel 通道，position是复制开始的坐标、count是复制长度、toChannel是复制的目标通道。

transferFrom(position, count, fromChannel);

从fromChannel 通道复制数据，position是复制开始的坐标、count是复制长度、fromChannel是通道对象。

例子

这个例子是将fromFile.txt文件复制到toFile.txt中。在这个复制中，toFile.txt文件中在count内的内容将被改写，而超过count的内容将保持不变。

@Test
    public voidtransferTo() throwsIOException {
        RandomAccessFile fromfile= new RandomAccessFile("src/main/resources/fromFile.txt", "r");
        FileChannel fromChannel= fromfile.getChannel();
       
        RandomAccessFile tofile= new RandomAccessFile("src/main/resources/toFile.txt", "rw");
        FileChannel toChannel= tofile.getChannel();
       
        fromChannel.transferTo(0, fromChannel.size(), toChannel);
    }

## Selector选择器 ##

Selector选择器可以监听多个Channel通道感兴趣的事情(read、write、accept(服务端接收)、connect，实现一个线程管理多个Channel，节省线程切换上下文的资源消耗。Selector只能管理非阻塞的通道，FileChannel是阻塞的，无法管理。

### 关键对象 ###

Selector：选择器对象，通道注册、通道监听对象和Selector相关。

SelectorKey：通道监听关键字，通过它来监听通道状态。

### 监听注册 ###

监听注册在Selector

socketChannel.register(selector, SelectionKey.OP_READ);

监听的事件有

OP\_ACCEPT: 接收就绪，serviceSocketChannel使用的

OP\_READ: 读取就绪，socketChannel使用

OP\_WRITE: 写入就绪，socketChannel使用

OP\_CONNECT: 连接就绪，socketChannel使用

可以用过OP\_READ| OP\_WRITE方式注册多个事件

socketChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE|SelectionKey.OP_CONNECT);

### 例子 ###

public classSelectorTest {
        Selectorselector= null;
        SocketChannelsocketChannel = null;
       
        @Before
        public void before(){
           try {
               selector = Selector.open();
               socketChannel = SocketChannel.open();
               socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
               socketChannel.configureBlocking(false);
           }catch(IOException e) {
               e.printStackTrace();
           }
        }
     
        @Test
        public void selectorTest() throws IOException {
           socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE | SelectionKey.OP_CONNECT);
           while (true) {
               int n = selector.select();
               if (n == 0)
                  continue;
               Iterator keyIterator= selector.selectedKeys().iterator();
               while (keyIterator.hasNext()) {
                  SelectionKey key1= (SelectionKey) keyIterator.next();
                  if (key1.isAcceptable()) {
                      System.out.println("服务端接收就绪");
                  }else if(key1.isConnectable()){
                      System.out.println("客户端连接接续");
                  }else if(key1.isReadable()){
                      System.out.println(key1.hashCode() + "读取就绪");
                      SocketChannel socketChannel1= (SocketChannel) key1.channel();
                      ByteBuffer bBuffer= ByteBuffer.allocate(48);
                      for (int readSize = socketChannel1.read(bBuffer); readSize != -1; readSize = socketChannel1
                             .read(bBuffer)) {
                         if (readSize == 0)
                             continue;
                         bBuffer.flip();
                         System.out.println(Charset.forName("UTF-8").decode(bBuffer));
                         bBuffer.clear();
                      }
                      socketChannel1.close();
                  }elseif(key1.isWritable()){
                      System.out.println(key1.hashCode() + "写入就绪");
                  }
                  keyIterator.remove();
               }
           }
        }
    }