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;
  }