我所知道Netty之初识NIO与它的Buffer介绍

一、Java NIO （New IO ）基本介绍

Java NIO（New IO）也有人称之为 java non-blocking IO是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API

NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO进行相关操作

NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传统的IO的read和write只能阻塞执行，在BIO中可以看到当线程在读写IO期间不能干其他事情，

比如调用socket.read()时，如果服务器一直没有数据传输过来，线程就一直阻塞，而NIO中可以配置socket为非阻塞模式

NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写

NIO 有三大核心部分：Channel( 通道)，Buffer( 缓冲区), Selector( 选择器)

Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情

非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情

通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 1000 个请求过来,根据实际情况，可以分配20 或者 80个线程来处理。不像之前的阻塞 IO 那样，非得分配 1000 个

二、NIO 和 BIO 的比较

• BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多
• BIO 是阻塞的，NIO 则是非阻塞的
• BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和Buffer(缓冲区)

NIO的数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。

Selector(选择器)用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道

BIO与NIO表格对比图

三、NIO 三大核心原理示意图

NIO 有三大核心部分：Channel( 通道)，Buffer( 缓冲区), Selector( 选择器)

Buffer 缓冲区

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存

内部有三个主要的指针式的结构

• capacity：代表Buffer的容量大小
• position：指示目前所在的位置
• limit：初始的时候位置与capacity相同
  
  这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。相比较直接对数组的操作，Buffer API更加容易操作和管理

Channel（通道）

通道类似流，但又有些不同：既可以从通道中读取数据，又可以写数据到通道

但流的（input或output)读写通常是单向的。 通道可以非阻塞读取和写入通道，通道可以支持读取或写入缓冲区，也支持异步地读写。并且Channel 之间也可以传输数据

几个重要的 channel

Selector选择器

Selector是 一个Java NIO组件，可以能够检查一个或多个 NIO 通道，并确定哪些通道已经准备好进行读取或写入。

这样，一个单独的线程可以管理多个channel，从而管理多个网络连接，提高效率

还可以根据 channel 的不同类型，就可以对channel 进行不同的操作

每个 channel 都会对应一个 Buffer，并且一个线程对应Selector ， 一个Selector对应多个 channel(连接)。程序切换到哪个 channel 是由事件决定的，Selector 会根据不同的事件，在各个通道上切换

简而言之：Channel 负责传输， Buffer 负责存取数据

四、介绍NIO核心一：缓冲区(Buffer)

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

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

Buffer 类及其子类

像一个数组，可以保存多个相同类型的数据。根据数据类型不同 ，有以下常用子类：

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

上述 Buffer 类他们都采用相似的方法进行管理数据，只是各自 管理的数据类型不同而已。都是通过如下方法获取一个 Buffer 对象：

//创建一个容量为capacity 的 XxxBuffer 对象
static XxxBuffer allocate(int capacity)

缓冲区的基本属性

Buffer 中的重要概念：

容量 (capacity) ：作为一个内存块，Buffer具有一定的固定大小，也称为"容量"，缓冲区容量不能为负，并且创建后不能更改

限制 (limit)：表示缓冲区中可以操作数据的大小（limit 后数据不能进行读写）。缓冲区的限制不能为负，并且不能大于其容量。

写入模式，限制等于buffer的容量。读取模式下，limit等于写入的数据量

位置 (position)：下一个要读取或写入的数据的索引。缓冲区的位置不能为 负，并且不能大于其限制

标记 (mark)与重置 (reset)：标记是一个索引，通过 Buffer 中的 mark() 方法 指定Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这 个 position

标记、位置、限制、容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity`

Buffer常见方法

• Buffer clear() 清空缓冲区并返回对缓冲区的引用
• Buffer flip() 为 将缓冲区的界限设置为当前位置，并将当前位置重置为 0
• int capacity() 返回 Buffer 的 capacity 大小
• boolean hasRemaining() 判断缓冲区中是否还有元素
• int limit() 返回 Buffer 的界限(limit) 的位置
• Buffer limit(int n) 将设置缓冲区界限为 n,并返回一个具有新 limit 的缓冲区对象
• Buffer mark() 对缓冲区设置标记
• int position() 返回缓冲区的当前位置 position
• Buffer position(int n) 将设置缓冲区的当前位置为 n并返回修改后的 Buffer 对象
• int remaining() 返回 position 和 limit 之间的元素个数
• Buffer reset() 将位置 position 转到以前设置的mark 所在的位置
• Buffer rewind() 将位置设为为 0， 取消设置的 mark

向 Buffer 写入数据

当创建一个 Buffer 对象的时候，我们会给他一个尺寸（大小），最初的位置如下图
往Buffer中写数据，空白格子部分假设是我们写入的数据

调整 position指针位置到开始位置、调整limit指针位置到上次写入的结束位置

然后就是读取的模式

第一种读取的情况：一口气读完，读到limit指针的位置

这个时候想写数据了，这个时候又需要翻转了，用 clear()方法，如下所示

仔细一看，发现与刚开始创建的是一样的，其实只是移动了指针，并没有清除 buffer 里面的数据

另外的一种读取的数据的情况：读取部分数据

后面未读的数据保留起来，以后来读，但是这个时候调整为写模式，希望的就是写完数据后，上次没有读完的数据依然能读取出来。compact() 方法就能达到这个目的

这里假设前3条数据是已读的，第4条数据是我们还没有来得及读完，但是又想在之后继续读取的数据

compact函数会把未读取的数据拷贝到整个Buffer的最开始的位置
也就是说我们下次如果再要读数据的话，知道我们未读的数据肯定是出现在Buffer对象的最开始的位置。之后会把position指针移动到我们未读的数据的接下来的位置

接下来，limit指针移动到与capacity同样的位置，之后由读模式翻转回写模式

之后再想写数据，就会从position所指的位置开始写，这样就代表了我们并不会覆盖掉上一次读取模式时还没有读完的数据

缓冲区的数据操作

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)

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

• 1：写入数据到Buffer
• 2：调用flip()方法，转换为读取模式
• 3：从Buffer中读取数据
• 4：调用buffer.clear()方法或者buffer.compact()方法清除缓冲区

五、对缓存区Buffer常用API案例实现

针对于Buffer的常用方法，我们先初次尝试分配一个缓冲区，容量设置为10

public static void test1(){
   //1. 分配一个指定大小的缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);
    System.out.println("---------------allocate()--------------");
    //返回缓冲区的当前位置 position
    System.out.println(buf.position());
    //返回 Buffer 的界限(limit) 的位置
    System.out.println(buf.limit());
    //返回 Buffer 的 capacity 大小
    System.out.println(buf.capacity());
}

控制台输出结果：
-----------------allocate()----------------
0
1024
1024

接下来我们利用put方法存入数据到缓存区中

public static void test1(){
   //1. 分配一个指定大小的缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);
    System.out.println("-----------------allocate()----------------");
    //返回缓冲区的当前位置 position
    System.out.println(buf.position());
    //返回 Buffer 的界限(limit) 的位置
    System.out.println(buf.limit());
    //返回 Buffer 的 capacity 大小
    System.out.println(buf.capacity());

    //2. 利用 put() 存入数据到缓冲区中
    String str = "你好";
    buf.put(str.getBytes());
    System.out.println("-----------------put()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());
}

控制台输出结果：
-----------------allocate()----------------
0
1024
1024
-----------------put()----------------
6
1024
1024

此时我们刚刚是写入了数据的，这时我们再切换回读的模式看看

public static void test1(){
   //1. 分配一个指定大小的缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);
    System.out.println("-----------------allocate()----------------");
    //返回缓冲区的当前位置 position
    System.out.println(buf.position());
    //返回 Buffer 的界限(limit) 的位置
    System.out.println(buf.limit());
    //返回 Buffer 的 capacity 大小
    System.out.println(buf.capacity());

    //2. 利用 put() 存入数据到缓冲区中
    String str = "你好";
    buf.put(str.getBytes());
    System.out.println("-----------------put()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());

    //3. 切换读取数据模式
    buf.flip();
    System.out.println("-----------------flip()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());
}

控制台输出结果：
-----------------allocate()----------------
0
1024
1024
-----------------put()----------------
6
1024
1024
-----------------flip()----------------
0
6
1024

就发现按照我们上面的思维图是一样的，此时的位置、界限发送了变化，读出来看看

public static void test1(){
   //1. 分配一个指定大小的缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);
    System.out.println("-----------------allocate()----------------");
    //返回缓冲区的当前位置 position
    System.out.println(buf.position());
    //返回 Buffer 的界限(limit) 的位置
    System.out.println(buf.limit());
    //返回 Buffer 的 capacity 大小
    System.out.println(buf.capacity());

    //2. 利用 put() 存入数据到缓冲区中
    String str = "你好";
    buf.put(str.getBytes());
    System.out.println("-----------------put()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());

    //3. 切换读取数据模式
    buf.flip();
    System.out.println("-----------------flip()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());

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

控制台输出结果：
-----------------allocate()----------------
0
1024
1024
-----------------put()----------------
6
1024
1024
-----------------flip()----------------
0
6
1024
-----------------get()----------------
6
6
1024

刚刚进行分配空间、写入数据、读取数据，那么我们能否清空缓冲区呢？试试看

public static void test2(){
   //1. 分配一个指定大小的缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);
    System.out.println("-----------------allocate()----------------");
    //返回缓冲区的当前位置 position
    System.out.println(buf.position());
    //返回 Buffer 的界限(limit) 的位置
    System.out.println(buf.limit());
    //返回 Buffer 的 capacity 大小
    System.out.println(buf.capacity());

    //2. 利用 put() 存入数据到缓冲区中
    String str = "你好";
    buf.put(str.getBytes());
    System.out.println("-----------------put()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());

    //3. 利用 clear() 清楚数据缓冲区
    buf.clear();
    System.out.println("-----------------clear()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());
}
控制台输出结果：
-----------------allocate()----------------
0
1024
1024
-----------------put()----------------
6
1024
1024
-----------------clear()----------------
0
1024
1024

我们发现起始位置回到0，但是它的数据是否清楚了呢？看看是否能读取出来？

public static void test2(){

    //1. 分配一个指定大小的缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);
    System.out.println("-----------------allocate()----------------");
    //返回缓冲区的当前位置 position
    System.out.println(buf.position());
    //返回 Buffer 的界限(limit) 的位置
    System.out.println(buf.limit());
    //返回 Buffer 的 capacity 大小
    System.out.println(buf.capacity());

    //2. 利用 put() 存入数据到缓冲区中
    String str = "你好";
    buf.put(str.getBytes());
    System.out.println("-----------------put()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());

    //3. 利用 clear() 清楚数据缓冲区
    buf.clear();
    System.out.println("-----------------clear()----------------");
    System.out.println(buf.position());
    System.out.println(buf.limit());
    System.out.println(buf.capacity());

    //4. 利用 get() 读取缓冲区中的数据
    byte[] dst = new byte[buf.limit()];
    buf.get(dst);
    System.out.println(new String(dst, 0, dst.length));
}
控制台输出结果：
-----------------allocate()----------------
0
1024
1024
-----------------put()----------------
6
1024
1024
-----------------clear()----------------
0
1024
1024
你好 

这就是说明了我们其实只是移动了指针，并没有清除 buffer 里面的数据