简介

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

NIO 与 IO 的主要区别

IO NIO
面向流（Stream Oriented） 面向缓冲区（Buffer Oriented）
阻塞 IO（Blocking IO） 非阻塞 IO（Non Blocking IO）
（无） 选择器（Selectors）

通道和缓冲区

Java NIO 系统的核心在于：通道（Channel）和缓冲区（Buffer）。通道表示打开到 IO 设备（例如：文件、套接字）的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。

缓冲区

在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
根据数据类型不同（boolean 除外），提供了相应类型的缓冲区：

  • ByteBuffer
  • CharBuffer
  • ShortBuffer
  • IntBuffer
  • LongBuffer
  • FloatBuffer
  • DoubleBuffer

上述缓冲区的管理方式几乎一致，通过allocate()获取缓冲区。
ByteBuffer buffer = ByteBuffer.allocate(1024);

核心方法

  1. // -- Singleton get/put methods --
  3. /**
  4.   * Relative <i>get</i> method.  Reads the byte at this buffer's
  5.   * current position, and then increments the position.
  6.   *
  7.   * @return  The byte at the buffer's current position
  8.   *
  9.   * @throws  BufferUnderflowException
  10.   *          If the buffer's current position is not smaller than its limit
  11.   */
  12. public abstract byte get();
  14. /**
  15.   * Relative <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
  16.   *
  17.   * <p> Writes the given byte into this buffer at the current
  18.   * position, and then increments the position. </p>
  19.   *
  20.   * @param  b
  21.   *         The byte to be written
  22.   *
  23.   * @return  This buffer
  24.   *
  25.   * @throws  BufferOverflowException
  26.   *          If this buffer's current position is not smaller than its limit
  27.   *
  28.   * @throws  ReadOnlyBufferException
  29.   *          If this buffer is read-only
  30.   */
  31. public abstract ByteBuffer put(byte b);

核心属性

  • capacity：容量，表示缓冲区中最大存储数据的容量，一旦声明不能改变。
  • limit：界限，表示缓冲区可以操作的数据的大小。（limit 后的数据不能进行读写）
  • position：位置，表示缓冲区中正在操作数据的位置。
  • mark：标记，表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置。
  • mark <= position <= limit <= capacity

未命名文件.png

  1. public class Test_01 {
  3.     public static void main(String[] args) {
  4.         String str = "abode";
  5.         //分配一个指定大小的缓冲区
  6.         ByteBuffer buffer = ByteBuffer.allocate(1024);
  7.         System.out.println("========= allocate =========");
  8.         System.out.println(buffer.position()); //0
  9.         System.out.println(buffer.capacity()); //1024
  10.         System.out.println(buffer.limit()); //1024
  12.         System.out.println("========= put =========");
  13.         buffer.put(str.getBytes());
  14.         System.out.println(buffer.position()); //5
  15.         System.out.println(buffer.capacity()); //1024
  16.         System.out.println(buffer.limit()); //1024
  18.         System.out.println("========= flip =========");
  19.         buffer.flip();
  20.         System.out.println(buffer.position()); // 0
  21.         System.out.println(buffer.capacity()); //1024
  22.         System.out.println(buffer.limit()); //5
  24.         System.out.println("========= get =========");
  25.         byte[] bytes = new byte[buffer.limit()];
  26.         buffer.get(bytes);
  27.         System.out.println(new String(bytes, 0, bytes.length)); //abode
  28.         System.out.println(buffer.position()); // 5
  29.         System.out.println(buffer.capacity()); //1024
  30.         System.out.println(buffer.limit()); //5
  32.         System.out.println("========= rewind =========");
  33.         buffer.rewind(); //可重复读
  34.         System.out.println(buffer.position()); // 0
  35.         System.out.println(buffer.capacity()); //1024
  36.         System.out.println(buffer.limit()); //5
  38.         System.out.println("========= clear =========");
  39.         buffer.clear(); //清空缓冲区，但是缓冲区的数据依然存在，但是处于“被遗忘”状态
  40.         System.out.println(buffer.position()); // 0
  41.         System.out.println(buffer.capacity()); //1024
  42.         System.out.println(buffer.limit()); //1024
  43.         System.out.println((char) buffer.get()); //a
  45.         System.out.println("========= other =========");
  46.         buffer.mark(); //标记
  47.         buffer.reset(); //恢复到mark位置
  48.         if (buffer.hashRemaining()) { //判断缓冲区中是否还有剩余数据
  49.             System.out.println(buffer.remaining()); //获取缓冲区中可以操作的数据数
  50.         }
  51.     }
  52. }

直接缓冲区与非直接缓冲区

  • 非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中

NIO - 图2

  • 直接缓冲区：通过 allocateDirect() 方法分配缓冲区，将缓冲区建立在物理内存中，可以提高效率

NIO - 图3

  • 字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
  • 直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
  • 直接字节缓冲区还可以通过 FileChannel 的 map() 方法将文件区域直接映射到内存中来创建。该方法返回 MappedByteBuffer。Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。

  • 字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在性能关键型代码中执行显示缓冲区管理。

    通道

    通道（Channel）：由 java.nio.channels 包定义的。Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据，Channel 只能与 Buffer 进行交互。
    NIO - 图4
    用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。

    主要实现类

  • FileChannel

  • SelectableChannel（I）
    • SocketChannel
    • ServerSocketChannel
    • DatagramChannel
  • Pipe.SinkChannel

  • Pipe.SourceChannel

    获取通道

  • Java 针对支持通道的类提供了 getChannel() 方法

    • 本地 IO
      • FileInputStream / FileOutputStream
      • RandomAccessFile

    • 网络 IO

      • Socket
      • ServerSocket
      • DatagramSocket ```java /**
        • 非直接缓冲区（利用通道） */ public class Test_02 {

      public static void main(String[] args) { FileInputStream fis = null; FileOutputStream fos = null; FileChannel inChannel = null; FileChannel outChannel = null; try {

      1.    fis = new FileInputStream("D:\\idea background\\5dc516c2b8418.jpg");
      2.    fos = new FileOutputStream("D:\\idea background\\1.jpg");
      4.    //获取通道
      5.    inChannel = fis.getChannel();
      6.    outChannel = fos.getChannel();
      8.    //分配指定大小的缓冲区
      9.    ByteBuffer buf = ByteBuffer.allocate(1024);
      11.    //将通道中的数据存入缓冲区
      12.    while (inChannel.read(buf) != -1) {
      13.        buf.flip();
      14.        //将缓冲区中的数据写入通道
      15.        outChannel.write(buf);
      16.        buf.clear();
      17.    }

      } catch (IOException e) {

      1.    e.printStackTrace();

      } finally {

      1.    if (inChannel != null && outChannel != null && fos != null && fis != null) {
      2.        try {
      3.            outChannel.close();
      4.            inChannel.close();
      5.            fos.close();
      6.            fis.close();
      7.        } catch (IOException e) {
      8.            e.printStackTrace();
      9.        }
      10.    }

      } } } ```

  • 在 JDK1.7 中的 NIO.2 针对各个通道提供了静态方法 open()

    1. /**
    2. * 使用直接缓冲区完成文件的复制（内存映射文件）
    3. */
    4. class Test_03 {
    6.   public static void main(String[] args) throws IOException {
    7.       FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
    8.       FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), 
    9.                                                 StandardOpenOption.WRITE, 
    10.                                                 StandardOpenOption.READ, 
    11.                                                 StandardOpenOption.CREATE);
    13.       //内存映射文件
    14.       MappedByteBuffer inMappedBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, 
    15.                                                    inChannel.size());
    16.       MappedByteBuffer outMappedBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0,
    17.                                                      inChannel.size());
    19.       //直接对缓冲区进行数据的读写操作
    20.       byte[] bytes = new byte[inMappedBuf.limit()];
    21.       inMappedBuf.get(bytes);
    22.       outMappedBuf.put(bytes);
    24.       inChannel.close();
    25.       outChannel.close();
    26.   }
    27. }

  • 在 JDK1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()

    通道间数据传输

    ```java /**

    • 通道之间的数据传输（直接缓冲区） */ public class Test_04 {

      public static void main(String[] args) throws IOException {

      1. FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
      2. FileChannel outChannel = FileChannel.open(Paths.get("3.jpg"), StandardOpenOption.WRITE,
      3.                                           StandardOpenOption.READ, 
      4.                                           StandardOpenOption.CREATE);

// inChannel.transferTo(0, inChannel.size(), outChannel); outChannel.transferFrom(inChannel, 0, inChannel.size());

  1.     inChannel.close();
  2.     outChannel.close();
  3. }

}

  1. <a name="t5IKi"></a>
  2. ### 分散（_Scatter_）与聚集（_Gather_）
  4. - 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中
  6. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/1605075/1611048938445-bce52b17-f250-4126-811d-9ba679ce3c40.png#align=left&display=inline&height=268&margin=%5Bobject%20Object%5D&name=image.png&originHeight=268&originWidth=312&size=25137&status=done&style=none&width=312)
  8.    - 注意：按照缓冲区的顺序，从 Channel 中读取的数据依次将 Buffer 填满
  9. - 聚集写入（Gathering Writes）：将多个缓冲区中的数据集聚集到一个通道中
  11. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/1605075/1611049084993-f65f4a99-0368-4ec5-a9c7-6cd9b5ed157d.png#align=left&display=inline&height=254&margin=%5Bobject%20Object%5D&name=image.png&originHeight=254&originWidth=316&size=25513&status=done&style=none&width=316)
  13.    - 注意：按照缓冲区的顺序，写入 position 和 limit 之间额数据到 Channel
  14. ```java
  15. /**
  16.  * 分散和聚集
  17.  */
  18. public class Test_05 {
  20.     public static void main(String[] args) throws IOException {
  21.         RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
  22.         //获取通道
  23.         FileChannel channel1 = raf1.getChannel();
  24.         //分配指定大小的缓冲区
  25.         ByteBuffer buf1 = ByteBuffer.allocate(100);
  26.         ByteBuffer buf2 = ByteBuffer.allocate(1024);
  27.         //分散读取
  28.         ByteBuffer[] buf = {buf1, buf2};
  29.         channel1.read(buf);
  31.         for (ByteBuffer byteBuffer : buf) {
  32.             byteBuffer.flip();
  33.         }
  35.         System.out.println(new String(buf[0].array(), 0, buf[0].limit()));
  36.         System.out.println("=========================");
  37.         System.out.println(new String(buf[1].array(), 0, buf[1].limit()));
  39.         //聚集写入
  40.         RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
  41.         FileChannel channel2 = raf2.getChannel();
  43.         channel2.write(buf);
  44.     }
  45. }

字符集（Charset）

  • 编码：字符串 -> 字符数组

  • 解码：字节数组 -> 字符串

    1. public class Test_06 {
    3.   public static void main(String[] args) throws CharacterCodingException {
    4.       /*Map<String, Charset> map = Charset.availableCharsets();
    5.       Set<Map.Entry<String, Charset>> entries = map.entrySet();
    6.       for (Map.Entry<String, Charset> entry : entries) {
    7.           System.out.println(entry.getKey() + " " + entry.getValue());
    8.       }*/
    10.       Charset gbk = Charset.forName("GBK");
    11.       //获取编码器
    12.       CharsetEncoder encoder = gbk.newEncoder();
    13.       //获取解码器
    14.       CharsetDecoder decoder = gbk.newDecoder();
    16.       CharBuffer charBuffer = CharBuffer.allocate(1024);
    17.       charBuffer.put("这都可以？");
    18.       charBuffer.flip();
    20.       //编码
    21.       ByteBuffer encode = encoder.encode(charBuffer);
    22.       for (int i = 0; i < 10; i++) {
    23.           System.out.println(encode.get());
    24.       }
    26.       //解码
    27.       encode.flip();
    28.       CharBuffer decode = decoder.decode(encode);
    29.       System.out.println(decode.toString());
    30.   }
    31. }

    NIO 的非阻塞式网络通信

    选择器

    是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况。

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

  • 可以监听的事件类型（可使用 SelectionKey 的四个常量表示）
    • 读：SelectionKey.OP_READ (1)
    • 写：SelectionKey.OP_WRITE (2)
    • 连接：SelectionKey.OP_CONNECT (8)
    • 接收：SelectionKey.OP_ACCEPT (16)
  • 若注册时不止监听一个事件，则可以使用“位或”操作符连接。

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

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

阻塞式

客户端

  1. /**
  2.  * 测试阻塞的 NIO
  3.  */
  4. public class Test_01_Client {
  6.     public static void main(String[] args) throws IOException {
  7.         //获取通道
  8.         SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
  10.         FileChannel inChannel = FileChannel.open(Paths.get("1.txt"), StandardOpenOption.READ);
  12.         //分配指定大小的缓冲区
  13.         ByteBuffer buffer = ByteBuffer.allocate(1024);
  14.         //读取本地文件，并发送到服务端
  15.         while (inChannel.read(buffer) != -1) {
  16.             buffer.flip();
  17.             socketChannel.write(buffer);
  18.             buffer.clear();
  19.         }
  21.         //关闭客户端的输出，如果不关闭的话，会一直等待
  22.         socketChannel.shutdownOutput();
  24.         //接收服务端的反馈
  25.         int len = 0;
  26.         while ((len = socketChannel.read(buffer)) != -1) {
  27.             buffer.flip();
  28.             System.out.println(new String(buffer.array(), 0, len));
  29.             buffer.clear();
  30.         }
  31.         //关闭通道
  32.         inChannel.close();
  33.         socketChannel.close();
  34.     }
  35. }

服务端

  1. /**
  2.  * 测试阻塞的 NIO
  3.  */
  4. public class Test_01_Server {
  6.     public static void main(String[] args) throws IOException {
  7.         //获取通道
  8.         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
  10.         FileChannel outChannel = FileChannel.open(Paths.get("3.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
  11.         //绑定连接
  12.         serverSocketChannel.bind(new InetSocketAddress(9898));
  13.         //获取客户端连接的通道
  14.         SocketChannel accept = serverSocketChannel.accept();
  15.         //分配指定大小的缓冲区
  16.         ByteBuffer buffer = ByteBuffer.allocate(1024);
  17.         //接收客户端的数据，并保存到本地
  18.         while (accept.read(buffer) != -1) {
  19.             buffer.flip();
  20.             outChannel.write(buffer);
  21.             buffer.clear();
  22.         }
  24.         //发送反馈给客户端
  25.         buffer.put("服务端接收数据成功".getBytes());
  26.         buffer.flip();
  27.         accept.write(buffer);
  29.         //关闭通道
  30.         accept.close();
  31.         outChannel.close();
  32.         serverSocketChannel.close();
  33.     }
  34. }

非阻塞式

客户端

  1. /**
  2.  * 非阻塞式 NIO
  3.  */
  4. public class Test_02_Client {
  6.     public static void main(String[] args) throws IOException {
  7.         SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8989));
  8.         //切换非阻塞模式
  9.         sChannel.configureBlocking(false);
  11.         ByteBuffer buffer = ByteBuffer.allocate(1024);
  12.         //发送数据给服务端
  13.         Scanner scanner = new Scanner(System.in);
  14.         while (scanner.hasNext()) {
  15.             String str = scanner.next();
  16.             buffer.put((LocalDateTime.now().toString() + "\n" + str).getBytes());
  17.             buffer.flip();
  18.             sChannel.write(buffer);
  19.             buffer.clear();
  20.         }
  22.         //关闭通道
  23.         sChannel.close();
  24.     }
  25. }

服务端

  1. /**
  2.  * 非阻塞式 NIO
  3.  */
  4. public class Test_02_Server {
  6.     public static void main(String[] args) throws IOException {
  7.         ServerSocketChannel ssChannel = ServerSocketChannel.open();
  8.         //切换非阻塞模式
  9.         ssChannel.configureBlocking(false);
  11.         ssChannel.bind(new InetSocketAddress(8989));
  12.         //获取选择器
  13.         Selector selector = Selector.open();
  15.         //将通道注册到选择器上，并且指定监听接收事件
  16.         ssChannel.register(selector, SelectionKey.OP_ACCEPT);
  18.         //轮询式的获取选择器上已经准备就绪的事件
  19.         while (selector.select() > 0) {
  20.             //获取当前选择器中所有注册的选择键（已就绪的监听事件）
  21.             Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  22.             while (iterator.hasNext()) {
  23.                 //获取准备就绪的事件
  24.                 SelectionKey next = iterator.next();
  25.                 //判断具体是什么事件准备就绪
  26.                 if (next.isAcceptable()) {
  27.                     //若接受就绪，获取客户端连接
  28.                     SocketChannel socketChannel = ssChannel.accept();
  29.                     //切换非阻塞模式
  30.                     socketChannel.configureBlocking(false);
  31.                     //将通道注册到选择器上
  32.                     socketChannel.register(selector, SelectionKey.OP_READ);
  33.                 } else if (next.isReadable()) {
  34.                     //获取当前选择器上读就绪状态的通道
  35.                     SocketChannel channel = (SocketChannel) next.channel();
  36.                     //读取数据
  37.                     ByteBuffer buffer = ByteBuffer.allocate(1024);
  39.                     int len = 0;
  40.                     while ((len = channel.read(buffer)) > 0) {
  41.                         buffer.flip();
  42.                         System.out.println(new String(buffer.array(), 0, len));
  43.                         buffer.clear();
  44.                     }
  45.                 } //TODO
  47.                 //取消选择键
  48.                 iterator.remove();
  49.             }
  50.         }
  51.     }
  52. }

DatagramChannel

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

  • 操作步骤

    • 打开 DatagramChannel

    • 接收 / 发送数据

      客户端

      1. /**
      2. * DatagramChannel
      3. */
      4. public class Test_03_Client {
      6. public static void main(String[] args) throws IOException {
      7.    DatagramChannel dChannel = DatagramChannel.open();
      9.    dChannel.configureBlocking(false);
      11.    ByteBuffer buffer = ByteBuffer.allocate(1024);
      12.    Scanner scanner = new Scanner(System.in);
      14.    while (scanner.hasNext()) {
      15.        String str = scanner.next();
      16.        buffer.put((LocalDateTime.now().toString() + "\n" + str).getBytes());
      17.        buffer.flip();
      18.        dChannel.send(buffer, new InetSocketAddress("127.0.0.1", 8989));
      19.        buffer.clear();
      20.    }
      22.    dChannel.close();
      23. }
      24. }

      服务端

      1. /**
      2. * DatagramChannel
      3. */
      4. public class Test_03_Server {
      6. public static void main(String[] args) throws IOException {
      7.    DatagramChannel dChannel = DatagramChannel.open();
      9.    dChannel.configureBlocking(false);
      10.    dChannel.bind(new InetSocketAddress(8989));
      12.    Selector selector = Selector.open();
      13.    dChannel.register(selector, SelectionKey.OP_READ);
      15.    while (selector.select() > 0) {
      16.        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
      17.        while (iterator.hasNext()) {
      18.            SelectionKey next = iterator.next();
      19.            if (next.isReadable()) {
      20.                ByteBuffer buffer = ByteBuffer.allocate(1024);
      21.                dChannel.receive(buffer);
      22.                buffer.flip();
      23.                System.out.println(new String(buffer.array(), 0, buffer.limit()));
      24.                buffer.clear();
      25.            }
      26.        }
      27.        iterator.remove();
      28.    }
      29. }
      30. }

      管道（Pipe）

  • Java NIO 管道是 2 个线程之间的单向数据连接。Pipe 有一个 source 通道和一个 sink 通道。数据会被写到 sink 通道，从 source 通道读取。

    1. /**
    2. * 单向 Pipe
    3. */
    4. public class Test_04 {
    6.   public static void main(String[] args) throws IOException {
    7.       //获取管道
    8.       Pipe pipe = Pipe.open();
    9.       //将缓冲区的数据写入管道
    10.       ByteBuffer buffer = ByteBuffer.allocate(1024);
    11.       Pipe.SinkChannel sinkChannel = pipe.sink();
    13.       buffer.put("通过单向管道发送数据".getBytes());
    14.       buffer.flip();
    15.       sinkChannel.write(buffer);
    17.       //读取缓冲区中的数据
    18.       Pipe.SourceChannel sourceChannel = pipe.source();
    19.       buffer.flip();
    20.       int len = sourceChannel.read(buffer);
    21.       System.out.println(new String(buffer.array(), 0, len));
    23.       sourceChannel.close();
    24.       sinkChannel.close();
    25.   }
    26. }