华为二面！！！面试官直接问我Java中到底什么是NIO？这不是直接送分题？？？

ゝ一世哀愁。 2022-09-14 13:27 53阅读 0赞

### 华为二面！！！面试官直接问我Java中到底什么是NIO？这不是直接送分题？？？ ###

*  什么是NIO
 *  缓冲区(Buffer)
 *   *  缓冲区类型
     *  获取缓冲区
     *  核心属性
     *  核心方法
 *  非直接缓冲区和直接缓冲区
 *   *  非直接缓冲区
     *  直接缓冲区
 *  通道(Channel)
 *   *  Java Channel
     *   *  获得通道的方法
         *   *  对象调用getChannel() 方法
             *  getChannel()+非直接缓冲区
             *  open()+直接缓冲区
             *  通道间直接传输
             *  直接缓冲区VS非直接缓冲区
     *  分散和聚集
 *  非阻塞式网络通信
 *   *  概念
     *  阻塞式网络通信
     *  非阻塞式网络通信
     *   *  选择器

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASmF2YeaetuaehOayoeaciTk5Ng_size_14_color_FFFFFF_t_70_g_se_x_16][]

# 什么是NIO #

Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，**可以替代标准的Java IO API**。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持**面向缓冲区的、基于通道的IO操作**。NIO将以更加高效的方式进行文件的读写操作。

<table> 
 <thead> 
  <tr> 
   <th>IO</th> 
   <th>NIO</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>面向流(Stream Oriented)</td> 
   <td>面向缓冲区(Buffer Oriented)</td> 
  </tr> 
  <tr> 
   <td>阻塞IO(Blocking IO)</td> 
   <td>非阻塞IO(NonBlocking IO)</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>选择器(Selectors)</td> 
  </tr> 
 </tbody> 
</table>

底层原理可见：[操作系统-文件IO][-_IO]

# 缓冲区(Buffer) #

## 缓冲区类型 ##

Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同(**boolean 除外**) ，有以下Buffer 常用子类

*  ByteBuffer
 *  CharBuffer
 *  ShortBuffer
 *  IntBuffer
 *  LongBuffer
 *  FloatBuffer
 *  DoubleBuffer

**各种类型的缓冲区中，都有一个对应类型的数组**，如

ByteBuffer

final byte[] hb;                  // Non-null only for heap buffersCopy

IntBuffer

final int[] hb;                  // Non-null only for heap buffers

[![image][]][image 1]

## 获取缓冲区 ##

通过**allocate方法**可以获取一个对应缓冲区的对象，它是缓冲区类的一个静态方法

例

// 获取一个容量大小为1024字节的字节缓冲区
    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

## 核心属性 ##

缓冲区的父类Buffer中有几个核心属性，如下

// Invariants: mark <= position <= limit <= capacity
    private int mark = -1;
    private int position = 0;
    private int limit;
    private int capacity;Copy

*  capacity：缓冲区的容量。通过构造函数赋予，一旦设置，无法更改
 *  limit：缓冲区的界限。位于limit 后的数据不可读写。缓冲区的限制不能为负，并且**不能大于其容量**
 *  position：**下一个**读写位置的索引（类似PC）。缓冲区的位置不能为负，并且**不能大于limit**
 *  mark：记录当前position的值。**position被改变后，可以通过调用reset() 方法恢复到mark的位置。**

以上四个属性必须满足以下要求

**mark <= position <= limit <= capacity**

## 核心方法 ##

**put()方法**

*  put()方法可以将一个数据放入到缓冲区中。
 *  进行该操作后，postition的值会+1，指向下一个可以放入的位置。capacity = limit ，为缓冲区容量的值。

[![image][image 2]][image_image 2]

**flip()方法**

*  flip()方法会**切换对缓冲区的操作模式**，由写->读 / 读->写
 *  进行该操作后
    
     *  如果是写模式->读模式，position = 0 ， limit 指向最后一个元素的下一个位置，capacity不变
     *  如果是读->写，则恢复为put()方法中的值

[![image][image 3]][image_image 3]

**get()方法**

*  get()方法会读取缓冲区中的一个值
 *  进行该操作后，position会+1，如果超过了limit则会抛出异常

**rewind()方法**

*  该方法**只能在读模式下使用**
 *  rewind()方法后，会恢复position、limit和capacity的值，变为进行get()前的值

**clean()方法**

*  clean()方法会将缓冲区中的各个属性恢复为最初的状态，position = 0, capacity = limit
 *  **此时缓冲区的数据依然存在**，处于“被遗忘”状态，下次进行写操作时会覆盖这些数据

[![image][image 4]][image_image 4]

**mark()和reset()方法**

*  mark()方法会将postion的值保存到mark属性中
 *  reset()方法会将position的值改为mark中保存的值

**使用展示**

import java.nio.ByteBuffer;
    
    public class demo1 {
        public static void main(String[] args) {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    
            System.out.println("放入前参数");
            System.out.println("position " + byteBuffer.position());
            System.out.println("limit " + byteBuffer.limit());
            System.out.println("capacity " + byteBuffer.capacity());
            System.out.println();
    
            System.out.println("------put()------");
            System.out.println("放入3个数据");
            byte bt = 1;
            byteBuffer.put(bt);
            byteBuffer.put(bt);
            byteBuffer.put(bt);
    
            System.out.println("放入后参数");
            System.out.println("position " + byteBuffer.position());
            System.out.println("limit " + byteBuffer.limit());
            System.out.println("capacity " + byteBuffer.capacity());
            System.out.println();
    
            System.out.println("------flip()-get()------");
            System.out.println("读取一个数据");
            // 切换模式
            byteBuffer.flip();
            byteBuffer.get();
    
            System.out.println("读取后参数");
            System.out.println("position " + byteBuffer.position());
            System.out.println("limit " + byteBuffer.limit());
            System.out.println("capacity " + byteBuffer.capacity());
            System.out.println();
    
            System.out.println("------rewind()------");
            byteBuffer.rewind();
            System.out.println("恢复后参数");
            System.out.println("position " + byteBuffer.position());
            System.out.println("limit " + byteBuffer.limit());
            System.out.println("capacity " + byteBuffer.capacity());
            System.out.println();
    
            System.out.println("------clear()------");
            // 清空缓冲区，这里只是恢复了各个属性的值，但是缓冲区里的数据依然存在
            // 但是下次写入的时候会覆盖缓冲区中之前的数据
            byteBuffer.clear();
            System.out.println("清空后参数");
            System.out.println("position " + byteBuffer.position());
            System.out.println("limit " + byteBuffer.limit());
            System.out.println("capacity " + byteBuffer.capacity());
            System.out.println();
            System.out.println("清空后获得数据");
            System.out.println(byteBuffer.get());
    
        }
    }

放入前参数
    position 0
    limit 1024
    capacity 1024
    
    ------put()------
    放入3个数据
    放入后参数
    position 3
    limit 1024
    capacity 1024
    
    ------flip()-get()------
    读取一个数据
    读取后参数
    position 1
    limit 3
    capacity 1024
    
    ------rewind()------
    恢复后参数
    position 0
    limit 3
    capacity 1024
    
    ------clear()------
    清空后参数
    position 0
    limit 1024
    capacity 1024
    
    清空后获得数据
    1
    
    Process finished with exit code 0

# 非直接缓冲区和直接缓冲区 #

## 非直接缓冲区 ##

通过**allocate()方法获取的缓冲区都是非直接缓冲区。这些缓冲区是建立在JVM堆内存**之中的。

public static ByteBuffer allocate(int capacity) {
       if (capacity < 0)
       throw new IllegalArgumentException();
    
       // 在堆内存中开辟空间
       return new HeapByteBuffer(capacity, capacity);
    }
    
    HeapByteBuffer(int cap, int lim) {        // package-private
       // new byte[cap] 创建数组，在堆内存中开辟空间
       super(-1, 0, lim, cap, new byte[cap], 0);
       /*
       hb = new byte[cap];
       offset = 0;
       */
    }

通过非直接缓冲区，想要将数据写入到物理磁盘中，或者是从物理磁盘读取数据。**都需要经过JVM和操作系统**，数据在两个地址空间中传输时，会**copy**一份保存在对方的空间中。所以费直接缓冲区的读取效率较低.。

[![image][image 5]][image_image 5]

## 直接缓冲区 ##

**只有ByteBuffer可以获得直接缓冲区**，通过allocateDirect()获取的缓冲区为直接缓冲区，这些缓冲区是建立在**物理内存**之中的。

public static ByteBuffer allocateDirect(int capacity) {
       return new DirectByteBuffer(capacity);
    }
    
    DirectByteBuffer(int cap) {                   // package-private
       ...
       // 申请物理内存
       boolean pa = VM.isDirectMemoryPageAligned();
       ...
    }

直接缓冲区通过在操作系统和JVM之间创建**物理内存映射文件**加快缓冲区数据读/写入物理磁盘的速度。放到物理内存映射文件中的数据就不归应用程序控制了，操作系统会自动将物理内存映射文件中的数据写入到物理内存中。

[![image][image 6]][image_image 6]

# 通道(Channel) #

Channel由java.nio.channels 包定义的。Channel 表示**IO 源与目标打开的连接**。Channel 类似于传统的“流”。只不过**Channel 本身不能直接访问数据，Channel 只能与Buffer 进行交互** 。

应用程序进行读写操作调用函数时，**底层调用的操作系统提供给用户的读写API**，调用这些API时会生成对应的指令，CPU则会执行这些指令。在计算机刚出现的那段时间，**所有读写请求的指令都有CPU去执行**，过多的读写请求会导致CPU无法去执行其他命令，从而CPU的利用率降低。

[![image][image 7]][image_image 7]

后来，**DMA**(Direct Memory Access，直接存储器访问)出现了。当IO请求传到计算机底层时，**DMA会向CPU请求，让DMA去处理这些IO操作**，从而可以让CPU去执行其他指令。DMA处理IO操作时，会请求获取总线的使用权。**当IO请求过多时，会导致大量总线用于处理IO请求，从而降低效率** 。

[![image][image 8]][image_image 8]

于是便有了**Channel(通道)**，Channel相当于一个**专门用于IO操作的独立处理器**，它具有独立处理IO请求的能力，当有IO请求时，它会自行处理这些IO请求 。

[![image][image 9]][image_image 9]

## Java Channel ##

[![image][image 10]][image_image 10]

*  本地文件IO
    
     *  FileChannel
 *  网络IO
    
     *  SocketChanel、ServerSocketChannel：用于TCP传输
     *  DatagramChannel：用于UDP传输

### 获得通道的方法 ###

#### 对象调用getChannel() 方法 ####

获取通道的一种方式是对支持通道的**对象调用getChannel() 方法**。支持通道的类如下：

*  FileInputStream
 *  FileOutputStream
 *  RandomAccessFile
 *  DatagramSocket
 *  Socket
 *  ServerSocket

例子：

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.net.DatagramSocket;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.nio.channels.DatagramChannel;
    import java.nio.channels.FileChannel;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.nio.file.Paths;
    
    public class demo2 {
        
        public static void main(String[] args) throws IOException {
        
            // 本地通道
            FileInputStream fileInputStream = new FileInputStream("zwt");
            FileChannel channel1 = fileInputStream.getChannel();
    
            FileOutputStream fileOutputStream = new FileOutputStream("zwt");
            FileChannel channel2 = fileOutputStream.getChannel();
    
            // 网络通道
            Socket socket = new Socket();
            SocketChannel channel3 = socket.getChannel();
    
            ServerSocket serverSocket = new ServerSocket();
            ServerSocketChannel channel4 = serverSocket.getChannel();
    
            DatagramSocket datagramSocket = new DatagramSocket();
            DatagramChannel channel5 = datagramSocket.getChannel();
    
            // 最后要关闭通道
    
            FileChannel open = FileChannel.open(Paths.get("zwt"));
    
            SocketChannel open1 = SocketChannel.open();
    
        }
    }

#### getChannel()+非直接缓冲区 ####

*  getChannel()获得通道
 *  allocate()获得**非直接缓冲区**

通过非直接缓冲区读写数据，需要通过通道来传输缓冲区里的数据

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    public class demo4 {
        public static void main(String[] args) {
            FileInputStream is = null;
            FileOutputStream os = null;
            // 获得通道
            FileChannel inChannel = null;
            FileChannel outChannel = null;
    
            // 利用 try-catch-finally 保证关闭
            try {
                is = new FileInputStream("");
                os = new FileOutputStream("");
    
                // 获得通道
                inChannel = is.getChannel();
                outChannel = os.getChannel();
    
                // 获得缓冲区，用于在通道中传输数据
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    
                // 循环将字节数据放入到buffer中，然后写入磁盘中
                while (inChannel.read(byteBuffer) != -1) {
                    // 切换模式
                    byteBuffer.flip();
                    outChannel.write(byteBuffer);
                    byteBuffer.clear();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (inChannel != null) {
                    try {
                        inChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (outChannel != null) {
                    try {
                        outChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (os != null) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

#### open()+直接缓冲区 ####

*  通过open获得通道
 *  通过FileChannel.map()获取直接缓冲区

使用直接缓冲区时，无需通过通道来传输数据，直接将数据放在缓冲区内即可

import java.io.IOException;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.file.Paths;
    import java.nio.file.StandardOpenOption;
    
    public class demo5 {
       public static void main(String[] args) throws IOException {
           // 通过open()方法来获得通道
           FileChannel inChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ);
    
           // outChannel需要为 READ WRITE CREATE模式
           // READ WRITE是因为后面获取直接缓冲区时模式为READ_WRITE模式
           // CREATE是因为要创建新的文件
           FileChannel outChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
    
           // 获得直接缓冲区
           MappedByteBuffer inMapBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
           MappedByteBuffer outMapBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());
    
           // 字节数组
           byte[] bytes = new byte[inMapBuf.limit()];
    
           // 因为是直接缓冲区，可以直接将数据放入到内存映射文件，无需通过通道传输
           inMapBuf.get(bytes);
           outMapBuf.put(bytes);
    
           // 关闭缓冲区，这里没有用try-catch-finally
           inChannel.close();
           outChannel.close();
       }
    }

#### 通道间直接传输 ####

public static void channelToChannel() throws IOException {
      long start = System.currentTimeMillis();
      // 通过open()方法来获得通道
      FileChannel inChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ);
    
      // outChannel需要为 READ WRITE CREATE模式
      // READ WRITE是因为后面获取直接缓冲区时模式为READ_WRITE模式
      // CREATE是因为要创建新的文件
      FileChannel outChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
    
      // 通道间直接传输
      inChannel.transferTo(0, inChannel.size(), outChannel);
      // 对应的还有transferFrom
      // outChannel.transferFrom(inChannel, 0, inChannel.size());
    
      inChannel.close();
      outChannel.close();
    }

#### 直接缓冲区VS非直接缓冲区 ####

// getChannel() + 非直接缓冲区耗时
    708
    // open() + 直接缓冲区耗时
    115
    // channel transferTo channel耗时
    47
    
    直接缓冲区的读写速度虽然很快，但是会占用很多很多内存空间。如果文件过大，会使得计算机运行速度变慢

## 分散和聚集 ##

**分散读取**

分散读取（Scattering Reads）是指**从Channel 中读取的数据“分散”到多个Buffer 中。**

**注意**：按照缓冲区的**顺序**，从Channel 中读取的数据依次将 Buffer 填满。

**聚集写入**

聚集写入（Gathering Writes）是指将**多个Buffer 中的数据“聚集”到Channel。**

按照缓冲区的**顺序**，写入position 和limit 之间的数据到Channel。

# 非阻塞式网络通信 #

## 概念 ##

底层原理可见：[操作系统-文件IO][-_IO]

比喻：

举个你去饭堂吃饭的例⼦，你好⽐⽤户程序，饭堂好⽐操作系统。
    
    阻塞 I/O 好⽐，
    你去饭堂吃饭，但是饭堂的菜还没做好，然后你就⼀直在那⾥等啊等，
    
    等了好⻓⼀段时间终于等到饭堂阿姨把菜端了出来（数据准备的过程），
    
    但是你还得继续等阿姨把菜（内核空间）打到你的饭盒⾥（⽤户空间），
    
    经历完这两个过程，你才可以离开。
    
    ⾮阻塞 I/O 好⽐，
    你去了饭堂，问阿姨菜做好了没有，阿姨告诉你没，
    
    你就离开了，过⼏⼗分钟，你⼜来，
    
    饭堂问阿姨，阿姨说做好了，于是阿姨帮你把菜打到你的饭盒⾥，这个过程你是得等待的。
    
    基于⾮阻塞的 I/O 多路复⽤好⽐，
    你去饭堂吃饭，发现有⼀排窗⼝，饭堂阿姨告诉你这些窗⼝都还没做好菜，
    
    等做好了再通知你，于是等啊等（ select 调⽤中），过了⼀会阿姨通知你菜做好了，
    
    但是不知道哪个窗⼝的菜做好了，你⾃⼰看吧。
    
    于是你只能⼀个⼀个窗⼝去确认，后⾯发现 5 号窗⼝菜做好了，
    
    于是你让 5 号窗⼝的阿姨帮你打菜到饭盒⾥，这个打菜的过程你是要等待的，虽然时间不⻓。
    
    打完菜后，你⾃然就可以离开了。
    
    异步 I/O 好⽐，
    你让饭堂阿姨将菜做好并把菜打到饭盒⾥后，把饭盒送到你⾯前，整个过程你都不需要任何等待。

## 阻塞式网络通信 ##

package NIOAndBIO;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.nio.file.Paths;
    import java.nio.file.StandardOpenOption;
    
    public class BIO {
        public static void main(String[] args) throws IOException {
            Thread thread1 = new Thread(() -> {
                try {
                    server();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
    
            Thread thread2 = new Thread(() -> {
                try {
                    client();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
    
            thread1.start();
            thread2.start();
        }
    
        public static void client() throws IOException {
            // 创建客户端通道
            SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 2022));
    
            // 读取信息 D:\\bizhi\\bizhi202008\\wallhaven-kwp2qq.jpg
            FileChannel fileChannel = FileChannel.open(Paths.get("D:\\\\bizhi\\\\bizhi202008\\\\wallhaven-kwp2qq.jpg"), StandardOpenOption.READ);
    
            // 创建缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    
            // 写入数据
            while (fileChannel.read(byteBuffer) != -1) {
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
                byteBuffer.clear();
            }
    
            fileChannel.close();
            socketChannel.close();
        }
    
        public static void server() throws IOException {
            // 创建服务端通道
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    
            FileChannel fileChannel = FileChannel.open(Paths.get("D:\\\\bizhi\\\\bizhi202008\\\\wallhaven-kwp2qq.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
    
            // 绑定链接
            serverSocketChannel.bind(new InetSocketAddress(2022));
    
            // 获取客户端的通道
            SocketChannel socketChannel = serverSocketChannel.accept();
    
            // 创建缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    
            while (socketChannel.read(byteBuffer) != -1) {
                byteBuffer.flip();
                fileChannel.write(byteBuffer);
                byteBuffer.clear();
            }
    
            socketChannel.close();
            fileChannel.close();
            serverSocketChannel.close();
        }
    }

## 非阻塞式网络通信 ##

package NIOAndBIO;
    
    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.Scanner;
    
    public class NIO {
        public static void main(String[] args) {
            Thread thread1 = new Thread(()->{
                try {
                    server();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
    
            Thread thread2 = new Thread(()->{
                try {
                    client();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            thread1.start();
            thread2.start();
        }
    
        public static void client() throws IOException {
            SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 2020));
    
            // 设置为非阻塞模式
            socketChannel.configureBlocking(false);
    
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()) {
                String str = scanner.next();
                byteBuffer.put(str.getBytes());
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
                byteBuffer.clear();
            }
    
            byteBuffer.clear();
    
            socketChannel.close();
        }
    
        public static void server() throws IOException {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.bind(new InetSocketAddress(2020));
    
            // 获得选择器
            Selector selector = Selector.open();
    
            // 将通道注册到选择器中，设定为接收操作
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    
            // 轮询接受
            while (selector.select() > 0) {
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                // 获得事件的key
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isAcceptable()) {
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector, SelectionKey.OP_READ);
                    } else if (key.isReadable()) {
                        // 从选择器中获取通道
                        SocketChannel socketChannel = (SocketChannel) key.channel();
    
                        ByteBuffer byteBuffer = ByteBuffer.allocate(10);
    
                        while (socketChannel.read(byteBuffer) != -1) {
                            int len = byteBuffer.limit();
                            byteBuffer.flip();
                            System.out.println(new String(byteBuffer.array(), 0, len));
                            byteBuffer.clear();
                        }
                        socketChannel.close();
                    }
                    iterator.remove();
                }
            }
            serverSocketChannel.close();
        }
    }

### 选择器 ###

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

[![image][image 11]][image_image 11]

**选择器的创建**

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

**绑定选择器**

通过调用通道的register方法可以绑定选择器，register方法有两个参数

*  Selector：即绑定哪个选择器
 *  ops：监听事件类型。ops有4个值可以选择，为**SelectionKey**的静态属性

// 让选择器监听一种状态
    myChannel.register(selector, SelectionKey.OP_READ);
    // 让选择器监听多种状态
    myChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_ACCEPT);

**SelectionKey**

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

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASmF2YeaetuaehOayoeaciTk5Ng_size_14_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/71e97e7a7ee14afc8db4d51cb6a2ceb3.png
[-_IO]: https://www.cnblogs.com/zwtblog/p/15265331.html#%E2%BD%82%E4%BB%B6-io
[image]: /images/20220828/7d01e3dc536048569d3d97c0f51d17f1.png
[image 1]: https://img2020.cnblogs.com/blog/2465789/202109/2465789-20210925103841864-1020577938.png
[image 2]: https://img-blog.csdnimg.cn/img_convert/f38c38ed02e462e2b0b810b2958e29d5.png
[image_image 2]: /images/20220828/6b800545dac64e0b849e0348833e14b4.png
[image 3]: https://img-blog.csdnimg.cn/img_convert/468faa55c29d30c64584aa6513d6075f.png
[image_image 3]: /images/20220828/1186e7a69e14440c87acf26356f22e5c.png
[image 4]: https://img-blog.csdnimg.cn/img_convert/ccf4fbf347603431f610b6abb8d45185.png
[image_image 4]: /images/20220828/66487e28f6084935952f4b2509ac932f.png
[image 5]: https://img-blog.csdnimg.cn/img_convert/c132207f52a9ad050d1273cd73f883a4.png
[image_image 5]: /images/20220828/0dfe0947435f4af2995e11c8e7292530.png
[image 6]: https://img-blog.csdnimg.cn/img_convert/81c29e20b30750e65b83bad8ca966d23.png
[image_image 6]: /images/20220828/c750fba2daf749eca97b81a901ce647a.png
[image 7]: https://img-blog.csdnimg.cn/img_convert/072eb761b2083463cc6333d04d508fdc.png
[image_image 7]: /images/20220828/31c429fd697a4078881a76687c868802.png
[image 8]: https://img-blog.csdnimg.cn/img_convert/b152ed0a15f78c5fe4a5dd0ce729d29d.png
[image_image 8]: /images/20220828/76eb2653c5ae435393b6eb327e76c2c1.png
[image 9]: https://img-blog.csdnimg.cn/img_convert/3ce9a43d5a0282d4970699716b23d50c.png
[image_image 9]: /images/20220828/fbdafa89153d4260be05ad6c7994c762.png
[image 10]: https://img-blog.csdnimg.cn/img_convert/6628e8de37ecc58eada4e0cb96a0b4f4.png
[image_image 10]: /images/20220828/a6f9d8b2ddba4c8dbb57f013c504c877.png
[image 11]: https://img-blog.csdnimg.cn/img_convert/d9a44f81fb58ce8de84d9ffa3adb04dc.png
[image_image 11]: /images/20220828/ab729855e204413688e86c22d160e6f2.png