0. 概述
1.Java NIO
2.Channel
- Channel到Channel的数据传输
- transferFrom()
- transferTo()
3.Buffer
- Buffer的基本使用
- Buffer的 capacity, position 和limit
- Buffer常用方法
  - 1.申请一个Buffer
  - 2.写入数据到buffer中
  - 3.flip()写切换到读
  - 4.从buffer中读取数据
  - 5.倒回rewind()
  - 6.clear()和compact()
  - 7.mark()和reset()
  - 8.equals()
  - 9.Scatter和Gather
3.Selector
- 1.创建Selector
- 2.注册Channel
- 3.SelectionKey对象
- 4.通过Selector选择Channel
- 5.selectionKey()
- 6.wakeUp()
- 7.close()
- 8.完整流程（伪代码）

0. 概述

NIO的全称是NoneBlocking IO，非阻塞IO，区别于BIO，BIO的全称是Blocking IO，阻塞IO。那这个阻塞是什么意思呢？例如传统的多线程服务器是BlockingIO模式的，从头到尾所有的线程都是阻塞的，接收请求和处理的过程中：

Accept是阻塞的，只有新连接来了，Accept才会返回，主线程才能继
Read是阻塞的，只有请求消息来了，Read才能返回，子线程才能继续处理
Write是阻塞的，只有客户端把消息收了，Write才能返回，子线程才能继续读取下一个请求

在IO处理被阻塞的时候处理线程就需要等在那里，占用了操作系统的调度资源，什么事也不干，是非常大的性能浪费。
NIO并不是Java独有的概念，NIO代表的一个词汇叫着IO多路复用。它是由操作系统提供的系统调用，早期这个操作系统调用的名字是select，但是性能低下，后来渐渐演化成了Linux下的epoll和Mac里的kqueue。

1.Java NIO

NIO并不是java独有概念，很早在操作系统层面已经提出。
Java从1.4版本引入NIO（New IO/Non-blocking IO）系列接口作为IO包的替代模块，用于替代Java IO和Java Networking 接口。与标准IO接口相比，JavaNIO提供了一种不同的方式来处理IO操作。

学习使用Java NIO需要理解下面几个概念：

Channels和Buffers：在标准IO接口中我们最常用的是字节流（byte strams）和字符流（character streams）。在NIO接口中我们需要使用Channel和Buffer进行IO操作，Channel模拟了流的概念，但是又有不同。数据总是从一个Channel读到一个buffer中，或者从一个buffer中写到channel中。
Non-blocking IO： Java NIO接口的核心就是提供了非阻塞IO的能力（Non-blocking IO）。例如：一个线程可以请求channel读取数据到buffer中，在channel读取数据的过程中，线程可以处理其他的事情，一旦数据已经读取到buffer中，线程可以继续处理buffer中的数据；对于将buffer中的数据写到channel中道理是一样的。
Selectors：Java NIO包含了Selectors的设计，Selector通过事件驱动多个Channel的对象，Selector可以实现让一个线程管理使用多个数据的Channel。

Java NIO包含了大量的类和组件，但是Channel，Buffer和Selector组成了NIO接口的核心，其余的一些组件例如Pipe、FileLock等更像是这三个组件结合使用的一些工具类。因此要学习使用Java NIO的使用必须首先掌握这三个模块。

Channel和Buffer通常是共同使用的，一般来讲，所有的IO和NIO操作都从一个channel开始，channel有点像stream，数据可以通过channel读取到buffer里；也可以将数据从buffer写到channel中Java NIO提供了很多种channel和buffer类型；Channel接口主要实现类如下：

* FileChannel
* DatagramChannel
* SocketChannel
* ServerSocketChannel

这些实现类覆盖了 UDP + TCP 网络IO以及常用的文件IO操作，这些实现类里还要一些比较有趣的接口，这里先简单了解一下，后边会详细介绍。Buffer的是要实现类：

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

这些Buffer的实现类涵盖了可以通过IO读写的所有基本类型：byte,short,int,long,float,double和字符（char）。Java NIO还包含了一个MappedByteBuffer用于使用内存映射读取文件，可以以内存的速度快速访问文件内容。

2.Channel

JavaNIO Channels和流有一些相似，但是又有些不同：

你可以同时读和写Channels，流Stream只支持单向的读或写（InputStream/OutputStream）
Channels可以异步的读和写，流Stream是同步的
Channels总是读取到buffer或者从buffer中写入

下面分别介绍一下Channel最重要的一些实现类：

FileChannel : 可以读写文件中的数据
DatagramChannel：可以通过UDP协议读写数据
SocketChannel：可以通过TCP协议读写数据
ServerSocketChannel：允许我们像一个web服务器那样监听TCP链接请求，为每一个链接请求创建一个SocketChannel

下面是一个基本的使用FileChannel读取数据到buffer的例子：

public class FileChannelExam {
    public static void main(String[] args){
        try {

            String path = FileChannelExam.class.getResource("/data/nio-data.txt").getPath();

            // 创建一个文件通道
            RandomAccessFile file = new RandomAccessFile(path, "rw");
            FileChannel channel = file.getChannel();

            // 创建一个字节buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            // 读取数据到buffer
            int len = channel.read(buffer);

            while (len != -1){
                System.out.println("Read " + len);

                // 将写模式转变为读模式，
                // 将写模式下的buffer内容最后位置设为读模式下的limit位置，作为读越界位，同时将读位置设为0
                // 表示转换后重头开始读，同时消除写模式的mark标记
                buffer.flip();

                // 判断当前读取位置是否到达越界位（position < limit）
                while (buffer.hasRemaining()){
                     // 读取当前position的字节（position++）
                    System.out.println(buffer.get());
                }

                // 清空当前buffer内容
                buffer.clear();
                len = channel.read(buffer);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

需要注意buffer.flip()方法，首先我们从Channel读取数据写入到Buffer，然后调用flip将切换到读模式，才能从buffer中读取数据。

Channel到Channel的数据传输

在Java NIO中我们可以直接将数据从一个Channel传输到另一个Channel中，比如FileChannel中有transferTo()和transferFrom()方法。

transferFrom()

transferFrom()方法可以将一个源channel中的数据传输到一个FileChannel中

String fromPath = FileChannelExam2.class.getResource("/data/nio-data.txt").getPath();
String toPath = FileChannelExam2.class.getResource("/data/nio-data-to.txt").getPath();

RandomAccessFile fromFile = new RandomAccessFile(fromPath, "rw");
FileChannel fromChannel = fromFile.getChannel();

RandomAccessFile toFile = new RandomAccessFile(toPath, "rw");
FileChannel toChannel = toFile.getChannel();

long position = 0;
long count = fromChannel.size();

toChannel.transferFrom(fromChannel, position, count);

transferFrom()有三个参数，源channel，position，count；position定义目标channel写入的起始位置，count定义写入数据的容量，如果源channel中的数据量小于count，只会写入源channel数据的量。
另外，在SocketChannel的实现中，当前SocketChannel已经读取一部分数据，稍后仍会读取更多数据情况下，并不一定能将完整的数据读取到FileChannel中。

transferTo()

transferTo()方法可以将FileChannel中的数据传输到其他channel中

String fromPath = FileChannelExam2.class.getResource("/data/nio-data.txt").getPath();
String toPath = FileChannelExam2.class.getResource("/data/nio-data-to.txt").getPath();

RandomAccessFile fromFile = new RandomAccessFile(fromPath, "rw");
FileChannel fromChannel = fromFile.getChannel();

RandomAccessFile toFile = new RandomAccessFile(toPath, "rw");
FileChannel toChannel = toFile.getChannel();

long position = 0;
long count = fromChannel.size();

fromChannel.transferTo(position, count, toChannel);

上边两个例子有些相似，唯一的区别就是调用的方法和调用方法的对象。这个方法和SocketChannel也会存在和transferFrom同样的问题。

3.Buffer

在Java NIO中各类Buffer主要用于和NIO Channel进行交互，数据从Channel中读取到Buffer中，从Buffer写入到Channel中。

Java NIO总结（一）：Channel、Buffer、Selector_第1张图片

channel-buffer数据交互

我们可以将Buffer看做内存中的一块区域，我们可以在这块区域上写数据，然后在从中读取。这块内存区域被包装成NIO Buffer对象，提供了一系列的方法使我们操作这块内存变得更简单一些。

Buffer的基本使用

使用Buffer进行读写数据一般会通过下边四个步骤处理：

将数据写到Buffer中
调用buffer.flip()切换为读模式
从Buffer中读取数据
调用buffer.clear()或者buffer.compact()清空或压缩buffer

下边是个简单的Buffer使用的例子

public class FileChannelExam {
    public static void main(String[] args){
        try {

            String path = FileChannelExam.class.getResource("/data/nio-data.txt").getPath();

            // 创建一个文件通道
            RandomAccessFile file = new RandomAccessFile(path, "rw");
            FileChannel channel = file.getChannel();

            // 创建一个字节buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            // 读取数据到buffer
            int len = channel.read(buffer);

            while (len != -1){
                System.out.println("Read " + len);

                // 将写模式转变为读模式，
                // 将写模式下的buffer内容最后位置设为读模式下的limit位置，作为读越界位，同时将读位置设为0
                // 表示转换后重头开始读，同时消除写模式的mark标记
                buffer.flip();

                // 判断当前读取位置是否到达越界位（position < limit）
                while (buffer.hasRemaining()){
                     // 读取当前position的字节（position++）
                    System.out.println(buffer.get());
                }

                // 清空当前buffer内容
                buffer.clear();
                len = channel.read(buffer);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

当我们将数据写入buffer时，buffer会记录我们写入了多少数据，当需要读取数据的时候，需要调用flip()方法将buffer从写模式切换到读模式，在读模式下，buffer允许用户读取已经写入buffer的所有数据。

一旦我们已经读取了buffer中的所有数据，我们需要清空buffer以便写一次写入数据。我们可以使用两种方法达到这个目的：

调用clear()方法：清空整个buffer；
调用compact()方法：仅清空已经读取的数据，未读取的数据移动到buffer的起始位置，新写入的数据会放到未读取数据的后边。

Buffer的 capacity, position 和limit

Buffer对象使用capacity，position，limit三个属性来保存内存状态以便灵活操作内存，了解这三个属性的作用是理解Buffer工作原理的关键。position和limit决定了Buffer可以读写的区域（position <= x < limit），capacity 表示读写的最大容量

下图模拟了Buffer在读、写模式下capacity、position、limit的状态。

Java NIO总结（一）：Channel、Buffer、Selector_第2张图片

buffer状态

capacity

作为一块内存，buffer必须有一个固定容量，这就是buffer的capacity。你最多只能写入capacity容量的数据到buffer中，一旦buffer中被写满数据，在你写入新的数据之前需要置空buffer（通过读取数据或直接清空）。

position

当写入buffer数据的时候需要明确写入的位置，这就是position，buffer初始化的时候position为0；当你写入一个字节或者整型数字后，position指针会移动到已经写入数据的内存的下一个内存位置，position的最大值为capacity-1；
当读取数据的时候，你也可以给定一个position，当你调用filp()方法将一个buffer从写模式切换到读模式的时候，position会重置为0，你将会从0位置开始读取数据，读取数据后position也会移动到已读取数据的下一个位置。

limit

在写数据的时候，limit限制了写入数据的最大容量即position的最大值（position < limit）.在写模式下，limit=capacity；
从上边代码可以看到当调用flip()切换到读模式时，limit被设置为已写入数据的position值，限制你能读取数据的容量，也就是说你最多能读取你写入的所有的数据。

Buffer常用方法

1.申请一个Buffer

在使用Buffer之前，你必须为它申请一块内存空间，每个Buffer的实现类都实现了它自己的allocate()方法来完成内存申请的工作，下面的代码展示了如何创建一个Buffer对象。

// 创建一个1024字节的ByteBuffer对象
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

// 创建一个1024字符的CharBuffer对象
CharBuffer charBuffer = CharBuffer.allocate(1024);

2.写入数据到buffer中

向buffer写入数据有两种方法：

通过Channel向Buffer中写入数据
直接写入数据到Buffer

// 通过Channel写入，即将Channel数据读取到buffer中
int len = channel.read(buffer);

// 直接写入，调用put方法
buffer.put(127);

需要注意的是，put()方法有多重实现，你可以使用不同的方式写入数据，例如：写入到特定的位置，写入一个字节数组等。

3.flip()写切换到读

flip()方法是将buffer由写模式切换到读模式的方法，flip()方法将position重置为0，将limit设置为已经写入的最大位置，也就是position从标记写入位置改变为标记都区位置；源码中flip()方法的实现如下：

public final Buffer flip() {
    limit = position; 
    position = 0;
    mark = -1;
    return this;
}

4.从buffer中读取数据

从buffer中读取数据同样有两种方法：

通过Channel从Buffer中读取数据
直接从Buffer中读取数据

// 使用Channel读取数据，即将数据写入Channel
int len = channel.write(buffer);

// 直接读取数据
byte data = buffer.get();

同样get()方法也有很多重载实现，允许我们使用不同的方法读取数据，可以参考Buffer实现类文档查看更多细节。

5.倒回rewind()

rewind()倒回方法只是将position重置为0，limit仍保持原值；一般在读模式下使用可以让我们重复读取buffer中的数据;在写模式下则会导致重新写入数据（类似于置空了buffer）。源码：

public final Buffer rewind() {
    position = 0;
    mark = -1;
    return this;
}

6.clear()和compact()

一旦完成读操作，我们需要让buffer重新改变为写模式，以便可以重新向buffer写入新的数据，buffer通过clear()和compact()来完成。
当调用clear的时候position会重置为0，limit设置为capacity，虽然buffer中的数据未被擦除，但逻辑上相当于buffer被清空了，因为新写入的数据会覆盖旧数据，如果buffer中还有未被读取的数据，这些数据依然会被覆盖！
clear源码实现，可以和rewind的比较一下，看有什么区别：

public final Buffer clear() {
    position = 0;
    limit = capacity; 
    mark = -1;
    return this;
}

如果希望保留buffer中还未读取的数据，只是清理已读取的数据来腾出写入空间，则可以通过compact()方法实现；compact()方法会拷贝未读入的数据到buffer内存空间的起始位置，然后将position设置到未读取数据元素的最后位置，limit值仍然为buffer的capacity，现在buffer就有了更多的空间供写入数据。我们可以看一下HeapByteBuffer的源代码实现：

public ByteBuffer compact() {
    //复制数据
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());  
    // 重置position位置   
    position(remaining());
    // limit设置为capacity      
    limit(capacity());              
    discardMark();
    return this;
}

7.mark()和reset()

mark和reset方法是配合使用的一组方法，你可以通过mark()方法标记buffer中的一个位置，经过读写操作后position位置会改变，然后你就可以使用reset()方法使position位置回到mark()方法标记的位置。

buffer.mark();
...; // 读或写操作
buffer.reset();  // 回到标记位置

8.equals()

可以通过equals和compareTo()方法来比较两个buffer，equals判断条件：
1. 两个buffer是否同一类型；
2. 是否持有相同数量的数据；
3. 持有的数据是否每个元素都相同。

9.Scatter和Gather

Java NIO内置支持分散（Scatter）和聚集（Gather）,Scatter和Gather是用于读取和写入Channel的概念。

Scatter是指从一个Channel中分散读取数据到一个或多个Buffer的操作，因此Channel将数据分散到多个Buffer中；
Gather是指将一个或多个Buffer中的数据写入一个Channel的操作，一次Channel可以从多个Buffer中收集数据。
Scatter和Gather在解决传输数据拥有多个部分需要进行分离的场景下有很大的用处；比如，一个消息数据中包含消息头（header）和消息体（body）两部分，我们就可以将消息头和消息体分别读入不同的Buffer保存，使得消息的分离处理更加方便。

Scatter操作

将Channel中的数据读取到多个Buffer

Java NIO总结（一）：Channel、Buffer、Selector_第3张图片

这里写图片描述

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);

ByteBuffer[] buffers = { header, body };

channel.read(buffers);

当Channel的read()方法传入参数为buffer数据的时候，read()方法会按照顺序将数据写入到传入的多个buffer中，当一个buffer写满后便会写入下一个buffer直到写满所有的buffer；因为分离读取的时候，Channel写入buffer的数据是按顺序的，Scatter操作并不适合动态长度的数据传输，也就意味着传输数据的每一部分都是固定长度时，Scatter才能发挥它的作用。

Gather操作

Gather操作将多个buffer的数据写入到同一个Channel

Java NIO总结（一）：Channel、Buffer、Selector_第4张图片

这里写图片描述

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);

// 写入数据
ByteBuffer[] bufferArray = { header, body };
channel.write(bufferArray);

channel的write()方法可以接受buffer数据作为参数，write()方法会按照顺序将多个buffer中的数据依次写入channel。需要注意的是，write()操作只会写入buffer中已写入的数据，即position到limit之间的数据；例如一个buffer的容量为128字节，但buffer中只写入了28字节的数据，只有这28个字节会写入channel中，因此Gather操作和Scatter相反非常适合动态长度数据写入。

3.Selector

Selector是Java NIO中用于管理一个或多个Channel的组件，控制决定对哪些Channel进行读写；通过使用Selector让一个单线程可以管理多个Channel甚至多个网络连接。

使用Selector最大的优势就是可以在较少的线程中控制更多的Channel。事实上我们可以使用一个线程控制需要使用的所有Channel。操作系统线程的运行和切换需要一定的开销，使用的线程越小，系统开销也就越少；因此使用Selector可以节省很多系统开销。下图展示了一个线程使用Selector控制三个Channel的情形。

Java NIO总结（一）：Channel、Buffer、Selector_第5张图片

这里写图片描述

1.创建Selector

Selector selector = Selector.open();

2.注册Channel

想要通过Selector中控制Channel，必须将Channel注册到Selector中，通过SelectableChannel.register()方法实现。

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

需要注意的是注册到Selector的Channel必须是非阻塞模式的（non-blocking），FileChannel是无法使用的因为FileChannel无法切换到非阻塞模式，SocketChannel非常适合配合Selector使用。
register方法的第二个参数是监听设置，用于设置注册的channel通过Selector监听的操作事件类型，总共有四类事件可以监听：

Connect
Accept
Read
Write

JavaNIO中在SelectionKey中有四个静态变量表示这四类事件：

SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE

如果在注册Channel的时候希望监听多个事件可以使用“|”连接静态变量

SelectionKey key = channel.register(selector, 
    SelectionKey.OP_READ|SelectionKey.OP_WRITE);

3.SelectionKey对象

Channel注册到Selector后会返回一个SelectionKey对象，这个对象包含了下面一些重要属性：

事件监听集合（interest set）

监听集合（interest set）是channel在selector监听的事件类型的集合，可以同SelectionKey读写这个配置。

int interestSet = selectionKey.interestOps();

// 通过 & 操作判断监听配置是否包含某类事件
boolean isInterestedInAccept = interestSet & SelectionKey.OP_ACCEPT;
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;

就绪结合（ready set）

就绪集合（ready set）是channel已经就绪的操作的集合，我们主要在一个selection操作后访问就绪集合。

int readySet = selectionKey.readyOps();
// 可以使用和interest set 同样的方法测试集合中是否包含某类事件，
// 也可以通过调用下边的一些方法进行判断：
selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

Channel对象

Channel channel = selectionKey.channel();

Selector对象

Selector selector = selectionKey.selector();

一个可选附属对象（an attached object (optional) ）

可以给SelectionKey添加一个附加对象，通常用来标记Channel或者Channel的特征信息。例如，我们可以将和Channel配合使用的Buffer附加到SelectionKey上。

//  附加对象
selectionKey.attach(theObject);
// 获取附加对象 
Object attachedObj = selectionKey.attachment();
// 还可以再注册channel的时候直接添加附加对象
SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

4.通过Selector选择Channel

将多个Channel注册到Selector后，我们就可以通过调用select()方法选择监听了特定事件（connect，accept，read，write）并且已经就绪的Channel。换种说法就是，如果你已经注册了一个监听read事件的channel，它就会通过select()方法接收到read事件。
select方法有几种不同的重载：

int select()：阻塞直到至少有一个channel对监听的事件操作准备就绪
int select(long timeout)：和select()方法一样，但只会阻塞到指定的超时时间；
int selectNow()：不会阻塞，无论是否有就绪的channel都会立即返回。

三个方法的返回值是最后一次调用select()后就绪的channel的数量，如果你调用select()返回1，表示调用select()后有一个channel准备就绪了；当你再次调用sleect()时再返回1，表示这次又有一个channel就绪了，如果对第一次调用就绪的channel没有做任何操作，这时总共有两个已经准备就绪的channel，在两次调用中都只有一个channel变为就绪状态。

5.selectionKey()

调用select()方法返回就绪channel个数后，可以调用selectedKeys()方法获取就绪channel的SelectionKey集合

Set selectedKeys = selector.selectedKeys();

我们可以通过这个集合访问已经就绪的channel

Set selectedKeys = selector.selectedKeys();

Iterator keyIterator = selectedKeys.iterator();

while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();

    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.

    } else if (key.isConnectable()) {
        // a connection was established with a remote server.

    } else if (key.isReadable()) {
        // a channel is ready for reading

    } else if (key.isWritable()) {
        // a channel is ready for writing
    }

    keyIterator.remove();
}

上边代码演示了遍历每一个SelectionKey并判断SelectionKey持有的channel引用就绪的事件。

注意循环中最后keyInterator.remove()方法，这里并不是将SelectionKey对象从selector中移除，只是从就绪集合中移除，对channel操作后必须调用这个方法，当下一次channel就绪后，它的SelectionKey还会被加入到就绪集合中。

6.wakeUp()

一个线程调用select()后可以通过再次调用select()离开阻塞状态；也可以通过其他线程调用wakeUp()方法是阻塞在select()的Selecor立即返回。

7.close()

使用完Selector后可以使用close()方法关闭它，这会关闭Selector和清除注册到Selector的SelecionKey对象，但Channel本身并不会关闭。

8.完整流程（伪代码）

Selector selector = Selector.open();

channel.configureBlocking(false);

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

while(true) {

    int readyChannels = selector.select();

    if(readyChannels == 0) continue;

    Set selectedKeys = selector.selectedKeys();

    Iterator keyIterator = selectedKeys.iterator();

    while(keyIterator.hasNext()) {

    SelectionKey key = keyIterator.next();

    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.

    } else if (key.isConnectable()) {
        // a connection was established with a remote server.

    } else if (key.isReadable()) {
        // a channel is ready for reading

    } else if (key.isWritable()) {
        // a channel is ready for writing
    }

    keyIterator.remove();
    }
}

转自 https://blog.csdn.net/oMaoYanEr/article/details/79976359

Java NIO总结（一）：Channel、Buffer、Selector

0. 概述

1.Java NIO

2.Channel

Channel到Channel的数据传输

transferFrom()

transferTo()

3.Buffer

Buffer的基本使用

Buffer的 capacity, position 和limit

Buffer常用方法

1.申请一个Buffer

2.写入数据到buffer中

3.flip()写切换到读

4.从buffer中读取数据

5.倒回rewind()

6.clear()和compact()

7.mark()和reset()

8.equals()

9.Scatter和Gather

3.Selector

1.创建Selector

2.注册Channel

3.SelectionKey对象

4.通过Selector选择Channel

5.selectionKey()

6.wakeUp()

7.close()

8.完整流程（伪代码）

你可能感兴趣的:(Java NIO总结（一）：Channel、Buffer、Selector)