BufferedSource

final class RealBufferedSource implements BufferedSource {
  public final Buffer buffer = new Buffer();
  public final Source source;
  boolean closed;

    //....
    @Override public long read(Buffer sink, long byteCount) throws IOException {
    if (sink == null) throw new IllegalArgumentException("sink == null");
    if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
    if (closed) throw new IllegalStateException("closed");

    //先将数据读到buffer中
    if (buffer.size == 0) {
       //source是被装饰的对象
      long read = source.read(buffer, Segment.SIZE);
      if (read == -1) return -1;
    }

    long toRead = Math.min(byteCount, buffer.size);
    return buffer.read(sink, toRead);
  }
  //...
}

小结一下：
Source对象每次read，Sink对象每次write都需要一个Buffer对象，Buffer管理者循环双向链表Segment，每次读写数据都先保存在segment中进行缓冲，BufferedSource和BufferedSink进行读写操作时都是间接调用Buffer对Segment的操作来完成的，整个过程层层嵌套还是有点绕的。
InputStream--Source--BufferedSource--Buffer--segment--Buffer--Sink--BufferedSink--OutputStream

为什么Okio更高效

在buffer的注释中说明了Okio的高效性：

1. 采用了segment的机制进行内存共享和复用，避免了copy数组；
2. 根据需要动态分配内存大小；
3. 避免了数组创建时的zero-fill，同时降低GC的频率。

Segment和SegmentPool:
Segment是一个循环双向列表，内部维护者固定长度的byte[]数组：

  static final int SIZE = 8192;
  /** Segments 用分享的方式避免复制数组 */
  static final int SHARE_MINIMUM = 1024;
  final byte[] data;
  /** data[]中第一个可读的位置*/
  int pos;
  /** data[]中第一个可写的位置 */
  int limit;
  /**与其它Segment共享  */
  boolean shared;
  boolean owner;

  Segment next;
  Segment prev;
  /**
   * 将当前segment从链表中移除
   */
  public Segment pop() {
     //....
  }
  /**
   * 将一个segment插入到当前segment后
   */
  public Segment push(Segment segment) {
    //....
  }

SegmentPool是一个Segment池，由一个单向链表构成。该池负责Segment的回收和闲置Segment的管理，也就是说Buffer使用的Segment是从Segment单向链表中取出的，这样有效的避免了GC频率。

  /** 总容量 */
  static final long MAX_SIZE = 64 * 1024; // 64 KiB.

  /**用Segment实现的单向链表,next是表头*/
  static Segment next;

  /** Total bytes in this pool. */
  static long byteCount;
  
  
  //回收闲置的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;
    }
  }
  //从链表头部取出一个
    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中还有两个特殊的方法split()和compact()，split()根据当前的Segment产生一个新的Segment，新的Segment与原来的Segment共用同一个data[]数组，但是改变了读写的标记位pos和limit，从原来的
[pos..limit]拆分为[pos..pos+byteCount]和[pos+byteCount..limit]，从而避免了复制数组带来的性能消耗。前一个和自身的数据量都不足一半时，compact()会对segement进行压缩，把自身的数据写入到前一Segment中，然后将自身进行回收，使Segment的利用更高效！

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

Okio实战

Okio封装了io操作底层操纵字节的细节，使用起来更简单了。但一般来说高度的封装意味着无法定制，比如说在网络应用中经常要监听文件的上传下载进度，显然Okio默认是没有这个功能的，应该怎么扩展呢？别忘了，装饰者模式。实际上Okio已经提供了Decorator类：ForwardingSink，ForwardingSource，只要继承这两个类就可以自己定制功能了。

class CountingSink extends ForwardingSink{
        private long bytesWritten = 0;
        private Listen listen;
        private File file;
        private long totalLength;
        public CountingSink(Sink delegate,File file,Listen listen) {
            super(delegate);
            this.listen = listen;
            this.file = file;
            totalLength = contentLength();
        }
        public long contentLength(){
            if (file != null) {
                long length = file.length();
                Log.d("abc : length :", length + "");
                return length;
            }else {
                return 0;
            }

        }

        @Override
        public void write(Buffer source, long byteCount) throws IOException {
            super.write(source, byteCount);
            bytesWritten += byteCount;
            listen.onProgress(bytesWritten, totalLength);
        }

        interface Listen{
            void onProgress(long bytesWritten, long contentLength);
        }
    }

我们复制一首歌做测试：

 File fileSrc = new File(Environment.getExternalStorageDirectory() + "/000szh", "pain.mp3");
 File fileCopy = new File(Environment.getExternalStorageDirectory() + "/000szh","pain3.mp3");

      CountingSink.Listen listen = new CountingSink.Listen() {
            @Override
            public void onProgress(long bytesWritten, long contentLength) {
                long total = contentLength;
                float pos = bytesWritten *1.0f / total;
            }
        };
        BufferedSink bufferedSink = null;
        Source source = null;
        try {
            //包装sink
            Sink sink= Okio.sink(fileCopy);
            CountingSink countingSink = new CountingSink(sink, fileSrc,listen);
            bufferedSink = Okio.buffer(countingSink);
            source = Okio.source(fileSrc);
            bufferedSink.writeAll(source);
            bufferedSink.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                closeAll(bufferedSink, source);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }