使用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方法。
现在我们已经做好准备工作了，已经有了一个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对象又是什么，之间有什么联系？
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处理。