Java NIO 和 NIO2

1. Java NIO 简介

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

2. Java NIO 与 IO 的主要区别

Java NIO 和 IO的主要区别

3. 缓冲区(Buffer)和通道(Channel)

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

简而言之，Channel 负责传输， Buffer 负责存储

 缓冲区（Buffer）：一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。

Buffer 中的重要概念：
 量容量 (capacity) ：表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能更改。
 制限制 (limit) ：第一个不应该读取或写入的数据的索引，即位于 limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
 置位置 (position)：：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制
 记标记 (mark) 与重置 (reset) ：标记是一个索引，通过 Buffer 中的 mark() 方法指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这个 position.

缓冲区的基本属性

Buffer的常用方法

缓冲区的数据操作
 Buffer 所有子类提供了两个用于数据操作的方法：get()与 put() 方法
 取获取 Buffer 中的数据
get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)
 放到入数据到 Buffer 中中
put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动position)

直接与非直接缓冲区
 字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在本机此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。

 的直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。

 直接字节缓冲区还可以过通过FileChannel 的 map() 方法将文件区域直接映射到内存中来创建。该方法返回MappedByteBuffer 。Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。

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

非直接缓冲区

直接缓冲区

package cn.icanci.NIO;

import java.nio.ByteBuffer;

public class NIOTestBuffer {
    public static void main(String[] args) {
        /**
         * 缓冲区  在Java NIO 中负责数据读取 缓冲区就是数组 用于存储不同的是数据
         *
         * 根据数据类型的不同 (Boolean除外 ) 提供了相应类型的缓冲区
         * ByteBuffer
         * CharBuffer
         * ShortBuffer
         * IntBuffer
         * LongBuffer
         * FloatBuffer
         * DoubleBuffer
         *
         * 上述缓冲区的管理方法几乎一致 通过 allocate() 获取缓冲区
         *
         * 2.缓冲区存取数据的两个核心方法
         * put():存入
         * get():读取
         *
         *
         * 4.缓冲区的4个核心属性
         *     private int mark = -1;    标记当前 position 的位置 可以通过
         *     private int position = 0; 位置:表示缓冲区中正在操作数据的位置
         *     private int limit;      界限,表示缓冲区中可以操作数据的大小.(limit 后数据不能进行读写)
         *     private int capacity;   容量 ,表示缓冲区中最大存储的数据的容量 一旦声明 不能改变 ,因为底层是数组
         *
         *  0 <= mark <= limit <= capacity
         *  5.非直接缓冲区  通过 allocate() 方法 分配缓冲区,将缓冲区建立在JVM的内存中
         *    直接缓冲区:  通过 allocateDirect() 方法分配缓冲区 将缓冲区建立在 物理内存中
         *
         */

        test3();

    }

    public static void test3() {
        //分配直接缓冲区
        ByteBuffer bb = ByteBuffer.allocateDirect(1024);
        System.out.println(bb.isDirect());
    }

    public static void test2() {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("gasgasdgs".getBytes());
        buffer.flip();
        byte[] dst = new byte[buffer.limit()];
        buffer.get(dst,0,2);
        System.out.println(new String(dst, 0, dst.length));
        System.out.println(buffer.position());
        //标记
        buffer.mark();
        System.out.println(buffer.get(dst, 2, 2));
        System.out.println(buffer.position());
        buffer.reset();
        System.out.println(buffer.position());
        //缓冲区是否还有数据
        if (buffer.hasRemaining()){
            //获取缓冲区可以操作的数据
            System.out.println(buffer.remaining());
        }
    }

    public static void test1() {
        //1.分配一个缓冲区
        ByteBuffer buf = ByteBuffer.allocate(20);
        System.out.println("-------分配一个缓冲区--------");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());
        System.out.println(buf.mark());
        System.out.println("-------存储--------");

        //2.存储
        buf.put("123142214".getBytes());
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());
        System.out.println(buf.mark());

        //切换成读取数据的模式
        buf.flip();
        System.out.println("------flip---------");

        //4.利用 get() 读取数据
        byte[] dst = new byte[buf.limit()];
        buf.get(dst);
        System.out.println(new String(dst, 0, dst.length));
        System.out.println("--------get-------");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());
        System.out.println(buf.mark());
        //5.rewind
        System.out.println("-------rewind--------");
        buf.rewind();
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());
        System.out.println(buf.mark());

        //6.clear   清空缓冲区 但是数据依旧存在 只是处于被"遗忘"的状态
        buf.clear();
        System.out.println("-------clear--------");
        buf.rewind();
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());
        System.out.println(buf.mark());
        System.out.println((char) buf.get());
    }
}

 Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。

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

通道

Java 为为 Channel 接口提供的最主要实现类如下：
• FileChannel：用于读取、写入、映射和操作文件的通道。
• DatagramChannel：通过 UDP 读写网络中的数据通道。
• SocketChannel：通过 TCP 读写网络中的数据。
• ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。

获取通道
 获取通道的一种方式是对支持通道的对象调用
getChannel() 方法。支持通道的类如下：
 FileInputStream
 FileOutputStream
 RandomAccessFile
 DatagramSocket
 Socket
 ServerSocket
获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道

4. 文件通道(FileChannel)

通道的数据传输

分散和聚集

transform()

transformTo()

FileChannel的常用方法

public class NIOTestChannel {
    /**
     * 1.通道:用于源节点与目标节点的链接 在Java NIO 中负责缓冲区的数据的传输,Channel本身不存储数据,
     * 因此需要配合缓冲区进行传输
     * 2.通道的主要实现类
     * java.nio.channels.Channel 接口
     * --FileChannel
     * --SocketChannel
     * --ServerSocketChannel
     * --DatagramChannel
     * 3.获取通道
     * 1.java针对支持通道类提供了getChannel()方法
     * 本地IO操作
     * FileInputStream/FileOutputStream
     * RandomAccessFile
     * 网络IO
     * Socket
     * ServerSocket
     * DatagramSocket
     * <p>
     * 2.在JDK7中 NIO2 针对各个通道提供了静态方法
     * 3.在JDK7中 NIO2 的Files工具类的 newByteChannel()
     */

    public static void main(String[] args) {
        test6();

    }
    public static void test6() {
        Charset charset = Charset.forName("UTF-8");
        //1.获取编码器
        CharsetEncoder charsetEncoder = charset.newEncoder();

        //2..和解码器
        CharsetDecoder charsetDecoder = charset.newDecoder();

        CharBuffer charBuffer = CharBuffer.allocate(1024);
        charBuffer.put("哈哈哈哈 呆子 wo ai ni");
        charBuffer.flip();

        //编码
        try {
            ByteBuffer buffer = charsetEncoder.encode(charBuffer);
            for (int i = 0;i<20;i++){
                System.out.println(buffer.get(i));
            }

            //解码
            CharBuffer cbuffer = charsetDecoder.decode(buffer);
            System.out.println(cbuffer.toString());
        } catch (CharacterCodingException e) {
            e.printStackTrace();
        } finally {
        }
    }

   public static void test5() {

        /**
         * 字符集
         * 编码:字符串 ->字节数组
         * 解码:字节数组 -> 字符串
         */
        SortedMap<String, Charset> stringCharsetSortedMap = Charset.availableCharsets();
        Set<Map.Entry<String, Charset>> entries = stringCharsetSortedMap.entrySet();
        for (Map.Entry<String, Charset> entry : entries) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }

    }

    public static void test4() {
        /**
         * 分散和聚集
         */
        try {
            RandomAccessFile randomAccessFile = new RandomAccessFile("1.mp4", "rw");
            //1.获取通道
            FileChannel channel1 = randomAccessFile.getChannel();
            //2.指定大小缓冲区
            ByteBuffer buffer1 = ByteBuffer.allocate(100);
            ByteBuffer buffer2 = ByteBuffer.allocate(1024);
            //3,分散读取
            ByteBuffer[] buffers = {buffer1, buffer2};
            channel1.read(buffers);
            System.out.println(new String(buffers[0].array(), 0, buffers[0].limit()));
            System.out.println("-------------------");
            System.out.println(new String(buffers[1].array(), 0, buffers[1].limit()));

            //4.聚集写入
            RandomAccessFile randomAccessFile1 = new RandomAccessFile("2.mp4", "rw");
            FileChannel channel2 = randomAccessFile1.getChannel();
            channel2.write(buffers);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
    }

    public static void test3() {
        /**
         * 通道之间的数据传输
         */
        try {
            FileChannel open = FileChannel.open(Paths.get("1.mp4"), StandardOpenOption.READ);
            FileChannel out = FileChannel.open(Paths.get("0.mp4"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
            open.transferTo(0, open.size(), out);
            out.close();
            open.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }
    }

    public static void test2() {
        //利用 直接缓冲区完成文件的复制(内存映射文件)
        try {
            FileChannel open = FileChannel.open(Paths.get("1.mp4"), StandardOpenOption.READ);
            FileChannel out = FileChannel.open(Paths.get("0.mp4"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
            //内存映射文件
            MappedByteBuffer map = open.map(FileChannel.MapMode.READ_ONLY, 0, open.size());
            MappedByteBuffer map1 = out.map(FileChannel.MapMode.READ_WRITE, 0, open.size());

            //直接对缓冲区进行数据的读写操作
            byte[] bytes = new byte[1024];
            map.get(bytes);
            map1.put(bytes);
            out.close();
            open.close();
            map1.clear();
            map.clear();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }

    }

    public static void test1() {
        //1. FileInputStream/FileOutputStream
        // 利用通道完成文件的复制
        FileInputStream fis = null;
        FileOutputStream fos = null;

        FileChannel fc = null;
        FileChannel oc = null;
        try {
            fis = new FileInputStream(new File("logo.jpg"));
            fos = new FileOutputStream(new File("logo2.jpg"));

            //1.获取通道
            fc = fis.getChannel();
            oc = fos.getChannel();

            //2.指定大小的缓冲区
            ByteBuffer bb = ByteBuffer.allocate(1024);

            //3.将通道的数据读取缓冲区
            while (fc.read(bb) != -1) {
                //切换读取数据的模式
                bb.flip();
                //4.将缓冲区的数据写入通道
                oc.write(bb);
                bb.clear();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            try {
                oc.close();
                fc.close();
                fis.close();
                fos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

5. NIO 的非阻塞式网络通信

阻塞与非阻塞

 传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。

 Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。

package cn.icanci.NIO;

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 NIOTest1 {
    public static void main(String[] args) {
        /**
         * NIO完成网络通信的三个核心
         * 1.通道(channel)负责链接
         *      java.nio.channels.Channel 接口
         *      --FileChannel
         *      --SocketChannel
         *      --ServerSocketChannel
         *      --DatagramChannel
         *
         *      --pipe.SinkChannel
         *      --Pipe.SourceChannel
         *
         * 2.缓冲区(Buffer) 负责数据的存取
         *
         * 3.选择器 (Selector) 是SelectableChannel 的对路复用器 用于监控S  是SelectableChannel 的 IO 状况
         *
         */
        try {
            Server();
            Client();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void Client() throws IOException {
        //1.获取通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        FileChannel inChannel = FileChannel.open(Paths.get("1.mp4"), StandardOpenOption.READ);
        //2.分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //3.读取本地文件,并发送到服务端
        while (inChannel.read(buf) != -1) {
            buf.flip();
            socketChannel.write(buf);
            buf.clear();
        }
        //4.关闭通道
        inChannel.close();
        socketChannel.close();
    }

    public static void Server() throws IOException {
        //1.获取通道
        ServerSocketChannel open = ServerSocketChannel.open();
        FileChannel fileChannel = FileChannel.open(Paths.get("4.mp4"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        //2.绑定链接
        open.bind(new InetSocketAddress(9898));

        //3.获取链接通道
        SocketChannel socketChannel = open.accept();

        //4.获取指定大小的缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        //5.接收数据 并保存到本地
        while (socketChannel.read(buffer) != -1) {
            buffer.flip();
            fileChannel.write(buffer);
            buffer.clear();
        }
        //6.关闭通道
        fileChannel.close();
        socketChannel.close();
        open.close();
    }
}

package cn.icanci.NIO;

import org.junit.Test;

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 NIOTest2 {

    //客户端
    @Test
    public void client() throws IOException{
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));

        FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);

        ByteBuffer buf = ByteBuffer.allocate(1024);

        while(inChannel.read(buf) != -1){
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }

        sChannel.shutdownOutput();

        //接收服务端的反馈
        int len = 0;
        while((len = sChannel.read(buf)) != -1){
            buf.flip();
            System.out.println(new String(buf.array(), 0, len));
            buf.clear();
        }

        inChannel.close();
        sChannel.close();
    }

    //服务端
    @Test
    public void server() throws IOException{
        ServerSocketChannel ssChannel = ServerSocketChannel.open();

        FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        ssChannel.bind(new InetSocketAddress(9898));

        SocketChannel sChannel = ssChannel.accept();

        ByteBuffer buf = ByteBuffer.allocate(1024);

        while(sChannel.read(buf) != -1){
            buf.flip();
            outChannel.write(buf);
            buf.clear();
        }

        //发送反馈给客户端
        buf.put("服务端接收数据成功".getBytes());
        buf.flip();
        sChannel.write(buf);

        sChannel.close();
        outChannel.close();
        ssChannel.close();
    }

}

选择器(Selector)

选择器

选择器(Selector)的应用
SocketChannel、ServerSocketChannel、DatagramChannel

选择器的应用

SelectionKey

SelectionKey

Select的常用方法

SocketChannel

 Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。
操作步骤：
打开 SocketChannel
读写数据
关闭 SocketChannel

SocketChannel

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

DatagramChannel
Java NIO中的DatagramChannel是一个能收发UDP包的通道。
 操作步骤：
打开 DatagramChannel
接收/发送数据

package cn.icanci.NIO;


import org.junit.Test;

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;

/*
 * 一、使用 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();
            }
        }
    }
}

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();
        }
    }

}

6. 管道(Pipe)

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

管道


import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

import org.junit.Test;

public class TestPipe {

    @Test
    public void test1() throws IOException{
        //1. 获取管道
        Pipe pipe = Pipe.open();
        
        //2. 将缓冲区中的数据写入管道
        ByteBuffer buf = ByteBuffer.allocate(1024);
        
        Pipe.SinkChannel sinkChannel = pipe.sink();
        buf.put("通过单向管道发送数据".getBytes());
        buf.flip();
        sinkChannel.write(buf);
        
        //3. 读取缓冲区中的数据
        Pipe.SourceChannel sourceChannel = pipe.source();
        buf.flip();
        int len = sourceChannel.read(buf);
        System.out.println(new String(buf.array(), 0, len));
        
        sourceChannel.close();
        sinkChannel.close();
    }
    
}

7. Java NIO2 (Path、Paths 与 Files )

随着 JDK 7 的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为 NIO.2。因为 NIO 提供的一些功能，NIO已经成为文件处理中越来越重要的部分

Paths和Pathj

Files类

Java 7 增加了一个新特性，该特性提供了另外一种管理资源的方式，这种方式能自动关闭文件。这个特性有时被称为自动资源管理(Automatic Resource Management, ARM)，该特性以 try 语句的扩展版为基础。自动资源管理主要用于，当不再需要文件（或其他资源）时，可以防止无意中忘记释放它们。

自动资源管理