简介
先看看源码中该类的简介：
/**
* A segment of a buffer.
*
* <p>Each segment in a buffer is a circularly-linked list node referencing
* the following and preceding segments in the buffer.
*
* <p>Each segment in the pool is a singly-linked list node referencing the rest of
* segments in the pool.
*
* <p>The underlying byte arrays of segments may be shared between buffers and byte strings. When a
* segment's byte array is shared the segment may not be recycled, nor may its byte data be changed.
* The lone exception is that the owner segment is allowed to append to the segment, writing data at
* {@code limit} and beyond. There is a single owning segment for each byte array. Positions,
* limits, prev, and next references are not shared.
*/
大概意思是：
1.缓冲区的组成单位结构
2.每一个Segment是一个双向循环链表，每一个节点都指向了同一个buffer中的他的前后各一个节点。双向循环链表如图（来自网络）：
3.池中的每个Segment都是一个引用池中其余Segment的单链表列表节点
4.Segment底层的byte数组可以在Buffer和ByteString间共享， 当一个Segment的字节数组被共享时，这个Segment可能不会被回收，其字节数据也不会被改变。 唯一的例外是，该Segment允许附加到Segment上，写入数据可以突破原有的limit。 每个字节数组都有一个单独的拥有Segment。 position，limit，pre和next引用是不被共享的。
变量
/** 每一个Segment的字节数 */
static final int SIZE = 8192;
/** Segment被分享的最小字节数 */
static final int SHARE_MINIMUM = 1024;
final byte[] data;
/** 当前Segment的下一个可读数据的索引 */
int pos;
/** 当前Segment的第一个可写数据的索引 */
int limit;
/** True表示其他Segment或.byteString共享同一个byte array*/
boolean shared;
/** 是否为独享数据。Segment拥有自己的byte array并且可以进行追加 */
boolean owner;
//处于Buffer中由Segment组成的双向循环列表中的next和prev
/** 当前结点的下一个节点 */
Segment next;
/** 当前结点的上一个节点 */
Segment prev;
方法
Segment的主要方法：
1.pop() 移除操作
/**
* Removes this segment of a circularly-linked list and returns its successor.
* Returns null if the list is now empty.
*/
public Segment pop() {
Segment result = next != this ? next : null;
prev.next = next;
next.prev = prev;
next = null;
prev = null;
return result;
}
如图所示：
假设删除的Segment为Segment2，即我们就要断掉Segment2的前后链接，即断掉1-2，2-1，2-3，3-2，如果就这样断掉的话，整条链就断了，不能维持原来的链表结构，所以在断掉的同时，还得将Segment1和Segment3连接起来。故而pop()操作是这样的：
prev.next = next; //Segment3变成Segment1.next，即线1-3
next.prev = prev; //Segment1变成Segment3.pre，即线3-1：
next = null;
prev = null; 断掉2-1和2-3，删除Segment2:
2.push(Segment segment) 添加
/**
* Appends {@code segment} after this segment in the circularly-linked list.
* Returns the pushed segment.
*/
public Segment push(Segment segment) {
segment.prev = this;
segment.next = next;
next.prev = segment;
next = segment;
return segment;
}
同样的道理，只要把握住要节点间的pre与next的位置即可。
3.Segment split(int byteCount)
public Segment split(int byteCount) {
if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
Segment prefix;
// We have two competing performance goals:
// - Avoid copying data. We accomplish this by sharing segments.
// - Avoid short shared segments. These are bad for performance because they are readonly and
// may lead to long chains of short segments.
// To balance these goals we only share segments when the copy will be large.
if (byteCount >= SHARE_MINIMUM) {
prefix = new Segment(this);
} else {
prefix = SegmentPool.take();
System.arraycopy(data, pos, prefix.data, 0, byteCount);
}
prefix.limit = prefix.pos + byteCount;
pos += byteCount;
prev.push(prefix);
return prefix;
}
大概意思就是就该Segment链表分割成两个双向循环链表，第一个的元素是从pos-pos+byteCount，第二个是pos+byteCount-limit，返回第一个Segment的头结点。
writeTo(Segment sink, int byteCount)
public void writeTo(Segment sink, int byteCount) {
//若目标Segment不能进行追加操作则报异常
if (!sink.owner) throw new IllegalArgumentException();
if (sink.limit + byteCount > SIZE) {
// 若目标Segment是共享的，为避免污染数据，抛异常
if (sink.shared)
throw new IllegalArgumentException();
//若目标Segment从head位置到pos位置都不足以容纳byteCount个字节，抛异常
if (sink.limit + byteCount - sink.pos > SIZE)
throw new IllegalArgumentException();
//将sink.data数组中从sink.pos位置开始的sink.limit - sink.pos个字节复制到sink.data数组，复制位置从0开始
//也就是把整个 sink.data字节数组重复利用
System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos);
//改变limit和pos的值
sink.limit -= sink.pos;
sink.pos = 0;
}
System.arraycopy(data, pos, sink.data, sink.limit, byteCount);
sink.limit += byteCount;
//pos表示的是this.pos，读完byteCount个数据之后，this的pos位置自然到了pos + byteCount
pos += byteCount;
}
compat() Segment的压缩操作
public void compact() {
//Segment仅仅有一个Head()时调用抛异常
if (prev == this) throw new IllegalStateException();
//prev不可写
if (!prev.owner) return; // Cannot compact: prev isn't writable.
//计算占用空间大小
int byteCount = limit - pos;
//prev的剩余空间大小（SIZE-prev.limit表示limit到SIZE的剩余空间，
prev.shared为true表示所用空间为共享空间，不能进行操作
+prev.pos表示0-pos的剩余空间）
int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);
//若所用空间大于剩余空间，没有足够的空间进行压缩，直接返回
if (byteCount > availableByteCount) return; // Cannot compact: not enough writable space.
//否则调用writeTo（prev, byteCount）方法将当前Segment的数据写入到this.prev的data数组中，
//然后调用pop销毁自身，进行回收
writeTo(prev, byteCount);
pop();
SegmentPool.recycle(this);
}
正如注释所言，compat()使用Segment的空间得到最大程度上的使用，及时进行内存释放优化，避免空间碎片化，利用SegmentPool对Segment进行回收利用，大大地提升了应用的性能。
总结
Segment是数据缓冲区Buffer的基本存储单位，以双向循环链表的形式存在再Buffer中。每一个Buffer自身又存在着一个byte[]数组用来存放数据。通过pop()操作取数据，push()操作添加数据，再通过compat()进行数据压缩，更进一步利用xxxpool思想对Segment进行回收利用，很大程度上进行了优化。
