• Sink定义了四个方法write(Buffer source, long byteCount), flush(), close(), and timeout()；
• Source定义了三个方法long read(Buffer sink, long byteCount), close(), and timeout()；

• BufferedSink定义了writeUtf8、writeString、writeByte、writeShort、 writeInt、writeLong等常用方法；
• BufferedSource定义了readByte()、readShort()、readInt()、readLong()、readUtf8()等常用方法；

static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; //很明显这个肯定是在进行hex解析的时候被使用到
final byte[] data;
transient int hashCode; //说是String远方亲戚也不假，String也有类似上面的两个域
transient String utf8; //这个域的存在就是实现了对utf-8解码的优化，是一个对utf8解码String的优化

ByteString(byte[] data) {
    this.data = data; 
}

public static ByteString of(byte... data) {
    if (data == null) throw new IllegalArgumentException("data == null");
    return new ByteString(data.clone());//note1
}
public static ByteString of(byte[] data, int offset, int byteCount) {
    if (data == null) throw new IllegalArgumentException("data == null");
    checkOffsetAndCount(data.length, offset, byteCount);//note2
    byte[] copy = new byte[byteCount];
    System.arraycopy(data, offset, copy, 0, byteCount);//note3
    return new ByteString(copy);
}

public String toString() {
    if (data.length == 0) {
      return "ByteString[size=0]";
    }
    if (data.length <= 16) {
      return String.format("ByteString[size=%s data=%s]", data.length, hex());
    }
    return String.format("ByteString[size=%s md5=%s]", data.length, md5().hex());
}

public String utf8() {
    String result = utf8;
    return result != null ? result : (utf8 = new String(data, Util.UTF_8));
}

public Segment push(Segment segment) {
    segment.prev = this;
    segment.next = next;
    next.prev = segment;
    next = segment;
    return segment;
  }

public Segment split(int byteCount) {
    if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
    Segment prefix = new Segment(this);
    prefix.limit = prefix.pos + byteCount;
    pos += byteCount;
    prev.push(prefix);
    return prefix;
  }

public void compact() {
    if (prev == this) throw new IllegalStateException();
    if (!prev.owner) return; //note1
    int byteCount = limit - pos; //note2
    int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos); //note3
    if (byteCount > availableByteCount) return; //note4
    writeTo(prev, byteCount); //note5
    pop(); //note6
    SegmentPool.recycle(this); //note7
  }

public void writeTo(Segment sink, int byteCount) {
    if (!sink.owner) throw new IllegalArgumentException(); //note1
    if (sink.limit + byteCount > SIZE) { //note2
      if (sink.shared) throw new IllegalArgumentException(); //note3
      if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException(); //note4
      System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos); //note5
      sink.limit -= sink.pos;
      sink.pos = 0;
    }
    System.arraycopy(data, pos, sink.data, sink.limit, byteCount);//note6
    sink.limit += byteCount;
    pos += byteCount;
}

static final long MAX_SIZE = 64 * 1024; // 大家是否还记得一个Segment记录的数据最大长度为2048？因此该Segment相当于能存储32个Segment对象。不过为何不是32*2048？
static Segment next; //该SegmentPool存储了一个回收Segment的链表
static long byteCount; //该值记录当前存储的所有Segment总大小，最大值为MAX_SIZE

static Segment take() {
    synchronized (SegmentPool.class) {
      if (next != null) {
        Segment result = next;
        next = result.next;
        result.next = null;
        byteCount -= Segment.SIZE;
        return result;
      }
    }
    return new Segment(); // Pool is empty. Don't zero-fill while holding a lock.
}

static void recycle(Segment segment) {
    if (segment.next != null || segment.prev != null) throw new IllegalArgumentException();
    if (segment.shared) return; // This segment cannot be recycled.
    synchronized (SegmentPool.class) {
      if (byteCount + Segment.SIZE > MAX_SIZE) return; // Pool is full.
      byteCount += Segment.SIZE;
      segment.next = next;
      segment.pos = segment.limit = 0;
      next = segment;
    }
  }

public int readInt() {
    if (size < 4) throw new IllegalStateException("size < 4: " + size); //note1
    Segment segment = head;
    int pos = segment.pos;
    int limit = segment.limit;
    //note2
    if (limit - pos < 4) {
      return (readByte() & 0xff) << 24
          |  (readByte() & 0xff) << 16
          |  (readByte() & 0xff) <<  8
          |  (readByte() & 0xff);
    }
   //note3
    byte[] data = segment.data;
    int i = (data[pos++] & 0xff) << 24
        |   (data[pos++] & 0xff) << 16
        |   (data[pos++] & 0xff) <<  8
        |   (data[pos++] & 0xff);
    size -= 4;
    if (pos == limit) { //note4
      head = segment.pop();
      SegmentPool.recycle(segment);
    } else {
      segment.pos = pos;
    }
    return i; //note5
  }

public byte readByte() {
    if (size == 0) throw new IllegalStateException("size == 0");
    Segment segment = head;
    int pos = segment.pos;
    int limit = segment.limit;
    byte[] data = segment.data;
    byte b = data[pos++]; //note1
    size -= 1;
    if (pos == limit) { //note2
      head = segment.pop();
      SegmentPool.recycle(segment);
    } else {
      segment.pos = pos;
    }
    return b; //note3
  }