11 | Android 高级进阶(源码剖析篇) Square 高效易用的 IO 框架 okio

Posted 2023-01-25 ACE1985

作者简介：ASCE1885， 《android 高级进阶》作者。

本文由于潜在的商业目的，未经授权不开放全文转载许可，谢谢！

本文分析的源码版本已经 fork 到我的 Github。

超时机制在现实世界中广泛存在，例如为了保证系统的正常有序运行，高铁等交通工具每个班次是有明确的出发时间和到达时间的，当你超过出发时间还没有上车时，那么不好意思，高铁系统的超时机制将发挥作用，正常情况下你将错过这趟列车。在计算机的世界中，同样如此，例如服务器对外提供的接口一般都设置了超时时间，但超过指定时间接口的请求还没有处理完成时，服务器将会主动断开连接，避免存在大量这种非正常的连接时拖垮服务器。客户端在请求服务器的接口时，同样会设置读取超时时间，当服务器由于某些原因迟迟未返回结果时，客户端为了保证用户体验会断开这次连接，并提示用户某些功能暂时不可用，稍后重试。

在本系列第一篇文章中我们提到 okio 中的输入流 Source 和输出流 Sink 的一大特点是引入了超时机制，和上面同样的道理，此处的超时机制也是为了保证系统正常有序的运行，本文就来聊聊它的原理和具体实现。okio 中超时机制主要有三种：

• 同步超时 Timeout

• 异步超时 AsyncTimeout

• 基于装饰者模式的超时 ForwardingTimeout

其中 ForwardingTimeout 是使用装饰者模式对 Timeout 的封装，跟本系列第二篇文章中介绍的 ForwardingSource 类是同一个道理，不再赘述。

同步超时

同步超时用来控制某个任务执行的最大时长，当执行超过指定的时间时，任务将被中断，例如当从输入流 Source 中读取数据超时后，输入流将被关闭，读取操作只能稍后重试；当将数据写入输出流 Sink 超时时，输出流也将被关闭并等待稍后重试。同步超时 Timeout 类中用来判断是否超时存在两个策略：

• 根据任务处理的超时时间 timeoutNanos 判断

• 根据任务的截止时间点 deadlineNanoTime 判断

需要注意一点，deadlineNanoTime 表示的是某个具体的时间点，而 timeoutNanos 表示的是一段时间间隔。相关变量定义如下代码所示：

private boolean hasDeadline; // 是否设置了截止时间点	
private long deadlineNanoTime; // 截止时间点（单位纳秒）	
private long timeoutNanos; // 任务处理的超时时间间隔（单位纳秒）

关于这几个变量的设置和获取方法比较简单，我们略过不谈，直接来看下判断是否超时的方法 throwIfReached ，操作很明了，主要有两个判断条件：

• 判断当前线程是否已经被中断

• 判断当前时间点是否大于设定的截止时间点 deadlineNanoTime

如果满足条件，说明超时了，抛出 InterruptedIOException 表示超时时间到，代码如下所示：

public void throwIfReached() throws IOException 	
    if (Thread.interrupted()) 	
      throw new InterruptedIOException("thread interrupted");	
    	
	
    if (hasDeadline && deadlineNanoTime - System.nanoTime() <= 0) 	
      throw new InterruptedIOException("deadline reached");	
    	

可以看到这个方法并没有根据 timeoutNanos 来判断是否超时，因此，当你的 Timeout 实例只设置了任务处理的超时时间 timeoutNanos 时，调用 throwIfReached 方法其实是不会发生超时操作的，这点 okio 的设计是存在问题的。

当然 timeoutNanos 不是说没有用到，它在接下来介绍的 waitUntilNotified 方法和异步超时中会使用到。waitUntilNotified 方法用来等待某个指定的 monitor 对象，直到这个对象被 notify 或者超时时间到，也属于同步超时的一种。

public final void waitUntilNotified(Object monitor) throws InterruptedIOException 	
    try 	
      boolean hasDeadline = hasDeadline();	
      long timeoutNanos = timeoutNanos();	
	
      // 当没有设置超时时间，将无限等待直到对象被notify	
      if (!hasDeadline && timeoutNanos == 0L) 	
        monitor.wait(); // There is no timeout: wait forever.	
        return;	
      	
	
      // 根据timeoutNanos和deadlineNanoTime计算出较短的超时时间waitNanos	
      long waitNanos;	
      long start = System.nanoTime();	
      if (hasDeadline && timeoutNanos != 0) 	
        long deadlineNanos = deadlineNanoTime() - start;	
        waitNanos = Math.min(timeoutNanos, deadlineNanos);	
       else if (hasDeadline) 	
        waitNanos = deadlineNanoTime() - start;	
       else 	
        waitNanos = timeoutNanos;	
      	
	
      // 调用wait方法尝试等待超时时间waitNanos，当然如果monitor对象被外界notify，	
      // 那么自然就不会傻傻的等到waitNanos超时了	
      long elapsedNanos = 0L;	
      if (waitNanos > 0L) 	
        long waitMillis = waitNanos / 1000000L;	
        // wait方法第一个参数表示等待的毫秒数，第二个参数表示等待的纳秒数，最终等待时间是两者之和	
        monitor.wait(waitMillis, (int) (waitNanos - waitMillis * 1000000L));	
        elapsedNanos = System.nanoTime() - start;	
      	
	
      // 走到这里，说明wait等待超时时间到，或者monitor被外界notify了	
      if (elapsedNanos >= waitNanos) 	
        // 如果时超时时间到就抛出InterruptedIOException异常	
        throw new InterruptedIOException("timeout");	
      	
     catch (InterruptedException e) 	
      throw new InterruptedIOException("interrupted");	
    	

异步超时

异步超时 AsyncTimeout 继承自同步超时 Timeout，因此具有 Timeout 类的所有功能。此外，AsyncTimeout 使用一个后台线程 WatchDog 来实现超时的触发，相比同步超时而言，异步超时一般用来给原生不支持超时机制的类增加超时功能，例如 socket 在读写数据时本身是不支持超时的，因此，使用 okio 从 socket 中读写数据时，如果想要支持超时，可以通过 AsyncTimeout 给它增加这个功能，下面我们以从 socket 中读取数据为例进行介绍。AsyncTimeout 的子类通过重写 timedOut 方法来实现超时发生时的自定义处理逻辑，具体到 socket 这个例子，超时发生时我们自然是希望关闭 socket 连接，封装了 socket 的 AsyncTimeout 如下所示：

private static AsyncTimeout timeout(final Socket socket) 	
    return new AsyncTimeout() 	
      ...	
	
      @Override protected void timedOut() 	
        try 	
          socket.close();	
         catch (Exception e) 	
          logger.log(Level.WARNING, "Failed to close timed out socket " + socket, e);	
         catch (AssertionError e) 	
          if (isAndroidGetsocknameError(e)) 	
            logger.log(Level.WARNING, "Failed to close timed out socket " + socket, e);	
           else 	
            throw e;	
          	
        	
      	
    ;	

了解了 AsyncTimeout 子类定义方式后，我们来进一步看看 AsyncTimeout 的具体实现。除了上面介绍的需要子类实现的 timeOut 方法，AsyncTimeout 另外的两个核心方法分别是：

• enter：使用者在执行可能发生超时的任务前，需要调用这个方法

• exit：使用者在执行可能发生超时的任务后，需要调用这个方法

在具体介绍这两个方法之前，我们先来了解下后台线程 WatchDog 和它管理的 AsyncTimeout 链表，结构如下图所示：

可以看到，所有的 AsyncTimeout 在底层会互相联结成为一个链表，链表的顺序按照超时时间由短到长链接，而 WatchDog 用来管理这张链表。链表定义相关代码如下：

public class AsyncTimeout extends Timeout 	
  // 链表的头节点，指向链表中第一个元素	
  static @Nullable AsyncTimeout head;	
  // 当前 AsyncTimeout 指向的下一个链表元素	
  private @Nullable AsyncTimeout next;	

WatchDog 是一个守护线程，它的作用是当 AsyncTimeout 链表不为空时，轮询 AsyncTimeout 链表并触发最先超时的 AsyncTimeout 元素中的 timeOut 方法，代码如下所示：

... 更多内容请点击阅读原文继续阅读。