传统的IO操作是同步阻塞IO模式(BIO)，数据的读取写入必须阻塞在一个线程内等待其完成。NIO则是同步非阻塞IO模式。BIO面向流操作，NIO面向缓冲区操作。

      NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。

一 Channel(通道)

       Chanel通道相当于IO操作的载体，数据通过Channel读取和写入，全双工模式(双向)。Channel类似流，但是又和流不同，流的读写是单向的比如InputStream、OutputStream。但是Chanel既可以从通道里面读取数据又可以把数据写到通道里面去。通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。

1.1 FileChannel

       FileChannel是一个基于文件的通道。可以通过文件通道读写文件。有一点要注意FileChannel无法设置为非阻塞模式。它总是以阻止模式运行。

FileChannel提供的函数

       下面我们通过一个简单的实例来看FileChannel怎么使用。

    @Test
    public void fileChannelRead() {

        try {
            // 开启FileChannel
            RandomAccessFile aFile = new RandomAccessFile("D:\job\git\java-study\nio\src\main\resources\fileChanel.txt", "rw");
            FileChannel inChannel = aFile.getChannel();
            ByteBuffer buf = ByteBuffer.allocate(48);
            // 从FileChannel通道读取数据到缓冲区ByteBuffer
            int bytesRead = inChannel.read(buf);
            while (bytesRead != -1) {
                System.out.println("读取到的数据长度 " + bytesRead);
                buf.flip();
                while (buf.hasRemaining()) {
                    System.out.print((char) buf.get());
                }
                buf.clear();
                // 继续读取文件信息
                bytesRead = inChannel.read(buf);
            }
            aFile.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    @Test
    public void fileChannelWrite() {

        try {
            // 开启FileChannel
            RandomAccessFile aFile = new RandomAccessFile("D:\job\git\java-study\nio\src\main\resources\fileChanelWrite.txt", "rw");
            FileChannel inChannel = aFile.getChannel();
            ByteBuffer buf = ByteBuffer.allocate(48);
            byte[] forWrite = "需要写入的字符串。".getBytes(StandardCharsets.UTF_8);
            buf.put(forWrite, 0, forWrite.length);
            buf.flip();
            // 写入数据
            while (buf.hasRemaining()) {
                inChannel.write(buf);
            }
            aFile.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

1.2 DatagramChannel

       DatagramChannel主要是用来基于UDP通信的通道。

DatagramChannel方法介绍

注意，connect()、send()、read() 三个函数是配套使用的。

       接下来我们通过三个例子来说明DatagramChannel的用法，下面的例子都是阻塞模式的，等讲到Selector的时候我们在讲非阻塞的用法。

1.2.1 UDP服务端

       UDP服务端需要调用bind()函数绑定本地端口。

    /**
     * UDP 服务端
     */
    @Test
    public void datagramChannelService() {
        try {
            // 获取通道
            DatagramChannel datagramChannel = DatagramChannel.open();
            // 绑定端口8989,作为UDP服务端
            datagramChannel.bind(new InetSocketAddress(8989));
            // 分配Buffer,用于收发数据
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (true) {
                buffer.clear();
                // 等待接受客户端发送数据
                SocketAddress socketAddress = datagramChannel.receive(buffer);
                if (socketAddress != null) {
                    buffer.flip();
                    byte[] b = new byte[buffer.limit()];
                    int bufferReceiveIndex = 0;
                    while (buffer.hasRemaining()) {
                        b[bufferReceiveIndex++] = buffer.get();
                    }
                    System.out.println("收到客户端消息 " + socketAddress.toString() + ":" + new String(b, StandardCharsets.UTF_8));
                    // 接收到消息后给发送方回应
                    sendDataBack(socketAddress, datagramChannel);
                }
            }

        } catch (IOException e) {
            // ignore
        }
    }

    /**
     * 给socketAddress地址发送消息
     */
    private void sendDataBack(SocketAddress socketAddress, DatagramChannel datagramChannel) throws IOException {
        String message = "send back";
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put(message.getBytes(StandardCharsets.UTF_8));
        buffer.flip();
        datagramChannel.send(buffer, socketAddress);
    }

1.2.2 UDP客户端

       如果UDP作为客户端的话，可以直接往UDP服务端发送消息，服务端接收到消息的时候同时获取到了对应客户端的地址信息。又可以把消息发送回来。

    // UDP客户端
    @Test
    public void datagramChannelClient() {
        try {
            final DatagramChannel channel = DatagramChannel.open();
            // 开一个线程一直接收UDP服务端发送过来的消息
            new Thread(() -> {
                try {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    while (true) {
                        buffer.clear();
                        SocketAddress socketAddress = channel.receive(buffer);
                        if (socketAddress != null) {
                            buffer.flip();
                            byte[] b = new byte[buffer.limit()];
                            int bufferReceiveIndex = 0;
                            while (buffer.hasRemaining()) {
                                b[bufferReceiveIndex++] = buffer.get();
                            }
                            System.out.println("收到消息 " + socketAddress.toString() + ":" + new String(b, StandardCharsets.UTF_8));
                        }
                    }
                } catch (Exception e) {
                    // ignore
                }

            }).start();

            int messageIndex = 0;
            // 控制台输入数据，然后发送给指定的地址
            while (true) {
                // 5S发送一次数据
                Uninterruptibles.sleepUninterruptibly(5, TimeUnit.SECONDS);
                sendMessage(channel, new InetSocketAddress("192.168.5.14", 8989), String.valueOf(messageIndex++));
            }

        } catch (IOException e) {
            // ignore
        }
    }


    private void sendMessage(DatagramChannel channel, InetSocketAddress address, String mes) throws IOException {
        if (mes == null || mes.isEmpty()) {
            return;
        }
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.clear();
        buffer.put(mes.getBytes(StandardCharsets.UTF_8));
        buffer.flip();
        channel.send(buffer, address);
    }

1.2.3 connect用法

       DatagramChannel的connect()方法可以和指定的地址绑定起来，配合write()、read()函数在两者之间收发消息。比如下面的实例我们和time-a.nist.gov建立连接获取时间。

    /**
     * UDP connect() 在特定的地址上收发消息
     */
    @Test
    public void datagramChannelConnect() {
        try {
            // 获取通道
            DatagramChannel datagramChannel = DatagramChannel.open();
            // 连接到特定的地址，time-a.nist.gov 获取时间。只在这个地址间收发消息 write,read 方法
            datagramChannel.connect(new InetSocketAddress("time-a.nist.gov", 37));
            ByteBuffer buffer = ByteBuffer.allocate(8);
            buffer.order(ByteOrder.BIG_ENDIAN);
            buffer.put((byte) 0);
            buffer.flip();
            // 发送数据到 time-a.nist.gov
            datagramChannel.write(buffer);
            buffer.clear();
            // 前四个字节补0
            buffer.putInt(0);
            // 从 time-a.nist.gov 读取数据
            datagramChannel.read(buffer);
            buffer.flip();
            // convert seconds since 1900 to a java.util.Date
            long secondsSince1900 = buffer.getLong();
            long differenceBetweenEpochs = 2208988800L;
            long secondsSince1970 = secondsSince1900 - differenceBetweenEpochs;
            long msSince1970 = secondsSince1970 * 1000;
            Date time = new Date(msSince1970);
            // 打印时间
            System.out.println(time);
        } catch (Exception e) {
            // ignore
        }
    }

再次强调下，上面实例代码我们都是用的阻塞模式实现的。等下面讲到Selector的时候我们在讲怎么用非阻塞的方式实现。

1.3 SocketChannel

       SocketChannel主要是用来基于TCP通信的通道，它一般用来作为客户端的套接字，它有点类似于java中的Socket类。

SocketChannel方法介绍

       setOption():用于给socket设置一些选项配置，比如keep alive。socketChannel.setOption(StandardSocketOptions.TCP_NODELAY, true);socketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);等等。具体可以看看StandardSocketOptions里面的一些标准选项。

       关于connect()、isConnectionPending()、finishConnect()三个函数的关系我们稍微屡一下。分两种情况来考虑：

• 阻塞模式：connect()是阻塞的，这个时候isConnectionPending()、finishConnect()两个函数我觉得意义不大，因为你本来就是阻塞状态的，connect()函数成功了，这两个函数值也就确定了：isConnectionPending()->false、finishConnect()->true(如果连接失败他就是false)。
• 非阻塞模式：调用connect()方法底层socket建立连接的时候。因为是非阻塞的如果连接立即建立成功，则返回true，否则返回false。则此后一旦成功建立连接就必须通过调用finishConnect()方法来完成链接。在没有调用finishConnect()之前isConnectionPending()->true，调用之后isConnectionPending()->false。

1.3.1 SocketChannel使用

    /**
     * TCP客户端,阻塞模式
     */
    @Test
    public void socketChannelClient() {
        try {
            SocketChannel channel = SocketChannel.open();
            // 这里使用的是阻塞模式
            channel.connect(new InetSocketAddress("192.168.5.14", 6800));
            // KEEP ALIVE setOption()函数的使用,一定要在连接成功之后设置
            channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (true) {
                buffer.clear();
                int readLength = channel.read(buffer);
                if (readLength >= 0) {
                    buffer.flip();
                    byte[] b = new byte[buffer.limit()];
                    int bufferReceiveIndex = 0;
                    while (buffer.hasRemaining()) {
                        b[bufferReceiveIndex++] = buffer.get();
                    }
                    System.out.println("收到消息 " + ":" + new String(b, StandardCharsets.UTF_8));
                    // 把收到的消息又发送回去
                    buffer.clear();
                    buffer.put(b);
                    buffer.flip();
                    channel.write(buffer);
                }

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

1.4 ServerSocketChannel

       ServerSocketChannel也是用来基于TCP通信的通道，它一般用来作为服务端的套接字，它有点类似于java中的ServerSocket类。一般用来接收客户端的连接，在客户端连接的的基础之上做一些收发消息的处理。

ServerSocketChannel主要方法

       ServerSocketChannel是用于接收客户端连接的，在接收到(accept函数)客户端连接之后会拿到基于客户端连接的SocketChannel。和每个客户端的操作都是通过SocketChannel实现的。

1.4.1 ServerSocketChannel的使用

    /**
     * TCP服务端 -- 阻塞模式
     */
    @Test
    public void socketChannelServer() {
        try {
            ServerSocketChannel  channel = ServerSocketChannel.open();
            channel.bind(new InetSocketAddress("192.168.5.14", 6800));
            while (true) {
                // 接收客户端的连接,之后拿到的就是SocketChannel了，之后都是基于SocketChannel做相应的操作
                SocketChannel clientSocketChannel = channel.accept();
                clientSocketChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                buffer.clear();
                buffer.put("hello".getBytes(StandardCharsets.UTF_8));
                buffer.flip();
                // 给客户端发送消息
                clientSocketChannel.write(buffer);
                // 在收下客户端的消息
                buffer.clear();
               int readLength = clientSocketChannel.read(buffer);
                if (readLength >= 0) {
                    buffer.flip();
                    byte[] b = new byte[buffer.limit()];
                    int bufferReceiveIndex = 0;
                    while (buffer.hasRemaining()) {
                        b[bufferReceiveIndex++] = buffer.get();
                    }
                    System.out.println("收到消息 " + ":" + new String(b, StandardCharsets.UTF_8));
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

二 Buffer(缓冲区)

       Buffer用于和Channel通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成了NIO Buffer对象。

       我们先介绍先Buffer里面的三个属性，接着在介绍下Buffer里面主要的方法。

Buffer里面三个属性:capacity、position、limit。

• capacity：作为一个内存块，Buffer有一个固定的大小值，也叫“capacity”.你只能往里写capacity个byte、long，char等类型。一旦Buffer满了，需要将其清空(通过读数据或者清除数据)才能继续往里写数据。
• position：当你写数据到Buffer中时，position表示当前的位置。初始的position值为0。当一个byte、long等数据写到Buffer后，position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity–1；当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。position简单来说就相当于游标的作用。
• limit：在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。写模式下，limit等于Buffer的capacity；当切换Buffer到读模式时，limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据(limit被设置成已写数据的数量，这个值在写模式下就是position)。

一定要注意position、limit在读模式和谢模式下代表的含义，以及两个模式之间切换的时候position、limit做了那些变化。

Buffer里面常用函数。

public abstract class Buffer {
    
    /**
     * 获取当前缓冲区的容量 -- capacity
     */
    public final int capacity();

    /**
     * 获取当前缓冲区的位置 -- position
     */
    public final int position();

    /**
     * 设置当前缓冲区的位置 -- position
     */
    public final Buffer position(int newPosition);

    /**
     * 获取当前缓冲区的限制 -- limit
     */
    public final int limit();

    /**
     * 设置当前缓冲区的限制 -- limit
     */
    public final Buffer limit(int newLimit);

    /**
     * mark(), reset()函数是配对使用的，将当前缓冲区的标记(mark)设置在当前位置(position) -- mark
     */
    public final Buffer mark();

    /**
     * 通过调用mark()方法，可以标记Buffer中的一个特定position。
     * 之后可以通过调用Buffer.reset()方法恢复到这个position
     */
    public final Buffer reset();

    /**
     * 	清除此缓存区。将position = 0;limit = capacity;mark = -1;一般在写入数据之前调用
     */
    public final Buffer clear();

    /**
     * flip()方法可以把Buffer从写模式切换到读模式。调用flip方法会把position归零，
     * 并设置limit为之前的position的值。
     * 也就是说，现在position代表的是读取位置，limit标示的是已写入的数据位置。
     */
    public final Buffer flip();

    /**
     * 将position设回0，这个时候你可以重读Buffer中的所有数据。
     * limit保持不变，仍然表示能从Buffer中读取多少个元素
     */
    public final Buffer rewind();

    /**
     * return limit - position; 返回limit和position之间相对位置差
     */
    public final int remaining();

    /**
     * return position < limit，返回是否还有未读内容
     */
    public final boolean hasRemaining();

    /**
     * 判断此缓冲区是否为只读
     */
    public abstract boolean isReadOnly();

    /**
     * 判断此缓冲区是否由可访问的数组支持
     */
    public abstract boolean hasArray();

    /**
     * 返回支持此缓冲区的数组
     */
    public abstract Object array();

    /**
     * 返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量
     */
    public abstract int arrayOffset();

    /**
     * 判断个缓冲区是否为 direct
     */
    public abstract boolean isDirect();

}

flip()、hasRemaining()、clear()、rewind()、mark()、reset()几个函数要着重理解下。

       要想使用Buffer来读写数据一般遵循以下四个步骤：

• 写数据到Buffer里面。可以从Channel读取出来写入到缓冲区中，也可以调用put方法写入到缓冲区中。
• 调用flip()方法，切换到读数据模式。这个时候position指向第一个位置，limit指向写入数据的最后位置。
• 从Buffer中读取数据。一般从缓冲区读取数据写入到通道中，也可以调用get方法读取到Buffer里面的数据。
• 调用clear()或者compact()方法清空缓冲区。

       当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。

       在读模式下，可以读取之前写入到buffer的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。

       有两种方式能清空缓冲区：

• clear()：方法会清空整个缓冲区。
• compact()：这个方法在ByteBuffer、CharBuffer、ShortBuffer等方法里面提供。 该方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区。

       我们使用Buffer缓冲区。一般使用的都是他的子类：ByteBuffer、CharBuffer、ShortBuffer、LongBuffer、FloatBuffer、DoubleBuffer这些。Buffer的这些子类都是基于JAVA一些基本数据类型实现的一个Buffer缓冲区。我们先看下这些子类一般都会有的一些方法(Buffer里面的方法他们都会有，Buffer里面的方法我们就不重复介绍了)。

出Buffer提供的放方法之外，子类里面额外的方法。

       关于Buffer的使用，我们以ByteBuffer和CharBuffer来举例说明。其他的Buffer子类适应也都是很简单的。

ByteBuffer的使用

    @Test
    public void byteBufferTest() {
        // 创建一个ByteBuffer实例
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 清空
        buffer.clear();
        // 写入数据
        byte[] putByteArray = "hello word!".getBytes(StandardCharsets.UTF_8);
        buffer.put(putByteArray);
        // 切换到读模式
        buffer.flip();
        // 把数据读取出来
        buffer.slice();
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
        System.out.println();
        // 重新读
        buffer.rewind();
        // ps: 这个时候buffer.limit()就是数组元素的个数
        byte[] retByte = new byte[buffer.limit()];
        buffer.get(retByte);
        System.out.println(new String(retByte, StandardCharsets.UTF_8));
    }

CharBuffer使用距离

    @Test
    public void charBufferTest() {
        // 创建一个ByteBuffer实例
        CharBuffer buffer = CharBuffer.allocate(1024);
        // 清空
        buffer.clear();
        // 写入数据
        char[] putArray = "hello word!".toCharArray();
        buffer.put(putArray);
        // 切换到读模式
        buffer.flip();
        // 把数据读取出来
        buffer.slice();
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get());
        }
        System.out.println();
        // 重新读
        buffer.rewind();
        // ps: 这个时候buffer.limit()就是数组元素的个数
        char[] retByte = new char[buffer.limit()];
        buffer.get(retByte);
        System.out.println(String.valueOf(retByte));
    }

三 Selector(多路复用器)

       Selector提供了选择已就绪任务的能力，Selector会不断轮询注册在上面的Channel，某个Channel发生读或写事件，则该Channel就处于就绪状态，会被Selector轮询出来。然后通过SelectionKey获取就绪Channel的集合，进行后续IO操作。Selector允许单线程处理多个Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。

Selector方法介绍

       wakeup() 函数稍微讲下。Selector的选择方式有三种：select()、select(timeout)、selectNow()。selectNow的选择过程是非阻塞的，与wakeup没有太大关系。select(timeout)和select()的选择过程是阻塞的，其他线程如果想终止这个过程，就可以调用wakeup来唤醒select()。

3.1 Selector创建

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

Selector selector = Selector.open();

3.2 把Channel注册到Selector

channel.configureBlocking(false);
SelectionKey key = channel.register(selector, Selectionkey.OP_READ);

       注册到Selector的Channel是有前提添加的。Channel必须是非阻塞的，必须是SelectableChannel的子类。所以FileChannel不适用Selector，因为FileChannel不能切换为非阻塞模式，更准确的来说是因为FileChannel没有继承SelectableChannel。

       把Channel注册到Selector的时候还得指定监听事件。就是告诉Selector我这个Channel对什么事件感兴趣。当Channel上有这个事件发送的时候这个Channel就会被轮询出来。NIO提供了四个事件：

       我们有两种方式来设置Selector对Channel的哪些事件感兴趣。一个是在把Channel注册到Selector的时候设置。我们上面已经讲了这种情况。另一个是调用SelectionKey的interestOps()函数来修改Selector对Channel感兴趣的事件。

3.2.1 SelectionKey

       每个Channel向Selector注册时,都将会创建一个SelectionKey对象。一个SelectionKey键表示了一个特定的通道对象和一个特定的选择器对象之间的注册关系。并维护了Channel事件。

SelectionKey方法介绍

3.3 从Selector中选择就绪的Channel

       从Selector中选择就绪的Channel，其实是去选择SelectionKey，然后通过SelectionKey拿到对应的Channel。通过Channel做相应的操作。

       从Selector中选择就绪的Channel也很简单。先调用Selecotor的select()方法选择出已经就绪的通道，Selector会帮助我们把这些就绪的通道放到一个就绪列表里目前。然后我们在调用Selector的selectedKeys()方法把这些通道都拿出来。

3.4 Selecotr完整实例

    @Test
    public void tcpClient() {
        try {
            SocketChannel socketChannel = SocketChannel.open();
            // 连接
            socketChannel.connect(new InetSocketAddress("192.168.5.14", 6800));
            ByteBuffer writeBuffer = ByteBuffer.allocate(32);
            ByteBuffer readBuffer = ByteBuffer.allocate(32);
            writeBuffer.put("hello".getBytes());
            writeBuffer.flip();
            while (true) {
                writeBuffer.rewind();
                socketChannel.write(writeBuffer);
                readBuffer.clear();
                socketChannel.read(readBuffer);
                readBuffer.flip();
                byte[] b = new byte[readBuffer.limit()];
                int bufferReceiveIndex = 0;
                while (readBuffer.hasRemaining()) {
                    b[bufferReceiveIndex++] = readBuffer.get();
                }
                System.out.println("received : " + new String(b));
            }
        } catch (Exception e) {
            // ignore
        }
    }


    @Test
    public void tcpServer() {

        try {
            // 创建一个ServerSocketChannel通道
            ServerSocketChannel serverChannel = ServerSocketChannel.open();
            // 绑定6800端口
            serverChannel.bind(new InetSocketAddress("192.168.5.14", 6800));
            // 设置非阻塞
            serverChannel.configureBlocking(false);
            // Selector创建
            Selector selector = Selector.open();
            // 注册 channel，并且指定感兴趣的事件是 Accept
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            ByteBuffer readBuff = ByteBuffer.allocate(1024);
            ByteBuffer writeBuff = ByteBuffer.allocate(1024);
            writeBuff.put("received".getBytes());
            writeBuff.flip();
            while (true) {
                if (selector.select() > 0) {
                    Set<SelectionKey> readyKeys = selector.selectedKeys();
                    Iterator<SelectionKey> readyKeyIterator = readyKeys.iterator();
                    while (readyKeyIterator.hasNext()) {
                        SelectionKey key = readyKeyIterator.next();
                        readyKeyIterator.remove();

                        if (key.isAcceptable()) {
                            // 连接
                            ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                            SocketChannel socketChannel = serverSocketChannel.accept();
                            socketChannel.configureBlocking(false);
                            // 我们又给注册到Selector里面去了，声明这个channel只对读操作感兴趣。
                            socketChannel.register(selector, SelectionKey.OP_READ);
                        } else if (key.isReadable()) {
                            // 读
                            SocketChannel socketChannel = (SocketChannel) key.channel();
                            readBuff.clear();
                            socketChannel.read(readBuff);
                            readBuff.flip();
                            byte[] b = new byte[readBuff.limit()];
                            int bufferReceiveIndex = 0;
                            while (readBuff.hasRemaining()) {
                                b[bufferReceiveIndex++] = readBuff.get();
                            }
                            System.out.println("received : " + new String(b));
                            // 修改selector对channel感兴趣的事件
                            key.interestOps(SelectionKey.OP_WRITE);
                        } else if (key.isWritable()) {
                            // 写
                            writeBuff.rewind();
                            SocketChannel socketChannel = (SocketChannel) key.channel();
                            socketChannel.write(writeBuff);
                            // 修改selector对channel感兴趣的事件
                            key.interestOps(SelectionKey.OP_READ);
                        }
                    }
                }
            }

        } catch (IOException e) {
            // ignore
        }

    }

       以上，就是我们对JAVA NIO编程的一个简单介绍。最后我们用一个图来做一个总结。

最后

以上就是忧伤人生为你收集整理的JAVA NIO编程介绍一 Channel(通道)二 Buffer(缓冲区)三 Selector(多路复用器)的全部内容，希望文章能够帮你解决JAVA NIO编程介绍一 Channel(通道)二 Buffer(缓冲区)三 Selector(多路复用器)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。