okio解析

使用okhttp的时候，看过源码会知道，里面是使用了okio对流进行处理，那么okio到底是什么？
okio 同样也是square公司推出的io处理利器，它相对传统的io操作有一些优势。

优势

1、更低的CPU消耗和内存开销。okio内部使用了segment（片）来存放数据，segment里面放的也是byte[]，但在外面有一个segmentPool来对segment进行回收复用。避免了频繁创建segment而导致的内存开销。
2、使用更简单。传统的io流，采用了装饰模式的思想。装饰模式可以增强类的功能，而不通过继承的方式。如果需要读取一个整形数据，我们会使用DataInputStream进行包装，或者如果我们需要用到缓存，会用到BufferInputStream。但okio不需要这么麻烦，okio的Buffer已经提供了一系列的方法，比如readInt(),readUtf8()等等。
3、okio中的Timeout提供了超时的处理。

实例分析

okio中最重要的两个接口分别是Sink和Source
Source：这个接口相当于InputStream，是用来读数据。数据来源可以是磁盘、网络、内存等
Sink：这个接口相当于OutputStream,是用于往外写数据。
InputStream和OutputStream可以以内存为参照物，加载到内存的输入流、而从内存中输出到别的地方，称为输出流
从一个最简单的例子入手去了解okio的内部逻辑

        File file=new File("/mnt/sdcard/需求.txt");
        InputStream in=new FileInputStream(file);
        BufferedSource source = Okio.buffer(Okio.source(in));  //创建BufferedSource
        String s = source.readUtf8();  //以UTF-8读
        System.out.println(s);     //打印

        BufferedSink sink=Okio.buffer(Okio.sink(new File("/mnt/sdcard/需求copy.txt")));
        sink.writeUtf8(s);
        source.close();
        sink.close();

这个例子是从设备磁盘中读取txt文件的内容 并打印出来。再将内容写到另一个txt文件中。
按顺序先看一下Okio.source(in)方法

  public static Source source(InputStream in) {
    return source(in, new Timeout());
  }
  private static Source source(final InputStream in, final Timeout timeout) {
    if (in == null) throw new IllegalArgumentException("in == null");
    if (timeout == null) throw new IllegalArgumentException("timeout == null");

    return new Source() {
      @Override public long read(Buffer sink, long byteCount) throws IOException {
        if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
        if (byteCount == 0) return 0;
        try {
          /检查读取是否超时 如果超时了直接抛出异常
          timeout.throwIfReached(); 
          //获取一个可写的segment
          Segment tail = sink.writableSegment(1);
          int maxToCopy = (int) Math.min(byteCount, Segment.SIZE - tail.limit);
          int bytesRead = in.read(tail.data, tail.limit, maxToCopy);
          if (bytesRead == -1) return -1;
          tail.limit += bytesRead;
          sink.size += bytesRead;
          return bytesRead;
        } catch (AssertionError e) {
          if (isAndroidGetsocknameError(e)) throw new IOException(e);
          throw e;
        }
      }

      @Override public void close() throws IOException {
        in.close();
      }

      @Override public Timeout timeout() {
        return timeout;
      }

      @Override public String toString() {
        return "source(" + in + ")";
      }
    };
  }

这个方法其实是构建了一个Source的实例对象，并实现了read函数，内部通过Buffer对象sink的writableSegment函数返回一个可写的segment，并调用inputStream的read函数，将数据写入到segment中。那么这个sink是从哪里来的，我们接着往下分析。

Okio.buffer(Okio.source(in));

进到Okio的 buffer(Source source)函数

  public static BufferedSource buffer(Source source) {
    return new RealBufferedSource(source);
  }

这个方法返回一个RealBufferedSource对象，RealBufferedSource类实现了BufferedSource接口，而BufferedSource又实现了Source接口。RealBufferedSource内部又有一个Source对象和一个Buffer对象。这里其实有点装饰模式的味道了，通过RealBufferedSource增强了read方法。

image.png

现在我们已经做好准备工作了，已经有了一个RealBufferSource对象了，接下来就是调用该对象的readxxx（）方法了，我们这里用的是readUtf8（），具体看一下。

  @Override public String readUtf8() throws IOException {
    buffer.writeAll(source);
    return buffer.readUtf8();
  }

首先先看Buffer的writeAll方法

  @Override public long writeAll(Source source) throws IOException {
    if (source == null) throw new IllegalArgumentException("source == null");
    long totalBytesRead = 0;
    for (long readCount; (readCount = source.read(this, Segment.SIZE)) != -1; ) {
      totalBytesRead += readCount;
    }
    return totalBytesRead;
  }

重点看一下for循环里面的代码，其中的source对象就是前面构造出来的那个对象，不断调用它的read方法，将数据写入当前Buffer中。从前面的代码分析中可以知道，实际上，buffer对象通过调用writableSegment函数返回一个segment，将数据写到这个segment中。

Segment和Buffer

那么segment到底是什么，Buffer对象又是什么，之间有什么联系？

okiopng.png

okio使用segment来存储流数据，segment之间是双向链表的数据结构，buffer对象持有该链表的表头 head，通过head 可以快速定位到其它segment。Segment内部使用了byte[]数组，整体采用了链表和数组结合的模式，可以说在数据查找和修改移除做了相对平衡的选择。

注意:Segment中的split方法，从字面上了解是将一个segment对象 一分为二，用链表再串起来。但每个segment引用的是同一个byte[]，只不过是在数组上的不同区域，即不同的pos和limit。所以这个时候需要区分该segment是属于owner还是share，这两者互斥。如果是share，那对该segment处理便有很多限制，因为会影响其它引用同一个byte[]的segment。

回到例子中，在将数据读到buffer中后，调用了readUtf8方法，将字节流转换utf8字符串。

  @Override public String readString(long byteCount, Charset charset) throws EOFException {
    checkOffsetAndCount(size, 0, byteCount);
    if (charset == null) throw new IllegalArgumentException("charset == null");
    if (byteCount > Integer.MAX_VALUE) {
      throw new IllegalArgumentException("byteCount > Integer.MAX_VALUE: " + byteCount);
    }
    if (byteCount == 0) return "";

    Segment s = head;
    if (s.pos + byteCount > s.limit) {
      // If the string spans multiple segments, delegate to readBytes().
      return new String(readByteArray(byteCount), charset);
    }

    String result = new String(s.data, s.pos, (int) byteCount, charset);
    s.pos += byteCount;
    size -= byteCount;

    if (s.pos == s.limit) {
      head = s.pop();
      SegmentPool.recycle(s);
    }

    return result;
  }

将数据读出来 通过newString处理。