final class Segment {
  //Segment的容量，最大為8kb
  static final int SIZE = 8192;

  //如果Segment中位元組數 > SHARE_MINIMUM時（大Segment），就可以共享，不能添加到SegmentPool
  static final int SHARE_MINIMUM = 1024;
  //存儲的數據
  final byte[] data;

  //下一次讀取的開始位置
  int pos;

 //寫入的開始位置
  int limit;

  //當前Segment是否可以共享
  boolean shared;

  //data是否僅當前Segment獨有，不share
  boolean owner;

  //後繼節點
  Segment next;

  //前驅節點
  Segment prev;

  ...

  //移除當前Segment
  public final @Nullable Segment pop() {
    Segment result = next != this ? next : null;
    prev.next = next;
    next.prev = prev;
    next = null;
    prev = null;
    return result;
  }

  //在當前節點後添加一個新的節點
  public final Segment push(Segment segment) {
    segment.prev = this;
    segment.next = next;
    next.prev = segment;
    next = segment;
    return segment;
  }

  //將當前Segment分裂成2個Segment結點。前面結點pos~limit數據範圍是[pos..pos+byteCount)，後面結點pos~limit數據範圍是[pos+byteCount..limit)
  public final Segment split(int byteCount) {
    if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
    Segment prefix;

    //如果位元組數大於SHARE_MINIMUM則拆分成共享節點
    if (byteCount >= SHARE_MINIMUM) {
      prefix = sharedCopy();
    } 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結點和prev前驅結點合併成一個Segment，統一合併到prev，然後當前Segment結點從雙向鏈表移除並添加到SegmentPool復用。當然合併的前提是：2個Segment的位元組總和不超過8K。合併後可能會移動pos、limit
  public final void compact() {
    if (prev == this) throw new IllegalStateException();
    if (!prev.owner) return; // Cannot compact: prev isn't writable.
    int byteCount = limit - pos;
    int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);
    if (byteCount > availableByteCount) return; // Cannot compact: not enough writable space.
    writeTo(prev, byteCount);
    pop();
    SegmentPool.recycle(this);
  }

  //從當前節點移動byteCount個位元組到sink中
  public final void writeTo(Segment sink, int byteCount) {
    if (!sink.owner) throw new IllegalArgumentException();
    if (sink.limit + byteCount > SIZE) {
      // We can't fit byteCount bytes at the sink's current position. Shift sink first.
      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;
  }
}

final class SegmentPool {
    //SegmentPool的最大容量
    static final long MAX_SIZE = 64 * 1024; // 64 KiB.

    //後繼節點
    static Segment next;

    //當前池內的總位元組數
    static long byteCount;

    private SegmentPool() {
    }
    //從池中獲取一個Segment對象
    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.
    }
    //將Segment狀態初始化並放入池中
    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;
        }
    }
} 

    @Override
    public Buffer write(byte[] source, int offset, int byteCount) {
        if (source == null) throw new IllegalArgumentException("source == null");
        // 檢測參數的合法性
        checkOffsetAndCount(source.length, offset, byteCount);

        // 計算 source 要寫入的最後一個位元組的 index 值
        int limit = offset + byteCount;
        while (offset < limit) {
            // 獲取循環鏈表尾部的一個 Segment
            Segment tail = writableSegment(1);
            // 計算最多可寫入的位元組
            int toCopy = Math.min(limit - offset, Segment.SIZE - tail.limit);
            // 把 source 複製到 data 中
            System.arraycopy(source, offset, tail.data, tail.limit, toCopy);
            // 調整寫入的起始位置
            offset += toCopy;
            // 調整尾部Segment 的 limit 位置
            tail.limit += toCopy;
        }
        // 調整 Buffer 的 size 大小
        size += byteCount;
        return this;
    }

  /**
   * Returns a tail segment that we can write at least {@code minimumCapacity}
   * bytes to, creating it if necessary.
   */
  Segment writableSegment(int minimumCapacity) {
    if (minimumCapacity < 1 || minimumCapacity > Segment.SIZE) throw new IllegalArgumentException();

    // 如果鏈表的頭指針為null，就會SegmentPool中取出一個
    if (head == null) {
      head = SegmentPool.take(); // Acquire a first segment.
      return head.next = head.prev = head;
    }

    // 獲取前驅結點，也就是尾部結點
    Segment tail = head.prev;
    // 如果能寫的位元組數限制超過了8192，或者不是擁有者
    if (tail.limit + minimumCapacity > Segment.SIZE || !tail.owner) {
        // 從SegmentPool中獲取一個Segment，插入到循環雙鏈表當前結點的後面
      tail = tail.push(SegmentPool.take()); // Append a new empty segment to fill up.
    }
    return tail;
  }

    if (head == null) {
      head = SegmentPool.take(); // Acquire a first segment.
      return head.next = head.prev = head;
    }

  @Override 
  public int read(byte[] sink, int offset, int byteCount) {
    checkOffsetAndCount(sink.length, offset, byteCount);
    //取到Segment循環鏈表的表頭
    Segment s = head;
    if (s == null) return -1;
    // 計算最多可寫入的位元組
    int toCopy = Math.min(byteCount, s.limit - s.pos);
    //將數據拷貝到鏈頭的data位元組數組當中
    System.arraycopy(s.data, s.pos, sink, offset, toCopy);
    
    //調整鏈頭的data數組的起始postion和Buffer的size
    s.pos += toCopy;
    size -= toCopy;
    //pos等於limit的時候，從循環鏈表中移除該Segment並從SegmentPool中回收復用
    if (s.pos == s.limit) {
      head = s.pop();//移除的同時返回下一個Segment作為表頭
      SegmentPool.recycle(s);
    }

    return toCopy;
  }

@Override 
public void write(Buffer source, long byteCount) {
    // Move bytes from the head of the source buffer to the tail of this buffer
    // while balancing two conflicting goals: don't waste CPU and don't waste
    // memory.
    //
    //
    // Don't waste CPU (ie. don't copy data around).
    //
    // Copying large amounts of data is expensive. Instead, we prefer to
    // reassign entire segments from one buffer to the other.
    //
    //
    // Don't waste memory.
    //
    // As an invariant, adjacent pairs of segments in a buffer should be at
    // least 50% full, except for the head segment and the tail segment.
    //
    // The head segment cannot maintain the invariant because the application is
    // consuming bytes from this segment, decreasing its level.
    //
    // The tail segment cannot maintain the invariant because the application is
    // producing bytes, which may require new nearly-empty tail segments to be
    // appended.
    //
    //
    // Moving segments between buffers
    //
    // When writing one buffer to another, we prefer to reassign entire segments
    // over copying bytes into their most compact form. Suppose we have a buffer
    // with these segment levels [91%, 61%]. If we append a buffer with a
    // single [72%] segment, that yields [91%, 61%, 72%]. No bytes are copied.
    //
    // Or suppose we have a buffer with these segment levels: [100%, 2%], and we
    // want to append it to a buffer with these segment levels [99%, 3%]. This
    // operation will yield the following segments: [100%, 2%, 99%, 3%]. That
    // is, we do not spend time copying bytes around to achieve more efficient
    // memory use like [100%, 100%, 4%].
    //
    // When combining buffers, we will compact adjacent buffers when their
    // combined level doesn't exceed 100%. For example, when we start with
    // [100%, 40%] and append [30%, 80%], the result is [100%, 70%, 80%].
    //
    //
    // Splitting segments
    //
    // Occasionally we write only part of a source buffer to a sink buffer. For
    // example, given a sink [51%, 91%], we may want to write the first 30% of
    // a source [92%, 82%] to it. To simplify, we first transform the source to
    // an equivalent buffer [30%, 62%, 82%] and then move the head segment,
    // yielding sink [51%, 91%, 30%] and source [62%, 82%].

    if (source == null) throw new IllegalArgumentException("source == null");
    if (source == this) throw new IllegalArgumentException("source == this");
    checkOffsetAndCount(source.size, 0, byteCount);

    while (byteCount > 0) {
      // Is a prefix of the source's head segment all that we need to move?
     // 如果 Source Buffer 的頭結點可用位元組數大於要寫出的位元組數
      if (byteCount < (source.head.limit - source.head.pos)) {
        //取到當前buffer的尾節點
        Segment tail = head != null ? head.prev : null;
        // 如果尾部結點有足夠空間可以寫數據，並且這個結點是底層數組的擁有者
        if (tail != null && tail.owner
            && (byteCount + tail.limit - (tail.shared ? 0 : tail.pos) <= Segment.SIZE)) {
          // Our existing segments are sufficient. Move bytes from source's head to our tail.
          //source頭結點的數據寫入到當前尾節點中，然後就直接結束返回了
          source.head.writeTo(tail, (int) byteCount);
          source.size -= byteCount;
          size += byteCount;
          return;
        } else {
          // We're going to need another segment. Split the source's head
          // segment in two, then move the first of those two to this buffer.
          //如果尾節點空間不足或者不是持有者，這時就需要把 Source Buffer 的頭結點分割為兩個 Segment，
          //然後將source的頭指針更新為分割後的第一個Segment, 如[92%, 82%]變成[30%, 62%, 82%]這樣
          source.head = source.head.split((int) byteCount);
        }
      }

      // Remove the source's head segment and append it to our tail.
      //從 Source Buffer 的鏈表中移除頭結點, 並加入到當前Buffer的鏈尾
      Segment segmentToMove = source.head;
      long movedByteCount = segmentToMove.limit - segmentToMove.pos;
      //移除操作，並移動更新source中的head
      source.head = segmentToMove.pop();
       // 如果當前buffer的頭結點為 null，則頭結點直接指向source的頭結點，初始化雙向鏈表
      if (head == null) {
        head = segmentToMove;
        head.next = head.prev = head;
      } else {
        //否則就把Source Buffer的 head 加入到當前Buffer的鏈尾
        Segment tail = head.prev;
        tail = tail.push(segmentToMove);//壓入鏈尾，並更新尾節點
        tail.compact();//尾節點嘗試合併，如果合併成功，則尾節點會被SegmentPool回收掉
      }
      source.size -= movedByteCount;
      size += movedByteCount;
      byteCount -= movedByteCount;
    }
  }

public final class Pipe {
  //Pipe的最大容量
  final long maxBufferSize;
  //Pipe對應的Buffer
  final Buffer buffer = new Buffer();
  boolean sinkClosed;
  boolean sourceClosed;
  //寫入流，對應著生產者
  private final Sink sink = new PipeSink();
  //讀取流，對應著消費者
  private final Source source = new PipeSource();

  public Pipe(long maxBufferSize) {
    //最大容量不能小於1
    if (maxBufferSize < 1L) {
      throw new IllegalArgumentException("maxBufferSize < 1: " + maxBufferSize);
    }
    this.maxBufferSize = maxBufferSize;
  }
  ...
  //寫入數據到Pipe中
  final class PipeSink implements Sink {
    final Timeout timeout = new Timeout();

    @Override public void write(Buffer source, long byteCount) throws IOException {
      synchronized (buffer) {
        ...

        while (byteCount > 0) {
          ...

          long bufferSpaceAvailable = maxBufferSize - buffer.size();
          if (bufferSpaceAvailable == 0) {
            //buffer中，沒有剩餘空間，等待消費者消費
            timeout.waitUntilNotified(buffer); // Wait until the source drains the buffer.
            continue;
          }

          long bytesToWrite = Math.min(bufferSpaceAvailable, byteCount);
　　　　　　// 將數據寫入到 buffer的 data 中
          buffer.write(source, bytesToWrite);
          // 還需要寫多少數據
          byteCount -= bytesToWrite;
          //通知buffer，有新的數據了，
          buffer.notifyAll(); // Notify the source that it can resume reading.
        }
      }
    }

    ...
  }
  //從 Pipe 中讀取數據
  final class PipeSource implements Source {
    final Timeout timeout = new Timeout();

    @Override public long read(Buffer sink, long byteCount) throws IOException {
      synchronized (buffer) {
        ...

        while (buffer.size() == 0) {
          if (sinkClosed) return -1L;
          //Pipe中沒有數據，等待生產者寫入
          timeout.waitUntilNotified(buffer); // Wait until the sink fills the buffer.
        }

        long result = buffer.read(sink, byteCount);
        buffer.notifyAll(); // Notify the sink that it can resume writing.
        return result;
      }
    }
    ...
  }
}

    public void pipe() throws IOException {
        //設置 Pipe 的容量為1024位元組，即 1kb
        Pipe pipe = new Pipe(1024);
        new Thread(new Runnable() {
            @Override
            public void run() {
　　　　　　　　　　//1 pipe.source 會從 pipe 的 buffer 中讀取數據
                try (BufferedSource bufferedSource = Okio.buffer(pipe.source())) {
                    //2 將Pipe中數據寫入env4.txt這個文件中,；
                    bufferedSource.readAll(Okio.sink(new File("file/env4.txt")));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
　　　　　　　　　　//3 pipe.sink 會將數據寫入到 pipe 的 buffer 中
                try (BufferedSink bufferedSink = Okio.buffer(pipe.sink())) {
                    //4 將env3.txt中數據寫入到Pipe中;
                    bufferedSink.writeAll(Okio.source(new File("file/env3.txt")));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }