Buffer简介
在Java NIO中，主要有三大基本的组件：Buffer、Channel和Selector，上一篇文章我们具体介绍了Selector,现在让我们深入理解下在实际编程中使用的最多的Buffer。
定义
首先先让我们来认识一下Buffer：
A container for data of a specific primitive type.
A buffer is a linear, finite sequence of elements of a specific primitive type
在Buffer类的描述中，Buffer被定义为用于特定基本类型数据的容器，且是特定基本类型的线性优先元素序列。
Buffer提供了一个字节缓冲区，它可以从channels中读取数据到Buffer，也可以将Buffer中的数据写入到channels，所以NIO被定义为面向缓冲区编程，而IO则是被定义为面向流的编程。
底层实现
通过阅读源码让我们慢慢揭开Buffer的神秘面纱
public abstract class Buffer {
/************ 状态变量 ***********/
// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;
/************ 访问方法 ***********/
public final Buffer limit(int newLimit);
public final Buffer mark();
public final Buffer reset();
public final Buffer clear();
public final Buffer flip();
public final Buffer rewind();
// 剩余可读元素，limit - position
public final int remaining();
// 是否是只可读缓冲区
public abstract boolean isReadOnly();
// 是否是堆外内存
public abstract boolean isDirect();Buffer类一共有四个变量，被称之为状态变量
- capacity：容量，必须初始化的值（因为底层是数组）
- limit：上界，缓冲区的临界区，即最多可读到哪个位置
- position：下标，当前读取到的位置(例如当前读出第5个元素，则读完后，position为6)
- mark：标记，备忘位置
四个状态大小关系
0 <= mark <= position <= limit <= capacity通过访问方法我们可以控制变量的指向，来达到读取到我们想要的数据的目的，下面让我们结合源码和图来学习下各方法对缓冲区的操作
ByteBuffer buffer = ByteBuffer.allocate(n); (1)
buffer.limit(5); (2)
// 执行get操作会将position加1
buffer.get();
buffer.get();
buffer.mark(); (3)
buffer.get();
buffer.get();
buffer.reset(); (4)
buffer.flip(); (5)
buffer.rewind(); (6)
buffer.reset(); (7)(1)初始化Buffer
一个初始化的Buffer各变量位置指向如图(这里capacity大小为n)：
image.png
（2）limit
public final Buffer limit(int newLimit) {
if ((newLimit > capacity) || (newLimit < 0))
throw new IllegalArgumentException();
// 设置limit的新位置
limit = newLimit;
// 如果当前读取到位置大于新设置的可读上限，则将position重置为limit，意思是缓存区无法再往下读取了
if (position > limit) position = limit;
// 如果mark的位置大于新设置的可读上限，则需要重置mark为-1；代表mark的位置失效了
if (mark > limit) mark = -1;
return this;
}所以如果我们执行limit(5)操作，则上图变化为
image.png
（3）mark
public final Buffer mark() {
// 记录当前读到的位置
mark = position;
return this;
}mark操作之前Buffer已经被读取到第二个位置(此时position=2)，准备要读第三个元素之前，我们执行mark操作后，则图变化为
image.png
（4）reset
// mark位置，将postion置为mark
// 恢复到上次备忘的位置
public final Buffer reset() {
int m = mark;
if (m < 0)
throw new InvalidMarkException();
position = m;
return this;
}reset操作之前，我们执行了两次get操作，所以此时的position=4，状态变化为下图
image.png
执行reset后我们的状态又变为（3）操作
image.png
（5）flip
如果我们想重新读取上一次读取的内容，则可以执行flip操作
// 将缓冲区的内容切换为重新读取状态
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}状态变化为
image.png
（6）rewind
重读缓冲区操作
public final Buffer rewind() {
position = 0;
mark = -1;
return this;
}此时的操作结果与执行flip操作后一致；
但如果我们执行rewind之前不执行flip操作，则在（4）操作后，我们直接执行rewind，则状态变化为
image.png
（7）clear
恢复缓冲区至初始状态
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}即
image.png
通过上面的实例及图讲解相信大家一定对Buffer加深了了解，所以我们再次简单的定义一下Buffer；Buffer缓冲区其实就是一个线性数组，通过mark、position、limit来控制读取和写入数组，补充一下Buffer的特性：
- Buffer底层是线性数组，是有限的基本类型元素的组合
- Buffer可以提供一个固定大小的容器来读取和写入数据
- 每个Buffer都是可读的，但只有选中的buffer才可写
- 默认情况下，Buffer不是线程安全的，所以在多线程环境下操作同一个Buffer，一定要使用锁机制保证同步
Buffer的实现类
上文我们对Buffer已经有了一定的了解，下面让我们来看看它有哪些实现吧；首先我们看看Buffer类结构图
image.png
一般的，我们将Buffer分为两类
- ByteBuffer：字节缓冲区，NIO编程中最常用的缓冲区。主要包含两种，HeapByteBuffer和MappedByteBuffer
- 基本类型Buffer：除了boolean类型之外的其他基本数据类型的缓冲区
在实际编程中，我们最常用的就是ByteBuffer，因为在实际IO中也都是通过字节流在交互，所以下面我们将重点讲ByteBuffer,废话不多说，先上源码看看
public abstract class ByteBuffer
extends Buffer implements Comparable
{
final byte[] hb;
// 数组的起始位置
final int offset;
/**********创建ByteBuffer**********/
// 创建基于堆外内存的ByteBuffer
public static ByteBuffer allocateDirect(int capacity) {
return new DirectByteBuffer(capacity);
}
// 创建基于堆内存的ByteBuffer
public static ByteBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapByteBuffer(capacity, capacity);
}
/**********ByteBuffer的方法(不全，重要的几个)**********/
// 字节序
// BIG_ENDIAN：最低地址存放最高有效字节
// LITTLE_ENDIAN：最低地址存放最低有效字节
// java字节序：JAVA虚拟机中多字节类型数据的存放顺序，JAVA字节序也是BIG-ENDIAN。
public final ByteOrder order() {
return bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
}
// 读取指定位置的元素
public abstract byte get(int index);
// 往指定位置写入元素
public abstract ByteBuffer put(int index, byte b);
// 基于当前状态new一个新的ByteBuffer
public abstract ByteBuffer duplicate();
// 是否是直接操作内存的Buffer；若是，则此Buffer直接操作JVM堆外内存 ，使用Unsafe实现；否则操作JVM堆内存
public abstract boolean isDirect();
// 丢弃已经读取的数据，保留未读取的数据，并使缓存中处于待填充状态
public abstract ByteBuffer compact();
// 从当前buffer中生成一个该buffer尚未使用部分的新的缓冲区，例如当前buffer的position为3，limit为5，则新的缓冲区limit和capacity都为2，offset的3，数据区域两者共享；
public abstract ByteBuffer slice(); 从ByteBuffer的源码来看，相比较于Buffer，其新增了几个重要的方法，下面让我们继续以前文的方式来学习下这些方法的作用
ByteBuffer buffer = ByteBuffer.allocate(8);
// 执行get操作会将position加1
buffer.get();
buffer.get();
buffer.compact(); (1)
buffer.slice(); (2)执行（1）操作前，状态图如下：
image.png
（1）compact
protected int ix(int i) {
return i + offset;
}
public ByteBuffer compact() {
// 把已经读取的内容使用后面的内容覆盖
System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
// 修改状态
// 将position置为limit - position
position(remaining());
// limit为capacity
limit(capacity());
// mark置为-1
discardMark();
return this;
}状态转换如下，这里我们可以看到，position已经被置为6，但是其实我们是想position置为0，这样才符合我们的初衷；所以，从这点分析来看，compact方法最好是等缓冲区全部被读完后使用，达到复用ByteBuffer的目的，否则就会造成空间浪费
image.png
(2) slice
// 实际是共享当前ByteBuffer数组的空间
public ByteBuffer slice() {
return new HeapByteBuffer(hb,-1,0,this.remaining(),this.remaining(),this.position() + offset);
}最终状态如图，其中带1的部分是为新缓冲区的状态：
image.png
HeapByteBuffer和MappedByteBuffer
说了这么多Buffer和ByteBuffer的方法，我们再回过头来看看类结构图中ByteBuffer的两个子类，HeapByteBuffer和MappedByteBuffer，通过对比的方式了解下这两者的区别
HeapByteBuffer
MappedByteBuffer
实现
byte[]数组
Unsafe实现
内存分配
Java堆内存
堆外内存
适用场景
复用
经常释放和新建
这里就不具体介绍这两个类实现的源码了，有兴趣了解Unsafe的同学可以看下我团技术团队推的一篇文章【基本功】Java魔法类：Unsafe应用解析
（1）什么是Java堆内存和堆外内存？
- Java堆内存：Java内存结构主要有三大块：堆内存、方法区和栈；堆内存(如下图中的Heap区)是JVM中最大的一块由年轻代和老年代组成，是Java中GC的主要操作空间，是Java进程内的单位
image.png
- 堆外内存：不属于Java直接管理的空间，是不能被GC，所以只能手动申请和释放；属于操作系统直接管理的内存空间，是Java进程外的单位
（2）创建和释放的效率对比？
因为JVM堆中分配和释放内存肯定比系统分配和创建内存高效，所以创建和释放MappedByteBuffer的代价比HeapByteBuffer得要高
（3）IO效率对比?
在回答这个问题之前，首先让我们来看一张图
image.png
在unix和linux的体系架构中，一般会分为用户态和内核态
- 用户态：上层应用程序的活动空间，应用程序的执行必须依托于内核提供的资源。
- 内核态：用于控制计算机的硬件资源，并提供上层应用程序运行的环境。
- 系统调用：为了使上层应用能够访问到这些资源，内核为上层应用提供访问的接口。
而三者之间的关系为：
image.png
从上述的了解中，我们可以得出内核态的效率会大于用户态的效率
而在平时的read/write操作中，应用程序在与I/O设备进行交互时是需要经历一个“内核缓冲区”的。而MappedByteBuffer就好比是“内核缓冲区”上的缓存，而HeapByteBuffer则是应用程序Java中的内存空间，所以结论显而易见，把一个MappedByteBuffer写入一个Channel的速度要比把一个HeapByteBuffer写入一个Channel的速度要快。
这里顺便附上一张性能对比图，详见NIO Buffer performance
image.png