国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Okio 源碼解析(二):超時機制

honmaple / 2597人閱讀

摘要:內部會新開一個叫做的線程,根據超時時間依次處理鏈表的節點。總結通過以及分別提供了同步超時和異步超時功能,同步超時是在每次讀取數據前判斷是否超時,異步超時則是將組成有序鏈表,并且開啟一個線程來監控,到達超時則觸發相關操作。

簡介

上一篇文章(Okio 源碼解析(一):數據讀取流程)分析了 Okio 數據讀取的流程,從中可以看出 Okio 的便捷與高效。Okio 的另外一個優點是提供了超時機制,并且分為同步超時與異步超時。本文具體分析這兩種超時的實現。

同步超時

回顧一下 Okio.source 的代碼:

public static Source source(InputStream in) {
    // 生成一個 Timeout 對象
    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 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 的構造方法中,傳入了一個 Timeout 對象。在下面創建的匿名的 Source 對象的 read 方法中,先調用了 timeout.throwIfReached(),這里顯然是判斷是否已經超時,代碼如下:

public void throwIfReached() throws IOException {
    if (Thread.interrupted()) {
      throw new InterruptedIOException("thread interrupted");
    }

    if (hasDeadline && deadlineNanoTime - System.nanoTime() <= 0) {
      throw new InterruptedIOException("deadline reached");
    }
  }

這里邏輯很簡單,如果超時了則拋出異常。在 TimeOut 中有幾個變量用于設定超時的時間:

private boolean hasDeadline;
private long deadlineNanoTime;
private long timeoutNanos;

由于 throwIfReached 是在每次讀取數據之前調用并且與數據讀取在同一個線程,所以如果讀取操作阻塞,則無法及時拋出異常。

異步超時

異步超時與同步超時不同,其開了新的線程用于檢測是否超時,下面是 Socket 的例子。

Okio 可以接受一個 Socket 對象構建 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);
    // 返回 timeout 封裝的 source
    return timeout.source(source);
  }

相比于 InputStream,這里的額外操作是引入了 AsyncTimeout 來封裝 sockettimeout 方法生成一個 AsyncTimeout 對象,看一下代碼:

private static AsyncTimeout timeout(final Socket socket) {
    return new AsyncTimeout() {
      @Override protected IOException newTimeoutException(@Nullable IOException cause) {
        InterruptedIOException ioe = new SocketTimeoutException("timeout");
        if (cause != null) {
          ioe.initCause(cause);
        }
        return ioe;
      }
        // 超時后調用
      @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,其中有個 timedout 方法,這個方法是在超時的時候被調用,可以看出里面的操作主要是關閉 socket。有了 AsyncTimeout 之后,調用其 source 方法來封裝 socketInputStream

下面具體看看 AsyncTimeout

AsyncTimeout

AsyncTimeout 繼承了 Timeout,提供了異步的超時機制。每一個 AsyncTimeout 對象包裝一個 source,并與其它 AsyncTimeout 組成一個鏈表,根據超時時間的長短插入。AsyncTimeout 內部會新開一個叫做 WatchDog 的線程,根據超時時間依次處理 AsyncTimout 鏈表的節點。

下面是 AsyncTimeout 的一些內部變量:

// 鏈表頭結點
static @Nullable AsyncTimeout head;
// 此節點是否在隊列中
private boolean inQueue;
// 鏈表中下一個節點
private @Nullable AsyncTimeout next;

其中 head 是鏈表的頭結點,next 是下一個節點,inQueue 則標識此 AsyncTimeout 是否處于鏈表中。

在上面的 Okio.source(Socket socket) 中,最后返回的是 timeout.source(socket),下面是其代碼:

public final Source source(final Source source) {
    return new Source() {
      @Override public long read(Buffer sink, long byteCount) throws IOException {
        boolean throwOnTimeout = false;
        // enter
        enter();
        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 + ")";
      }
    };
  }

AsyncTimtout#source 依然是返回一個匿名的 Source 對象,只不過是將參數中真正的 source 包裝了一下,在 source.read 之前添加了 enter 方法,在 catch 以及 finally 中添加了 exit 方法。enterexit 是重點,其中 enter 中會將當前的 AsyncTimeout 加入鏈表,具體代碼如下:

public final void enter() {
    if (inQueue) throw new IllegalStateException("Unbalanced enter/exit");
    long timeoutNanos = timeoutNanos();
    boolean hasDeadline = hasDeadline();
    if (timeoutNanos == 0 && !hasDeadline) {
      return; // No timeout and no deadline? Don"t bother with the queue.
    }
    inQueue = true;
    scheduleTimeout(this, timeoutNanos, hasDeadline);
  }
private static synchronized void scheduleTimeout(
      AsyncTimeout node, long timeoutNanos, boolean hasDeadline) {
    // 如果鏈表為空,則新建一個頭結點,并且啟動 Watchdog線程
    if (head == null) {
      head = new AsyncTimeout();
      new Watchdog().start();
    }

    long now = System.nanoTime();
    if (timeoutNanos != 0 && hasDeadline) {
      node.timeoutAt = now + Math.min(timeoutNanos, node.deadlineNanoTime() - now);
    } else if (timeoutNanos != 0) {
      node.timeoutAt = now + timeoutNanos;
    } else if (hasDeadline) {
      node.timeoutAt = node.deadlineNanoTime();
    } else {
      throw new AssertionError();
    }

    // 按時間將節點插入鏈表
    long remainingNanos = node.remainingNanos(now);
    for (AsyncTimeout prev = head; true; prev = prev.next) {
      if (prev.next == null || remainingNanos < prev.next.remainingNanos(now)) {
        node.next = prev.next;
        prev.next = node;
        if (prev == head) {
          AsyncTimeout.class.notify(); // Wake up the watchdog when inserting at the front.
        }
        break;
      }
    }
  }

真正插入鏈表的操作在 scheduleTimeout 中,如果 head 節點還不存在則新建一個頭結點,并且啟動 Watchdog 線程。接著就是計算超時時間,然后遍歷鏈表進行插入。如果插入在鏈表的最前面(head 節點后面的第一個節點),則主動進行喚醒 Watchdog 線程,從這里可以猜到 Watchdog 線程在等待超時的過程中是調用了 AsyncTimeout.classwait 進入了休眠狀態。那么就來看看 WatchDog 線程的實際邏輯:

private static final class Watchdog extends Thread {
    Watchdog() {
      super("Okio Watchdog");
      setDaemon(true);
    }

    public void run() {
      while (true) {
        try {
          AsyncTimeout timedOut;
          synchronized (AsyncTimeout.class) {
            timedOut = awaitTimeout();

            // Didn"t find a node to interrupt. Try again.
            if (timedOut == null) continue;

            // The queue is completely empty. Let this thread exit and let another watchdog thread
            // get created on the next call to scheduleTimeout().
            if (timedOut == head) {
              head = null;
              return;
            }
          }

          // Close the timed out node.
          timedOut.timedOut();
        } catch (InterruptedException ignored) {
        }
      }
    }
  }


WatchDog 主要是調用 awaitTimeout() 獲取一個已超時的 timeout,如果不為空并且是 head 節點,說明鏈表中已經沒有其它節點,可以結束線程,否則調用 timedOut.timedOut()timeOut() 是一個空方法,由用戶實現超時后應該采取的操作。 awaitTimeout 是獲取超時節點的方法:

  static @Nullable AsyncTimeout awaitTimeout() throws InterruptedException {
    // Get the next eligible node.
    AsyncTimeout node = head.next;

    // 隊列為空的話等待有節點進入隊列或者達到超時IDLE_TIMEOUT_MILLIS的時間
    if (node == null) {
      long startNanos = System.nanoTime();
      AsyncTimeout.class.wait(IDLE_TIMEOUT_MILLIS);
      return head.next == null && (System.nanoTime() - startNanos) >= IDLE_TIMEOUT_NANOS
          ? head  // The idle timeout elapsed.
          : null; // The situation has changed.
    }

    // 計算等待時間
    long waitNanos = node.remainingNanos(System.nanoTime());

    // The head of the queue hasn"t timed out yet. Await that.
    if (waitNanos > 0) {
      // Waiting is made complicated by the fact that we work in nanoseconds,
      // but the API wants (millis, nanos) in two arguments.
      long waitMillis = waitNanos / 1000000L;
      waitNanos -= (waitMillis * 1000000L);
      // 調用 wait
      AsyncTimeout.class.wait(waitMillis, (int) waitNanos);
      return null;
    }

    // 第一個節點超時,移除并返回這個節點
    head.next = node.next;
    node.next = null;
    return node;
  }

enter 相反,exit 則是視情況拋出異常并且移除鏈表中的節點,這里就不放具體代碼了。

總結

Okio 通過 Timeout 以及 AsyncTimeout 分別提供了同步超時和異步超時功能,同步超時是在每次讀取數據前判斷是否超時,異步超時則是將 AsyncTimeout 組成有序鏈表,并且開啟一個線程來監控,到達超時則觸發相關操作。

如果我的文章對您有幫助,不妨點個贊支持一下(^_^)

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/68256.html

相關文章

  • Okio 源碼解析(一):數據讀取流程

    摘要:封裝了和,并且有多個優點提供超時機制不需要人工區分字節流與字符流,易于使用易于測試本文先介紹的基本用法,然后分析源碼中數據讀取的流程。和分別用于提供字節流和接收字節流,對應于和。和則是保存了相應的緩存數據用于高效讀寫。 簡介 Okio 是 square 開發的一個 Java I/O 庫,并且也是 OkHttp 內部使用的一個組件。Okio 封裝了 java.io 和 java.nio,...

    senntyou 評論0 收藏0
  • Android網絡編程6之OkHttp3用法全解析

    摘要:使用前準備配置添加網絡權限異步請求慣例,請求百度可以省略,默認是請求請求成功與版本并沒有什么不同,比較郁悶的是回調仍然不在線程。 前言 上一篇介紹了OkHttp2.x的用法,這一篇文章我們來對照OkHttp2.x版本來看看,OkHttp3使用起來有那些變化。當然,看這篇文章前建議看一下前一篇文章Android網絡編程(五)OkHttp2.x用法全解析。 1.使用前準備 Android ...

    Amos 評論0 收藏0
  • Android網絡編程5之OkHttp2.x用法全解析

    摘要:需要注意的是回調并不是在線程。也可以通過來同時取消多個請求。在開始創建的時候配置好,在請求網絡的時候用將請求的結果回調給線程。最后調用這個的方法請求成功使用起來簡單多了,而且請求結果回調是在線程的。 前言 講完了Volley,我們接下來看看目前比較火的網絡框架OkHttp, 它處理了很多網絡疑難雜癥:會從很多常用的連接問題中自動恢復。如果您的服務器配置了多個IP地址,當第一個IP連接失...

    wemall 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<