public void readFile() {
    try {
        FileInputStream fis = new FileInputStream("test.txt");
        okio.Source source = Okio.source(fis);
        BufferedSource bs = Okio.buffer(source);
        source.timeout().deadline(1, TimeUnit.MILLISECONDS);
        String res = bs.readUtf8();
        System.out.println(res);
    } catch (Exception e){
        e.printStackTrace();
    }
}

private class Dice {
    Random random = new Random();
    int latestTotal;

    // 搖骰子
    public synchronized void roll() {
        latestTotal = 2 + random.nextInt(6) + random.nextInt(6);
        System.out.println("Rolled " + latestTotal);
        notifyAll();
    }

    // 開啟一個線程，每隔一段時間執(zhí)行 roll 方法
    public void rollAtFixedRate(int period, TimeUnit timeUnit) {
      Executors.newScheduledThreadPool(0).scheduleAtFixedRate(new Runnable() {
        public void run() {
          roll();
         }
      }, 0, period, timeUnit);
    }

    // 超時檢測
    public synchronized void awaitTotal(Timeout timeout, int total) throws InterruptedIOException {
      while (latestTotal != total) {
        timeout.waitUntilNotified(this);
      }
   }
}

public void timeout(){
    try {
        Dice dice = new Dice();
        dice.rollAtFixedRate(3, TimeUnit.SECONDS);
        Timeout timeout = new Timeout();
        timeout.timeout(6, TimeUnit.SECONDS);
        dice.awaitTotal(timeout, 20);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void timeout(){
    try {
        Dice dice = new Dice();
        dice.rollAtFixedRate(3, TimeUnit.SECONDS);
        Timeout timeout = new Timeout();
        timeout.deadline(6, TimeUnit.SECONDS);
        dice.awaitTotal(timeout, 20);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public final void waitUntilNotified(Object monitor) throws InterruptedIOException {
    try {
      boolean hasDeadline = hasDeadline();
      long timeoutNanos = timeoutNanos();

      // 若沒有設(shè)置 deadline && timeout，則一直等待直到喚醒
      if (!hasDeadline && timeoutNanos == 0L) {
        monitor.wait(); // There is no timeout: wait forever.
        return;
      }

      // Compute how long we'll wait.
      // 計算等待的時長，若同時設(shè)置了deadline 和 timeout，則 deadline 優(yōu)先
      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;
      }

      // Attempt to wait that long. This will break out early if the monitor is notified.
      long elapsedNanos = 0L;
      if (waitNanos > 0L) {
        long waitMillis = waitNanos / 1000000L;
        // 等待 waitNanos
        monitor.wait(waitMillis, (int) (waitNanos - waitMillis * 1000000L));
        // 計算從等待 waitNanos 到喚醒所用時間
        elapsedNanos = System.nanoTime() - start;
      }

      // Throw if the timeout elapsed before the monitor was notified.
      // 若等待了 waitNanos 還沒喚醒，認為超時
      if (elapsedNanos >= waitNanos) {
        throw new InterruptedIOException("timeout");
      }
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt(); // Retain interrupted status.
      throw new InterruptedIOException("interrupted");
    }
}

enter();
// do something
exit();

private static final long IDLE_TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(60);
static @Nullable AsyncTimeout head;
private boolean inQueue;
private @Nullable AsyncTimeout next;
private long timeoutAt;

private static synchronized void scheduleTimeout(AsyncTimeout node, long timeoutNanos, boolean hasDeadline) {
    // Start the watchdog thread and create the head node when the first timeout is scheduled.
    // 若 head 節(jié)點為 null, 初始化 head 并啟動 Watchdog 線程
    if (head == null) {
      head = new AsyncTimeout();
      new Watchdog().start();
    }

    // 計算 node 節(jié)點的 timeoutAt 值
    long now = System.nanoTime();
    if (timeoutNanos != 0 && hasDeadline) {
      // Compute the earliest event; either timeout or deadline. Because nanoTime can wrap around,
      // Math.min() is undefined for absolute values, but meaningful for relative ones.
      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();
    }

    // Insert the node in sorted order.
    // 返回 node 節(jié)點的超時剩余時間
    long remainingNanos = node.remainingNanos(now);
    // 從 head 節(jié)點開始遍歷鏈表, 將 node 節(jié)點插入到合適的位置
    for (AsyncTimeout prev = head; true; prev = prev.next) {
      // 若當前遍歷的節(jié)點下一個節(jié)點為 null 或者 node 節(jié)點的超時剩余時間小于下一個節(jié)點
      if (prev.next == null || remainingNanos < prev.next.remainingNanos(now)) {
        // 將 node 節(jié)點插入到鏈表
        node.next = prev.next;
        prev.next = node;
        // 若當前遍歷的節(jié)點是 head, 喚醒 watchdog 線程
        if (prev == head) {
          AsyncTimeout.class.notify(); // Wake up the watchdog when inserting at the front.
        }
        break;
      }
    }
}

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

    public void run() {
      while (true) {
        try {
          // 超時的節(jié)點
          AsyncTimeout timedOut;
          // 加鎖，同步代碼塊
          synchronized (AsyncTimeout.class) {
            // 等待節(jié)點超時
            timedOut = awaitTimeout();

            // Didn't find a node to interrupt. Try again.
            // 當前該節(jié)點沒有超時，繼續(xù)檢查
            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().
            // 鏈表中已經(jīng)沒有超時節(jié)點，結(jié)束運行
            if (timedOut == head) {
              head = null;
              return;
            }
          }

          // Close the timed out node.
          // timedOut 節(jié)點超時，回調(diào) timedOut() 方法
          timedOut.timedOut();
        } catch (InterruptedException ignored) {
        }
      }
    }
}

static @Nullable AsyncTimeout awaitTimeout() throws InterruptedException {
    // Get the next eligible node.
    // 檢測的節(jié)點
    AsyncTimeout node = head.next;

    // The queue is empty. Wait until either something is enqueued or the idle timeout elapses.
    // 若鏈表為空
    if (node == null) {
      long startNanos = System.nanoTime();
      // Watchdog 線程等待 60s，期間會釋放類鎖
      AsyncTimeout.class.wait(IDLE_TIMEOUT_MILLIS);
      // 等待 60s 后若鏈表還為空則返回 head，否則返回 null
      return head.next == null && (System.nanoTime() - startNanos) >= IDLE_TIMEOUT_NANOS
              ? head  // The idle timeout elapsed.
              : null; // The situation has changed.
    }
    // node 節(jié)點超時剩余的時間
    long waitNanos = node.remainingNanos(System.nanoTime());

    // The head of the queue hasn't timed out yet. Await that.
    // node 節(jié)點超時剩余的時間 > 0，說明 node 還未超時，繼續(xù)等待 waitNanos 后返回 null
    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);
      AsyncTimeout.class.wait(waitMillis, (int) waitNanos);
      return null;
    }

    // The head of the queue has timed out. Remove it.
    // node 節(jié)點超時了，將 node 從鏈表中移除并返回
    head.next = node.next;
    node.next = null;
    return node;
}

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
    inQueue = true;
    scheduleTimeout(this, timeoutNanos, hasDeadline);
}

public final boolean exit() {
    if (!inQueue) return false;
    // 更新 inQueue 為 false
    inQueue = false;
    return cancelScheduledTimeout(this);
}

private static synchronized boolean cancelScheduledTimeout(AsyncTimeout node) {
    // Remove the node from the linked list.
    // 若 node 在鏈表中，將其移除。
    for (AsyncTimeout prev = head; prev != null; prev = prev.next) {
      if (prev.next == node) {
        prev.next = node.next;
        node.next = null;
        return false;
      }
    }

    // The node wasn't found in the linked list: it must have timed out!
    // node 不在鏈表中，則 node 一定超時了，返回 true
    return true;
}