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

  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);
		 // 從輸入流最多讀取 maxToCopy 個(gè)字節(jié)
          int maxToCopy = (int) Math.min(byteCount, Segment.SIZE - tail.limit);
		 // 從輸入流讀取數(shù)據(jù)到 Segment
          int bytesRead = in.read(tail.data, tail.limit, maxToCopy);
		 // 到達(dá)輸入流尾部
          if (bytesRead == -1) return -1;
		 // 更新 tail 的 limit
          tail.limit += bytesRead;
		 // 更新 sink 的 size 值
          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 + ")";
      }
    };
  }

public void readFile() {
	try {
		FileInputStream fis = new FileInputStream("test.txt");
		okio.Source source = Okio.source(fis);
		BufferedSource bs = Okio.buffer(source);
		// 設(shè)置超時(shí)時(shí)間為 1ms
		source.timeout().deadline(1, TimeUnit.MILLISECONDS);
		String res = bs.readUtf8();
		System.out.println(res);
	} catch (Exception e){
		e.printStackTrace();
	}
}

java.io.InterruptedIOException: deadline reached
	at okio.Timeout.throwIfReached(Timeout.kt:102)
	at okio.InputStreamSource.read(JvmOkio.kt:87)
	at okio.Buffer.writeAll(Buffer.kt:1642)
	at okio.RealBufferedSource.readUtf8(RealBufferedSource.kt:297)

public void readFile() {
	Thread thread = new Thread(){
		@Override
		public void run() {
			try {
				FileInputStream fis = new FileInputStream("test.txt");
				okio.Source source = Okio.source(fis);
				BufferedSource bs = Okio.buffer(source);
				// 中斷當(dāng)前線程
				interrupt();
				String res = bs.readUtf8();
				System.out.println(res);
			} catch (Exception e){
				e.printStackTrace();
			}
		}
	};
	thread.start();

	try {
		thread.join();
	} catch (Exception e) {
		e.printStackTrace();
	}
}

  public static BufferedSource buffer(Source source) {
    return new RealBufferedSource(source);
  }

  @Override public String readUtf8() throws IOException {
    buffer.writeAll(source);
    return buffer.readUtf8();
  }

  @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;
  }

public void readAndWrite() {
	try {
		FileInputStream fis = new FileInputStream("test.txt");
		Source source = Okio.source(fis);
		BufferedSource bSource = Okio.buffer(source);

		FileOutputStream fos = new FileOutputStream("test2.txt");
		Sink sink = Okio.sink(fos);
		BufferedSink bSink = Okio.buffer(sink);

		while (!bSource.exhausted()){
			// 不停的從 test.txt 中讀取數(shù)據(jù)并寫入到 test2.txt
			bSource.read(bSink.buffer(), 8*1024);
			// 將輸出流緩沖區(qū)的數(shù)據(jù)完全寫入到文件中
			bSink.emit();
		}

		bSource.close();
		bSink.close();

	} catch (Exception e) {
		e.printStackTrace();
	}
}

  /** 一個(gè)Segment的容量 8kb */
  static final int SIZE = 8192;

  /** data可共享閾值，小于這個(gè)值則使用 System.arraycopy 拷貝，不共享*/
  static final int SHARE_MINIMUM = 1024;

  final byte[] data;

  /** 讀數(shù)據(jù)的起始位 */
  int pos;

  /** 寫數(shù)據(jù)的起始位 */
  int limit;

  /** data字節(jié)數(shù)組是否共享. */
  boolean shared;

  /** 當(dāng)前Segment是否為data字節(jié)數(shù)組的宿主Segment，與shared互斥 */
  boolean owner;

  /** 后繼節(jié)點(diǎn) */
  Segment next;

  /** 前驅(qū)節(jié)點(diǎn) */
  Segment prev;

Segment sharedCopy()

Segment unsharedCopy()

Segment pop()

Segment push(Segment segment)

Segment split(int byteCount)

void compact()

void writeTo(Segment sink, int byteCount)

  final Segment sharedCopy() {
    shared = true;
    return new Segment(data, pos, limit, true, false);
  }

  final Segment unsharedCopy() {
    return new Segment(data.clone(), pos, limit, false, true);
  }

  public final @Nullable Segment pop() {
    Segment result = next != this ? next : null;
    prev.next = next;
    next.prev = prev;
    next = null;
    prev = null;
    return result;
  }

prev.next = next;
next.prev = prev;

next = null;
prev = null;

  public final Segment push(Segment segment) {
    segment.prev = this;
    segment.next = next;
    next.prev = segment;
    next = segment;
    return segment;
  }

  public final Segment split(int byteCount) {
	// byteCount 參數(shù)合法性校驗(yàn)，若要分割的字節(jié)數(shù)量 <=0 或 > 已有的數(shù)據(jù)量，則拋出異常
    if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
    Segment prefix;

	// 從當(dāng)前Segment分割出一個(gè)新的Segment(prefix)
	//1. 若要分割的字節(jié)數(shù) >= SHARE_MINIMUM(1kb)，則采用共享拷貝(拷貝引用)的方式
	//2. 若分割的字節(jié)數(shù) < 1kb，則采用拷貝的方式(完全復(fù)制，新開辟內(nèi)存空間)
    if (byteCount >= SHARE_MINIMUM) {
      prefix = sharedCopy();
    } else {
      prefix = SegmentPool.take();
      System.arraycopy(data, pos, prefix.data, 0, byteCount);
    }

	// 更新剛分割出來的Segment(prefix)的limit值, [pos, limit = (pos+byteCount))
    prefix.limit = prefix.pos + byteCount;
	// 更新當(dāng)前Segment的pos值, [pos = (pos+byteCount), limit)
    pos += byteCount;
	// 將新分割出來的Segment(prefix)添加到當(dāng)前Segment的后面
    prev.push(prefix);
	// 返回新分割出來的 Segment(prefix)
    return prefix;
  }

  public final void writeTo(Segment sink, int byteCount) {
	// sink 參數(shù)合法性校驗(yàn)，若sink非data的宿主Segemnt，則拋出異常。
	// 這說明獲得數(shù)據(jù)的Segment必須是data的宿主，只有宿主Segment才能對data進(jìn)行修改
    if (!sink.owner) throw new IllegalArgumentException();
	  
	// 若 sink 從 limit 開始寫數(shù)據(jù)，剩余的容量不足以容納 byteCount 個(gè)字節(jié)
    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();
	  // (byteCount > SIZE - (sink.limit-sink.pos))
	  // 即 sink 剩余的容量不能容納 byteCount 個(gè)字節(jié)數(shù)據(jù)，拋出異常
      if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException();
	  // 移動(dòng) sink 的數(shù)據(jù)，從 pos = 0 開始
      System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos);
      sink.limit -= sink.pos;
      sink.pos = 0;
    }

	// 拷貝數(shù)據(jù)到 sink
    System.arraycopy(data, pos, sink.data, sink.limit, byteCount);
	// 更新 sink 的 limit 值
    sink.limit += byteCount;
	// 更新當(dāng)前 Segment 的 pos 值
    pos += byteCount;
  }

  public final void compact() {
	// 若鏈表中只有一個(gè)Segment，無法合并。拋出異常
    if (prev == this) throw new IllegalStateException();
	// 若待合并的 prev 節(jié)點(diǎn)非宿主，無法進(jìn)行合并操作
    if (!prev.owner) return; // Cannot compact: prev isn't writable.
	// 當(dāng)前 Segment 存儲(chǔ)的字節(jié)數(shù)
    int byteCount = limit - pos;
	// prev 剩余的容量，SIZE - (prev.limit- prev.pos)
    int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);
	// 若 prev 剩余的容量不足以容納當(dāng)前 Segment 的數(shù)據(jù)，無法合并
    if (byteCount > availableByteCount) return; // Cannot compact: not enough writable space.
    // 將當(dāng)前 Segment 的數(shù)據(jù)移動(dòng)到 prev
	writeTo(prev, byteCount);
	// 將當(dāng)前 Segment 從鏈表中移除
    pop();
	// 回收當(dāng)前的 Segment
    SegmentPool.recycle(this);
  }

final class SegmentPool {
  // 池子里最多有 8 個(gè) Segment
  static final long MAX_SIZE = 64 * 1024; // 64 KiB.

  // 單鏈表的頭結(jié)點(diǎn)
  static @Nullable Segment next;

  // 池子中所有Segment的字節(jié)總數(shù)
  static long byteCount;

  private SegmentPool() {
  }

  // Segment 復(fù)用，取單鏈表頭結(jié)點(diǎn)
  static Segment take() {
    synchronized (SegmentPool.class) {
      if (next != null) {
        Segment result = next;
        next = result.next;
        result.next = null;
        byteCount -= Segment.SIZE;
        return result;
      }
    }
    return new Segment(); // Pool is empty. Don't zero-fill while holding a lock.
  }

	// Segment 回收，將其放到單鏈表頭部
  static void recycle(Segment segment) {
    if (segment.next != null || segment.prev != null) throw new IllegalArgumentException();
    if (segment.shared) return; // This segment cannot be recycled.
    synchronized (SegmentPool.class) {
      if (byteCount + Segment.SIZE > MAX_SIZE) return; // Pool is full.
      byteCount += Segment.SIZE;
      segment.next = next;
      segment.pos = segment.limit = 0;
      next = segment;
    }
  }
}

  @Nullable Segment head;
  long size;

  @Override public void write(Buffer source, long byteCount) {
	// 參數(shù)合法性校驗(yàn)
    if (source == null) throw new IllegalArgumentException("source == null");
    if (source == this) throw new IllegalArgumentException("source == this");
    checkOffsetAndCount(source.size, 0, byteCount);

	// 當(dāng) byteCount > 0
    while (byteCount > 0) {
      // Is a prefix of the source's head segment all that we need to move?
	  // 若 byteCount 個(gè)字節(jié)數(shù)據(jù)存在于 source 的頭部 Segment
      if (byteCount < (source.head.limit - source.head.pos)) {
        Segment tail = head != null ? head.prev : null;
		// 若當(dāng)前緩沖區(qū)尾部的 Segment 不為 null && 是宿主 Segment && 能容納 byteCount 個(gè)字節(jié)
        if (tail != null && tail.owner
            && (byteCount + tail.limit - (tail.shared ? 0 : tail.pos) <= Segment.SIZE)) {
          // Our existing segments are sufficient. Move bytes from source's head to our tail.
		  // 直接將 source緩沖區(qū) 頭部 Segment 的數(shù)據(jù)移動(dòng)到當(dāng)前緩沖區(qū)尾部的 Segment
          source.head.writeTo(tail, (int) byteCount);
		  // 更新 source 緩沖區(qū)的 size
          source.size -= byteCount;
		  // 更新當(dāng)前緩沖區(qū)的 size
          size += byteCount;
		  // 結(jié)束程序
          return;
        } else {
          // We're going to need another segment. Split the source's head
          // segment in two, then move the first of those two to this buffer.
		  // 若當(dāng)前緩沖區(qū)尾部的 Segment 為 null || 無法容納 byteCount 個(gè)字節(jié)
		  // 將 source 緩沖區(qū)頭部的 Segment 的 byteCount 個(gè)字節(jié)分割出來
          source.head = source.head.split((int) byteCount);
        }
      }

      // Remove the source's head segment and append it to our tail.
	  // source 緩沖區(qū)頭部節(jié)點(diǎn)
      Segment segmentToMove = source.head;
	  // source 緩沖區(qū)頭部節(jié)點(diǎn)的字節(jié)數(shù)
      long movedByteCount = segmentToMove.limit - segmentToMove.pos;
	  // 將 source 緩沖區(qū)頭部節(jié)點(diǎn)從雙鏈表中移除，并返回它的下一個(gè)節(jié)點(diǎn)
      source.head = segmentToMove.pop();
	  // 若當(dāng)前緩沖區(qū)頭部節(jié)點(diǎn)為 null
      if (head == null) {
        head = segmentToMove;
        head.next = head.prev = head;
      } else {
		// 若當(dāng)前緩沖區(qū)頭部節(jié)點(diǎn)不為 null，將 source 緩沖區(qū)頭部節(jié)點(diǎn)添加到當(dāng)前緩沖區(qū)尾部
        Segment tail = head.prev;
        tail = tail.push(segmentToMove);
		// 嘗試合并
        tail.compact();
      }
	  // 更新 source 緩沖區(qū)的 size
      source.size -= movedByteCount;
	  // 更新當(dāng)前緩沖區(qū)的 size
      size += movedByteCount;
	  // 更新 byteCount
      byteCount -= movedByteCount;
    }
  }