Okhttp源码解析(四)——Okio解析
参考：https://www.jianshu.com/p/f5941bcf3a2d
1.什么是OKIO
将JDK封装的IO操作再进行一层封装
好处：
（1）使用了segement片段管理的方式管理数据，以片段作为IO操作的单位，使IO操作吞吐率增加
(2）使用链表将Segment片段联系起来管理，对于移动指针就可以对数据进行管理，扩容方便
（3）使用SegmentPool对废弃的片段回收、复用和内存共享，从而减少内存的申请和减少了GC的频率，性能得到优化。
（4）封装了输出输入的超时处理，着在JDK原生io操作中没有
（5）具备了很多从字节到特定编码格式或者数据类型的转化方法，很方便
2.OKIO的简单使用
OKIO写流程图：
public static void main(String[] args) {
File file = new File("hello.txt");
try {
readString(new FileInputStream(file));
} catch (IOException e) {
e.printStackTrace();
}
}
public static void readString(InputStream in) throws IOException {
BufferedSource source = Okio.buffer(Okio.source(in)); //创建RealBufferedSource输入流
String s = source.readUtf8(); //以UTF-8读，就是通过执行回调（Okio.source(in)的read方法）往Buffer中写source输入流的数据，再返回Buffer存储size的全部字节
System.out.println(s);
source.close();
}
public static void writeString(OutputStream out){
BufferedSink sink = Okio.buffer(Okio.sink(out));
//创建RealBufferedSink输出流
sink.writeLone("test");//里面往Buffer里面写“test”,再通过执行回调（Okio.sink(out)的write方法）将Buffer里面的数据写到输出流sink里
sink.close();
}
3.okio架构
Souce、Sink接口：
两接口分别定义了read()和wriete()，代表着输入流和输出流，
BufferedSource、BufferedSink接口：
分别继承了Source和Sink，维护者Buffer，分别定义了一堆针对各种类型的读和写操作方法。
RealBufferedSource、RealBufferedSink：
相当于一个操作的中介代理，内部都维护着一个Buffer，分别定义了进行具体操作。
Segment:
存储最大长度为8K字节数组，该数组为不可变字节序列，pos代表开始可以读的字节序号，limit代表可以写的字节序号，boolean shared代表该片段是否共享，boolean owner代表自己是否可以操作本片段（与shared互斥），通过per、next形成链表（Buffer构建出双向链表），方法当然有push()、pop()
压缩机制：
由于存储的结果就是Head-new1-new2-new3-这样子，新建new的前提仅仅是上一片段（例如new3）的limit到Segment_size_max小于要存储的字节数，如果很长时间会有一个segment只存了小部分数据，但是有很多segment，造成内存浪费。因此需要压缩方法compact()，具体做法：先将上一片段的数据从pos往前移，使pos从序号0开始，然后将本片段的数据写到上一片段上，从limit开始，然后将本片段抛出。
public void compact() {
if (prev == this) throw new IllegalStateException();//如果上一节点是自己代表没有上一节点
if (!prev.owner) return; // Cannot compact: prev isn't writable.//如果上一节点不可以操作，返回
int byteCount = limit - pos;//记录当前片段存储的字节长度L1
int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);//计算上一节点没有存储数据的长度L2（pos之前的长度+limit之后的长度，如果perv是共享的，那么就不能加入pos之前的长度）
if (byteCount > availableByteCount) return; // Cannot compact: not enough writable space.//如果L1>L2,那么就不够位置存，返回
writeTo(prev, byteCount);//将本部分数据写入上一节点
pop();//弹出本节点
SegmentPool.recycle(this);
}
/** Moves {@code byteCount} bytes from this segment to {@code sink}. */
public void writeTo(Segment sink, int byteCount) {//往sink部分写入this（Segment）长度为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原本存储的数据往前移，pos设为1
sink.limit -= sink.pos;
sink.pos = 0;
}
System.arraycopy(data, pos, sink.data, sink.limit, byteCount);/／将this（Segment）数据写入sink中，从limit开始
sink.limit += byteCount;
pos += byteCount;
}
共享机制（减少数据复制带来的开销）
原理：将一个Segment分为[pos...pos+byteCount]和[pos+byteCount...limit]两部分，该方法只用在Buffer.wirte()上，注意的是byteCount参数的意义是两个Segment相同的部分，如果相同的部分超多SHARE_MINIMUM=1024字节，就共享一个Segment，看起来我们是new了一个Segment，但是里面的data[]引用还是原来的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;
}
SegmentPool（减少cpu消耗（减少GC）+减少内存消耗）：
该池通过一个segment变量将全部segment联系起来，存储最多8个segment的片段池，如果该池还未满，一旦segment废弃了就放到该池中，减少了GC。如果io操作需要新建segment的话就不用new申请内存空间了，直接从片段池中获取。
Buffer：
具体读写操作的执行类,内部维护着一个Segment head,通过该片段就可以获取整个链表的所有数据，long size代表已经存储的总字节数。实现了三个接口，读、写和Clone。
实现及好处：循环的双向链表实现，链表节点为Segment片段，而Segment维护着固定长度的字节数组。这样采取分片的链接方式，片中又通过数组存储，兼具读的连续性和写的可插入性，对比于单一的用链表或者数组，是比较折中的方式。还有个好处就是根据需求来改动分片的大小来权衡读写的业务操作。
clone():
/** Returns a deep copy of this buffer. */
@Override public Buffer clone() {
Buffer result = new Buffer();
if (size == 0) return result;
result.head = new Segment(head);
result.head.next = result.head.prev = result.head;//1
for (Segment s = head.next; s != head; s = s.next) {
result.head.prev.push(new Segment(s));
}
result.size = size;
return result;
}
Segment(Segment shareFrom) {
this(shareFrom.data, shareFrom.pos, shareFrom.limit);
shareFrom.shared = true;
}
Segment(byte[] data, int pos, int limit) {
this.data = data;
this.pos = pos;
this.limit = limit;
this.owner = false;
this.shared = true;
}
该Clone拷贝方法为浅拷贝，但是我们注意到虽然拷贝新建了一个Buffer，但是该Buffer的head变量的构造由new Segment（head）构建，细看该构造器中最重要的字节数组data引用指向了新的data，没有重新分配新的内存空间，性能得到优化。Segment的shared共享标示参数设为true，结合Segment类很多设计到shared的方法，有很多好处。
同时注意到语句1,result.head.next = result.head.prev = result.head,这样就形成了循环的链表中循环的特性了，之前分析Segment类无论增加数据add Segment或者读取数据 popSegment都没有形成循环闭环的特性，原来闭环（循环）的特性在Buffer类中形成。
除此之外，Buffer进行写操作每次都必须先获取segment，语句2也是形成闭环的原因
Segment writableSegment(int minimumCapacity) {
if (minimumCapacity < 1 || minimumCapacity > Segment.SIZE) throw new IllegalArgumentException();
if (head == null) {
head = SegmentPool.take(); // Acquire a first segment.
return head.next = head.prev = head;／／2
}
Segment tail = head.prev;
if (tail.limit + minimumCapacity > Segment.SIZE || !tail.owner) {／／需要的长度如果从limit上再追加大于了Segment的最大大小了
tail = tail.push(SegmentPool.take()); // Append a new empty segment to fill up.／／使得head.prev每次都指向新push的segment
}
return tail;
}
全是读、写操作方法：
具体分为int（4）、long（8）、short（2）的等等数据类型的读和写，需要注意的是各种数据类型需要多少个字节存储，读和写的参数分为直接是字节数组或者是source、sink、输入流、输出流等等，大同小异。
utf-8编码输出：
如果为String数据类型作为输入或者输出时，编码格式可以选择，utf-8
帮助方法:
以md5、sha1、sha256数字摘要输出Buffer里面存储的数据。
ByteString
其实就是一个不可变的字节数组，以特定的编码格式进行解码，支持的解码方式有utf-8，base64和hex。
final字段科普
该字段其实就是不可变的意思，在Segment存储data还是ByteString里面data都设了该字段。
定义：
类不被拓展（继承或者实现）
所有域都是final的，所有域都是private
没有任何提供改变该类状态的方法
好处：当然是线程安全的，不用考虑同步的问题（final的语义：当构造函数结束时，final定义的值被保证当其他线程访问该对象时，该值是可见的）
坏处：需要创建大量类的对象（。。。）
Okio中的超时机制
超时机制：意义在于防止IO操作阻塞在某个异常上，okio的超时机制的基础就是采取同步超时TimeOut。
同步：TimeOut类
使用在以任何inputStream或者outPutStream作为输入流输出流参数构建时，使用同步超时机制。
其实通过对OKIO的简单使用，我们知道读写操作的具体操作都在构建输入输出流的的回调方法。
以下sink构建输出流代码为例(source(final InPutStream in)构建输入流在超时处理上也一样执行了语句1，timeOut.throwInReached(),不拓展了)
OKIO：
public static Sink sink(OutputStream out) {
return sink(out, new Timeout());
}
private static Sink sink(final OutputStream out, final Timeout timeout) {
if (out == null) throw new IllegalArgumentException("out == null");
if (timeout == null) throw new IllegalArgumentException("timeout == null");
return new Sink() {
@Override public void write(Buffer source, long byteCount) throws IOException {
checkOffsetAndCount(source.size, 0, byteCount);
while (byteCount > 0) {
timeout.throwIfReached();／／1
Segment head = source.head;
int toCopy = (int) Math.min(byteCount, head.limit - head.pos);
out.write(head.data, head.pos, toCopy);
head.pos += toCopy;
byteCount -= toCopy;
source.size -= toCopy;
if (head.pos == head.limit) {
source.head = head.pop();
SegmentPool.recycle(head);
}
}
}
@Override public void flush() throws IOException {
out.flush();
}
@Override public void close() throws IOException {
out.close();
}
@Override public Timeout timeout() {
return timeout;
}
@Override public String toString() {
return "sink(" + out + ")";
}
};
}
TimeOut：
public void throwIfReached() throws IOException {
if (Thread.interrupted()) {
throw new InterruptedIOException("thread interrupted");
}
if (hasDeadline && deadlineNanoTime - System.nanoTime() <= 0) {
throw new InterruptedIOException("deadline reached");
}
}
异步：AsyncTimeOut，
使用在socket作为输入输出流时，使用异步超时处理，之所以在socket上使用异步超时处理，因为socket自身性质决定，socket常常因为自身阻塞导致往下不执行。
okio：与其他inputStream不同的是，他不直接返回source，而是作为AsyncTime.source()的参数再进行一次封装，返回source
public static Source source(Socket socket) throws IOException {
if (socket == null) throw new IllegalArgumentException("socket == null");
AsyncTimeout timeout = timeout(socket);
Source source = source(socket.getInputStream(), timeout);
return timeout.source(source);
}
AsyncTimeOut：我们发现这里才是执行的准确位置，语句1就是涉及到异步超时处理机制。
在开始读或者写之前执行enter(),该方法就是开启一个WatchDog线程，待分析。。。
public final Source source(final Source source) {
return new Source() {
@Override public long read(Buffer sink, long byteCount) throws IOException {
boolean throwOnTimeout = false;
enter();／／1
try {
long result = source.read(sink, byteCount);
throwOnTimeout = true;
return result;
} catch (IOException e) {
throw exit(e);
} finally {
exit(throwOnTimeout);
}
}
@Override public void close() throws IOException {
boolean throwOnTimeout = false;
try {
source.close();
throwOnTimeout = true;
} catch (IOException e) {
throw exit(e);
} finally {
exit(throwOnTimeout);
}
}
@Override public Timeout timeout() {
return AsyncTimeout.this;
}
@Override public String toString() {
return "AsyncTimeout.source(" + source + ")";
}
};
}
