segment中文意思是段，部分，在这里是缓存数据存放的地方，数据就存放在一个一个的segment中，一个segment最大可存储8192个字节。所有的segment以双向循环链表的数据结构组织在一起。
Segment类的成员变量
SIZE=8192； 一个segment可存储的最大字节数
SHARE_MINIMUM=1024； segment可被共享应含有的最小字节数（共享是为了不执行拷贝操作）
byte[] data; 存放数据的字节数组
int pos；下一个可读的字节的位置
int limit；下一个可写的字节的位置
boolean shared；标识该segment是否是共享的
boolean owner; 标识该segment是否是字节数组的所有者（所有者可以修改，不是所有者是只读权限）
Segment next; 链表中当前segment的下一个Segment
Segment prev;链表中当前segment的上一个Segment
Segment提供了从链表中删除，插入以及相邻segment的组合，一个segment拆分成两个segment的操作。
Segment.pop()
从链表中删除自身。
prev ↔ 当前segment ↔ next -----> prev ↔ next
当前segment需要pop，那么当前segment 的next结点的prev指针就需要指向当前segment的prev结点，当前segment的prev元素的next指针就需要指向当前segment的next结点。
public final @Nullable Segment pop() {
Segment result = next != this ? next : null;
prev.next = next;
next.prev = prev;
next = null;
prev = null;
return result;
}
Segment.push(Segment)
将参数知道的segment插入到当前segment的后面
当前segment ↔ next -----> 当前segment ↔插入的segment ↔ next
插入的segment的prev指针指向当前segment，插入的segment的next指针指向当前segment的next指针，当前segment的next结点的prev指针指向插入的segment，当前segment的next指针指向插入的segment。
public final Segment push(Segment segment) {
segment.prev = this;
segment.next = next;
next.prev = segment;
next = segment;
return segment;
}
Segment.split(int byteCount)
将一个segment拆分成两个segment，参数指定拆分后第一个segemnt含有的未读字节数。所以第一个segment包含的数据范围[pos,pos+ byteCount),第二个segment包含的数据范围[pos+byteCount,limit)。
拆分时，当byteCount大于1024时使用共享segment，否则执行拷贝。这是出于两方面考虑，一是避免拷贝数据，所以使用共享的segment；二是避免过短的共享segment，以免链表中含有太多过短的segement。为了平衡两者，规定共享的segment长度需要大于1024。
public final Segment split(int byteCount) {
//参数检查，byteCount必须大于0，并且byteCount不能大于可读数据长度
if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
Segment prefix;
//当byteCount大于1024时使用共享segment，否则执行拷贝
if (byteCount >= SHARE_MINIMUM) {
prefix = sharedCopy();//①
} else {
//从segment池中取出一个segment
prefix = SegmentPool.take();//②
System.arraycopy(data, pos, prefix.data, 0, byteCount);
}
prefix.limit = prefix.pos + byteCount;//设置prefix的limit指针（下一个可写的位置）
pos += byteCount;//设置当前segment的可读指针位置
prev.push(prefix);//将prefix segment插入segment链表
return prefix;
}
① sharedCopy()
final Segment sharedCopy() {
shared = true;//当前为分享模式
//创建一个分享的segment
return new Segment(data, pos, limit, true, false);
}
//Segment构造函数
Segment(byte[] data, int pos, int limit, boolean shared, boolean owner) {
this.data = data;
this.pos = pos;
this.limit = limit;
this.shared = shared;
this.owner = owner;
}
② SegmentPool.take()
SegmentPool是未使用segment的集合，采用单向链表组织在一起。只有两个方法 take 和recycle。
/**
* 取出一个可用的segment
*/
static Segment take() {
synchronized (SegmentPool.class) {
//next指向下一个可用的segment
if (next != null) {
Segment result = next;
next = result.next;//next指针指向next的下一个结点
result.next = null; //返回的segment的next指针置为null
byteCount -= Segment.SIZE;
return result;
}
}
//池中一个可用的segment都没有，new 一个返回
return new Segment();
}
/**
*回收一个segment
*/
static void recycle(Segment segment) {
//还在segment链中的segment不能回收
if (segment.next != null || segment.prev != null) throw new IllegalArgumentException();
if (segment.shared) return; //分享的segment不能回收
synchronized (SegmentPool.class) {
if (byteCount + Segment.SIZE > MAX_SIZE) return; //加入后超过池子大小的不能回收
byteCount += Segment.SIZE;
//将segment加入单链表头部
segment.next = next;
segment.pos = segment.limit = 0;//重置读写指针
next = segment;
}
}
Segment.compact()
将当前segment合并到前面一个segment。
首先计算当前segment可读字节数，然后计算前面一个segment可写的字节数，这里分两种情况，1，前面一个segment是共享的，则剩余可写的字节数=SIZE-prev.limit；2前面一个segment不是共享的，那么其实pos前面的数据已经是已读的，可以重新写入，那么剩余可写的字节数=SIZE-prev.limit+prev.pos。比较当前segment可读字节数与前面一个剩余可写字节数大小，如果前者大于后者，则不可写入，否则就写入。
public final void compact() {
if (prev == this) throw new IllegalStateException();
if (!prev.owner) return; // Cannot compact: prev isn't writable.
//当前segment可读字节数
int byteCount = limit - pos;
//前面一个segment可写字节数（注意：已读的字节部分是可以重新写的，这就是加上prev.pos的原因）
int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);
if (byteCount > availableByteCount) return;
writeTo(prev, byteCount);
//当前segment从链表移除
pop();
//回收到segmentpool
SegmentPool.recycle(this);
}
//将当前segment的未读数据长度是byteCount写到参数sink表示的segment中
public final void writeTo(Segment sink, int byteCount) {
if (!sink.owner) throw new IllegalArgumentException();
if (sink.limit + byteCount > SIZE) {
// 需要先将sink中已经读过的数据移走
if (sink.shared) throw new IllegalArgumentException();
if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException();
System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos);
sink.limit -= sink.pos;
sink.pos = 0;
}
System.arraycopy(data, pos, sink.data, sink.limit, byteCount);
sink.limit += byteCount;
pos += byteCount;
}
