雨山木工
雨山木工

Okio 源码分析

Okio 源码分析

Okio , Java, Java IO

OkIo 是 OKHTTP 中使用的 一个 IO的框架，它主要是对Java的IO进行了一次封装！相比于Java IO它有更加简洁优雅的API，同时在性能和内存的消耗上也有一定优势。

首先了解几个类：

  1. Sink : 这个接口用于描述 OutputStream ，功能可以类比Java中的OutputStream
  2. Source : 这个接口用于描述 InputStream ， 功能可以类比Java中的InputStream
  3. Okio : 这是个工具类，用于提供了 包装 生成 Sink 和 Source 的静态方法
  4. Buffer: 这是一个持有字节数组的类，可以看成Java中的byte[],但是它的实现比较有意思，后面会详细的介绍

我们来分析 一个 Sink 的写入行为：

        // 获取 file 引用，如果文件就删除 
        File file = removeExistsFile();

        // 获取一个 Sink 的 引用 
        Sink sink = Okio.sink(file);  (#1)

        // 构建一个 Buffer ，用于缓存我们写入的数据
        Buffer buffer = new Buffer();  (#2)

        buffer.writeUtf8("hello");
        
        // 将缓存写到 sink 中
        sink.write(buffer, buffer.size());  (#3)
        
        sink.flush();
  1. #1 处 我们 通过静态方法 获取了 Sink 引用 ， 进一步分析：
public static Sink sink(File file) throws FileNotFoundException {
    if (file == null) throw new IllegalArgumentException("file == null");
    return sink(new FileOutputStream(file));
}

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");
    
    // 在这里 实例化 一个 Sink 对象 返回 ，其实这个Sink 就是 包装了 OutputStream
    return new Sink() {
      @Override public void write(Buffer source, long byteCount) throws IOException {
      // 检查写入的字节数组的数据 
        checkOffsetAndCount(source.size, 0, byteCount);
        while (byteCount > 0) {
            // 检查是否超时 
          timeout.throwIfReached();
          
          // 首先获取 将要写入的字节数组的 头Segment 
          Segment head = source.head;
          // 取出 byteCount 和 头Segment 的可读区域的最小值 
          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;
        
            // 如果 头Segment没有可读字节了，代表当前Segment被消费完毕，
            // 将head从双向环形链表中移除，会移动head指向下一个Segment ，这样如果当head的Segment空间不足，下一次循环会将数据写到下一个head中 ， 并且尝试使用 SegmentPool 回收 该Segment
          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 + ")";
      }
    };
  }

我们可以看出，上面的Sink 就是 对 OutputStream的一个包装，重点是这里的 write 方法，这里涉及到了 Buffer 的内部结构，从头部Segment开始不断的消费数据，然后将已经消费的数据，回收

  1. #2中我们实例化了一个 Buffer ，并且在后面写入了一个UTF-8的字符串！这里我们来分析下Buffer的内部实现，这也是 Okio 最与众不同的地方：

/** 首先我们来看它的注释
 * A collection of bytes in memory. （内存中字节的集合）
 *
 * 
Moving data from one buffer to another is fast. Instead
 * of copying bytes from one place in memory to another, this class just changes
 * ownership of the underlying byte arrays.  ）
 * 它的移动数据从一个Buffer到另一个Buffer很快，这里使用的不是从一个Buffer拷贝内存到另一个，而是直接复用之前的内存片段，所以很快，也可以节省很多的内存分配，节省CPU时间（复制内存是需要CPU运算的）
 *
 *
 * 
This buffer grows with your data. Just like ArrayList,
 * each buffer starts small. It consumes only the memory it needs to.
 * 可以自动的增长，如果使用Java的自己数组，要指定数组的大小，当原数组大小不足，就要自己手动的复制数据，Okio 已经帮我们做好了这些
 *
 * 
This buffer pools its byte arrays. When you allocate a
 * byte array in Java, the runtime must zero-fill the requested array before
 * returning it to you. Even if you're going to write over that space anyway.
 * This class avoids zero-fill and GC churn by pooling byte arrays.
 * Buffer的字节数组，是被池化的，当你申请一块Java的内存的时候，JVM会自动的初始化这块内存，会将字节数组填充为0，OKio里使用SegmentPool 池化管理 Buffer 的 Segment ，可以复用之前申请的内存
 */

Buffer 类的注释，已经比较详细的介绍了，Buffer的优点：

  1. 减少了，内存中不断Copy的成本，可以复用Segment
  2. 相比与原生Java，更容易使用的API（自动增长等）

再来介绍下Buffer类内部结构：

    Segment head;
    
    long size;

如上代码片段，Buffer中，只有两个类变量！head，用于指定 head 的Segment，size 用于指定Buffer的大小。

说这里，我们必须要详细的介绍下 Segment 这个类了！

Segment类正如它的名字，就是 byte 数组的片段，在Buffer中，使用 双向循环链表管理 Segment , 在SegmentPool中 使用一个单向链表管理Segment！

下面解释下Segment类中的字段：

    // 指定一个Segment data 域的大小
    static final int SIZE = 8192;

    // Segment分享的阀值，超过这个大小的Segment，就不再使用复制的方法共享数据而是直     // 接共享Segment
    static final int SHARE_MINIMUM = 1024;

    // Segment的数据域，大小是上面的SIZE 
    final byte[] data;

    // 读指针
    int pos;

    // 写指针
    int limit;

    // 一个Segment是否被分享，如果被分享了，那么一般来说它就不能够再被修改了
    boolean shared;

    // 表示这个Segment是否可以被修改！
    boolean owner;

    // next指针，指向下一个Segment，用于SegmentPool 链表 和 Buffer 中的双向循环链表
    Segment next;

    // prev 指针，指向双向链表中的上一个元素
    Segment prev;

我们依次来讲讲 Segment的方法：

// 构造方法，默认大小为 SIZE 的data域，设置为修改，没有分享
Segment() {
    this.data = new byte[SIZE];
    this.owner = true;
    this.shared = false;
  }
  
  // 构造方法，直接复用了data , 设置了 读写指针，不可修改，共享状态
  Segment(byte[] data, int pos, int limit) {
    this.data = data;
    this.pos = pos;
    this.limit = limit;
    this.owner = false;
    this.shared = true;
  }
// 从一个旧的Segment中，直接复用数据域，相当于 浅拷贝一份原本的Segment，
// 并且将原来的Segment的状态改为分享
Segment(Segment shareFrom) {
    this(shareFrom.data, shareFrom.pos, shareFrom.limit);
    shareFrom.shared = true;
  }
  
  // 从双向循环链表中，移除当前的元素
  // 如果当前为空则返回null
  public @Nullable Segment pop() {
    Segment result = next != this ? next : null;
    prev.next = next;
    next.prev = prev;
    next = null;
    prev = null;
    return result;
  }
  
  // 向双向循环链表中插入数据
  public Segment push(Segment segment) {
    segment.prev = this;
    segment.next = next;
    next.prev = segment;
    next = segment;
    return segment;
  }
  
  // 这个方法，用于将当前的Segment 分割为两个Segment
  // 前一个Segment大小为 [pos , pos + byteCount] 
  // 后一个Segment大小为 [pos + byteCount ,  limit)
  // 这个用于将大的Segment ，分割成小的
  public Segment split(int byteCount) {
    if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
    Segment prefix;

    // 如果byteCount比较大，我们就不分了，直接复用当前的Segment
    // byteCount 太大 复制的成本就比较大，需要内存
    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;
  }
  
  // 用于将小的 Segment（单个Segment 的利用率 不足 50% ） ，合并成一个大的，
  // 将原本小的 ，Segment 放入 Pool 中
  public void compact() {
    if (prev == this) throw new IllegalStateException();
    if (!prev.owner) return; // Cannot compact: prev isn't writable.
    // 算出当前的 已经使用的 大小
    int byteCount = limit - pos;
    // 要存放数据的Segment剩余的大小 
    int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);
    // 如果没有足够的大小则，直接返回
    if (byteCount > availableByteCount) return; 
    // 若果有足够的大小，则将当前Segment数据写到 prev 中
    writeTo(prev, byteCount);
    // 移除当前的Segment
    pop();
    // 回收 当前Segment
    SegmentPool.recycle(this);
  }
  
  // 用于将当前的数据写到目标sink中
  public void writeTo(Segment sink, int byteCount) {
    if (!sink.owner) throw new IllegalArgumentException();
    // 如果 目标Segment的剩余大小不足！
    if (sink.limit + byteCount > SIZE) {
        // 如果目标Segment被分享了，则原本数据不能修改，直接抛异常
      if (sink.shared) throw new IllegalArgumentException();
      // 如果目标Segment，没有共享
      // 则尝试 抹去 pos之前的数据 ， 再看大小够不够
      if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException();
      // 如果够了的话，则将pos之前的数据抹去，
      // 这里 就是将原本数据 的数据前移 pos 位 
      System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos);
      // 抹去原本的pos指针
      sink.limit -= sink.pos;
      sink.pos = 0;
    }
    // 目标大小必定是足够的，直接拷贝数据
    System.arraycopy(data, pos, sink.data, sink.limit, byteCount);
    // 移动 目标Segment的写指针
    sink.limit += byteCount;
    // 移动当前目标的读指针
    pos += byteCount;
  }

我们已经分析了，Segment 的字段和方法，很容易看出，Segment就是一段byte[]数组的管理的对象，不过有读指针和写指针，当需要复用内部的byte[]数组的时候，可以 直接分享 Segment 而不是 复制数据！

之前的Buffer的源码中，只有一个 head的 Segment 的字段，其实这个head就是双向数据链表的头部，Buffer中Segment组成了一个双向循环链表！以此来管理数据！当需要和别的Buffer共享内存片段的时候，我们不是自己复制字节数组，而是想办法去共享Segment！

Buffer 结构下图：

Okio 源码分析_第1张图片
[email protected]

Buffer的head和其他的Segment，组成了一个环形的链表，head 的 pre就是 链表的尾结点

在看Buffer中是具体怎么使用 Segment之前，我们先看一下，SegmentPool是怎么管理，回收和复用Segment的，它的代码非常简单。

// 这个 SegmentPool代码很简洁 
// 主要的思路就是使用 Segment中的next指针，构成一个单链表，管理和分配Segment
// 每次 申请一块Segment时候，先查看，缓存的队列是不是空的，空的话，就直接新建一个Segment返回
// 如果不为空，则清空原来的Segment的数据，返回缓存的Segment
final class SegmentPool {
  /** The maximum number of bytes to pool. */
  // TODO: Is 64 KiB a good maximum size? Do we ever have that many idle segments?
  // 缓存的 Segment的最大的内存大小
  static final long MAX_SIZE = 64 * 1024; // 64 KiB.

  /** Singly-linked list of segments. */
  // 缓存队列的 头部指针
  static @Nullable Segment next;

  /** Total bytes in this pool. */
  // 缓存池中，缓存的字节数目
  static long byteCount;

// 私有的构造方法，因为这个类不需要实例化
  private SegmentPool() {
  }

// 在 通过SegmentPool去获取一个Segment的实例，
// 如果，next 为 null 则表示队列为null(当前没有Segment被回收！)，新建一个Segment返回
// next 不为空，则取队列的头Segment，next 移动到下一个元素
// byteCount 减去 Segment.SIZE 
  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的next 和 pre 不为空，或者 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) {
    //  如果 缓存的字节数的大小，大于 MAX_SZIE，则不缓存了
      if (byteCount + Segment.SIZE > MAX_SIZE) return; // Pool is full.
      byteCount += Segment.SIZE;
      // 将新来的Segment插入到 队列的头部，并且清除 pos 和 limit 
      segment.next = next;
      segment.pos = segment.limit = 0;
      next = segment;
    }
  }
}

我们看到了 SegmentPool 是如何管理Segment的了，下面进入重点，Buffer的源码：
由于Buffer的代码量比较大，我们只看几个重要方法（在Sink和Source中，经常被使用的方法） !

// 将 Buffer 复制到 OutputStream 中！
public Buffer copyTo(OutputStream out, long offset, long byteCount) throws IOException {
    if (out == null) throw new IllegalArgumentException("out == null");
    checkOffsetAndCount(size, offset, byteCount);
    if (byteCount == 0) return this;

    // 找到开始写入的 Segment
    Segment s = head;
    for (; offset >= (s.limit - s.pos); s = s.next) {
      offset -= (s.limit - s.pos);
    }

    // 将 数据 写到outputStream中
    for (; byteCount > 0; s = s.next) {
      int pos = (int) (s.pos + offset);
      int toCopy = (int) Math.min(s.limit - pos, byteCount);
      out.write(s.data, pos, toCopy);
      byteCount -= toCopy;
      offset = 0;
    }

    return this;
  }

// 这个方法，将数据拷贝到，另一个 Buffer 中。
public Buffer copyTo(Buffer out, long offset, long byteCount) {
    if (out == null) throw new IllegalArgumentException("out == null");
    checkOffsetAndCount(size, offset, byteCount);
    if (byteCount == 0) return this;

    out.size += byteCount;

    // Skip segments that we aren't copying from.
    Segment s = head;
    for (; offset >= (s.limit - s.pos); s = s.next) {
      offset -= (s.limit - s.pos);
    }

    for (; byteCount > 0; s = s.next) {
    // 直接新建一个 Segment 对象，这里复用了 原本的 Segment 
      Segment copy = new Segment(s);
      copy.pos += offset;
      copy.limit = Math.min(copy.pos + (int) byteCount, copy.limit);
      // 如果 头 为空，则代表还没有数据，当前Segment直接作为 Head 
      if (out.head == null) {
        out.head = copy.next = copy.prev = copy;
      } else {
      // 将Segment放入 双向循环链表中！
        out.head.prev.push(copy);
      }
      byteCount -= copy.limit - copy.pos;
      offset = 0;
    }

    return this;
  }

我们再来看下，一个很重要的方法，这个方法里用到了 Segment 里的一些复杂的API：

// 这里源码中注释很长，我们直接，解释意思：
// 这个方法，将 source Segment写入到 当前 Segment中
// 这里也是 直接 复用 Segment的数据，而不是 Copy 数据！
// Buffer中，除了头结点和尾结点，其他结点的，数据域使用率，应该不低于50%
// 当我们 向一个 Buffer [91%, 61%] 中写入另一个Buffer [72%] 的时候 
// 我们直接将72%的Segment , 放入 Buffer 队列中，得到新的 [91%, 61%, 72%] ，没有任何拷贝！
// 当我们有 [100%, 2%] ， 写入 [99%, 3%] ， 最终会是 [100%, 2%, 99%, 3%] 
// 但是如果有 [100%, 40%] ，写入 [30%, 80%] ，最终会是 [100%, 70%, 80%]
// 也就是，如果相临近的两个Segment的和小于 100 %，则就会将他们压缩 （使用的Segment的 compact 方法）

// 有时候，我们可能会只写一部分 数据！例如，[92%, 82%] ，我们将他的前 30% 写入 
//  [51%, 91%]，那么我们这时候，会将原来的[92%, 82%] , 分裂 [30%, 62%, 82%]，
// 最终结果 是 [51%, 91%, 30%] （使用的Segment的 split 方法）
@Override public void write(Buffer source, long byteCount) {

    if (source == null) throw new IllegalArgumentException("source == null");
    if (source == this) throw new IllegalArgumentException("source == this");
    checkOffsetAndCount(source.size, 0, byteCount);

    while (byteCount > 0) {
      // 如果byteCount 比较小，只涉及到 source Buffer的头Segment 
      if (byteCount < (source.head.limit - source.head.pos)) {
        // 获取队列的尾部，双向循环队列，head的pre就是尾部
        Segment tail = head != null ? head.prev : null;
        // 如果我们 当前 Buffer的尾部 足够，则直接复制到数据到尾部！
        if (tail != null && tail.owner
            && (byteCount + tail.limit - (tail.shared ? 0 : tail.pos) <= Segment.SIZE)) {
          
          source.head.writeTo(tail, (int) byteCount);
          source.size -= byteCount;
          size += byteCount;
          return;
        } else {
            // 如果当前的Buffer 的尾部空间不够，我们将 source 分开一部分！大小为 byteCount
          source.head = source.head.split((int) byteCount);
        }
      }

      
      // 剩下的 操作都是 跨越 source 中至少两个Segment的 
      Segment segmentToMove = source.head;
      long movedByteCount = segmentToMove.limit - segmentToMove.pos;
      // 直接 将 Head 从source中弹出！
      source.head = segmentToMove.pop();
      // 如果当前队列为空，则直接复用Head
      if (head == null) {
        head = segmentToMove;
        head.next = head.prev = head;
      } else {
      //不为空则，将其写入到当前的尾部，并且尝试，压缩下，防止过多的零碎的Segment
        Segment tail = head.prev;
        tail = tail.push(segmentToMove);
        tail.compact();
      }
      source.size -= movedByteCount;
      size += movedByteCount;
      byteCount -= movedByteCount;
    }
  }

我们已经了解了整个Buffer的内部结构，其核心就是使用Segment去分段的管理byte数组，然后尽量的复用Segment，而不是copy 字节数组，从而提高性能！

Okio 中还提供了一些，ByteString整个类，帮助我们做数据从byte数组的一些转换，如提供了 base64Url，和 utf8 等转换方法！

我们之前的例子，我们自己实例化了一个Buffer，然后用于缓存写入，最后，将整个Buffer写入到Sink中！其实Okio已经提供了包装类 RealBufferedSink

理解了上面的Buffer（OKio提供的独特的字节数组管理类）和Sink(对Java OutputStream 的包装！提供超时，以及写入Buffer等方法) ，再看这个类的时候，还是比较简单的。

RealBufferedSink：它就是一个 Buffer + Sink ，它的数据先写到 Buffer中，然后等到某个时候再写到Sink中，内部管理了一个Buffer，相当于提供了一个缓冲。

//将一个 buffer 写入到 Sink 中 
@Override public void write(Buffer source, long byteCount)
      throws IOException {
    if (closed) throw new IllegalStateException("closed");
    // 现将数据写入 缓冲的Buffer中
    buffer.write(source, byteCount);
    emitCompleteSegments();
  }
  
  @Override public BufferedSink emitCompleteSegments() throws IOException {
    if (closed) throw new IllegalStateException("closed");
    // completeSegmentByteCount 方法 ，返回 可以写入 sink 中的字节的数量
    long byteCount = buffer.completeSegmentByteCount();
    // sink 的 write ，我们在前面说过了哦（就是对OutputStream的包装）
    if (byteCount > 0) sink.write(buffer, byteCount);
    return this;
  }

下面我们再来说下，OKio的 TimeOut ：
TimeOut 正如它的名字，给我们一种设置超时的能力，后面我们将会看到它配合Sink或者Source使用

Timeout类的注释中有两点，我们需要特别的注意：
Timeouts：提供了，单次操作的最长时间限制，一般可以用于网络行为，远程调用等

Deadlines ： 这次任务的最大用时限制，通过它可以设置这次任务的最大用时，一次任务，可能包括多次的单操作！

    TimeOut类的三个字段
    // 是否有 deadLine 
    private boolean hasDeadline;
    // deadLine 的时间 （时间点）
    private long deadlineNanoTime;
    // timeout的时间 （一段时间，0代表无穷大）
    private long timeoutNanos;

前面我们在分析Sink的源码中，发现 Sink的 write 方法中，每次都调用了 throwIfReached 方法：

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

    //就是检查 当前是否到达 deadlineNanoTime ，如果到达了，就直接抛出异常
    // 不过我们在Sink中，并没有设置deadlineNanoTime ，所以不会抛异常
    if (hasDeadline && deadlineNanoTime - System.nanoTime() <= 0) {
      throw new InterruptedIOException("deadline reached");
    }
  }

再看下TimeOut中最长的一个方法，用于同步等待任务的完成：

// 该方法，使用前必须已经获取 monitor 的内置锁了
 public final void waitUntilNotified(Object monitor) throws InterruptedIOException {
    try {
      boolean hasDeadline = hasDeadline();
      long timeoutNanos = timeoutNanos();
        // 如果没有设置deadLineTime ,并且 timeout为0，那么无限的等待
      if (!hasDeadline && timeoutNanos == 0L) {
        monitor.wait(); // There is no timeout: wait forever.
        return;
      }

      // 根据 deadLineTime 和 timeOut 计算出，要等待的时间
      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;
      }

      long elapsedNanos = 0L;
      if (waitNanos > 0L) {
        long waitMillis = waitNanos / 1000000L;
        // 等待
        monitor.wait(waitMillis, (int) (waitNanos - waitMillis * 1000000L));
        elapsedNanos = System.nanoTime() - start;
      }

      // 如果唤醒后发现，等待时间已经大于外滩Nanos了，那么直接抛出超时异常
      if (elapsedNanos >= waitNanos) {
        throw new InterruptedIOException("timeout");
      }
    } catch (InterruptedException e) {
      throw new InterruptedIOException("interrupted");
    }
  }

除了上面的TimeOut ， 还有一种 AsyncTimeout ，一般用在 Socket中：

// 实例化一个Sink，包装了 Socket的方法如下：
public static Sink sink(Socket socket) throws IOException {
    if (socket == null) throw new IllegalArgumentException("socket == null");
    // 构造 timeout 
    AsyncTimeout timeout = timeout(socket);
    // new 一个 Sink 对象 
    Sink sink = sink(socket.getOutputStream(), timeout);
    return timeout.sink(sink);
  }

我们来看 AsyncTimeout 的内部实现：

其实在其内部，维护了一个 AsyncTimeout 的队列，并且它内部包装了 Sink 和 Source，然后对Sink和Source的操作，都添加了 enter ，使他们能够支持 TimeOut。

在 AsyncTimeout 内部还有一个 Watchdog 线程，这个线程一直在 检查 之前说到的AsyncTimeout内部队列中的AsyncTimeout，如果某个AsyncTimeout被检测出超时了，那么Watchdog线程就会调用它的 timedOut 方法！

我们再返回Okio类中，继续看之前的对Socket 的 Sink 的包装，这里主要的就是，构造了一个新的AsyncTimeout , 并且复写了timedOut方法。

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

// 复写了 timedOut ， 这个方法是会被WatchDog 检测为超时时候调用
// 这里直接关闭Socket
      @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)) {
            // Catch this exception due to a Firmware issue up to android 4.2.2
            // https://code.google.com/p/android/issues/detail?id=54072
            logger.log(Level.WARNING, "Failed to close timed out socket " + socket, e);
          } else {
            throw e;
          }
        }
      }
    };
  }

简单的使用 TimeOut:

        File file = newFile("./test1.txt");
        BufferedSink sink = Okio.buffer(Okio.sink(file));
        sink.timeout().deadline(3, TimeUnit.SECONDS);
        // 模拟 一次 耗时操作
        Thread.sleep(3000);
        Buffer wordBuffer = new Buffer().writeUtf8("hello");
        sink.write(wordBuffer, wordBuffer.size());
        sink.flush();

如上代码，我们设置了Sink的deadline时间，然后模拟了一次耗时操作，最后我们将会得到超时的异常

至此，我们的Okio源码分析，已经结束，回顾总结下：

  1. Okio 中的Sink 和 Source 就是 对Java的Output和Input流的包装！在这里整合了超时等机制。
  2. Okio 还提供了 Sink 和Source的缓存版本，RealBufferedSink 和 RealBufferedSource 他们内部使用Okio的Buffer 缓冲！
  3. Okio的Buffer，内部使用Segment管理字节数组，当要将一个Buffer写入到另一个Buffer的时候，可以直接共享Segment，而不是拷贝内存数据！
  4. Okio提供了TimeOut，特别是 AsyncTimeout ，能够简单的帮助我们做超时处理
  5. Okio提供了相比与Java API 更加优雅好用的API！

我们 Okio 就分析到这里，后面我们会分析Okio在OkHttp中的使用，以及OkHttp的源码

你可能感兴趣的:(Okio 源码分析)

  • JVM源码分析之堆外内存完全解读 HeapDump性能社区
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • Java集合类框架源码分析 之 RoleList源码解析 【6】 yunzhonghefei Java集合类源码分析RoleList源码解析
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析 "小夜猫&小懒虫&小财迷"的男人 鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
  • Java高并发编程详解系列-深入理解Thread构造 nihui123 高并发Java高并发Java高并发
    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程 QT性能优化QT原理源码QT界面美化 qtqt6.3qt5c++QT教程
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
  • Jetpack LiveData源码分析 xiangxiongfly915 #AndroidJetpack系列JetpackLiveData源码分析
    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
  • ExoPlayer架构详解与源码分析（17）——TrackSelector 山雨楼 ExoPlayer架构android音视频ExoPlayerMedia3源码
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
  • ExoPlayer架构详解与源码分析（12）——Cache 山雨楼 ExoPlayer架构android音视频ExoPlayerMedia3源码
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4) 2401_83740189 程序员架构
    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
  • 【HarmonyOS】- 常见算法简单写法 数的羊都睡了 HarmonyOSArkTS鸿蒙
    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因 nangonghen dockerdocker
    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
  • dispatch_once源码分析 福伟_Y
    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
  • jQuery Easyui 源码分析之combo组件 90后北京程序员 前端-easyuieasyui之combobox
    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法 RemusrickCat
    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector Colourful． Java集合java集合
    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
  • React Native通讯原理 zbl_zbl androidReactNativ
    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
  • [linux 驱动]增加一个文件节点控制led灯亮灭 嵌入式成长家 linux内核的系统实战linux驱动linux驱动led灯驱动
    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
  • 【QT教程】QT6对话框编程 QT性能优化QT原理源码QT界面美化 qtqt6.3qt5c++QT教程
    QT6对话框编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6对话框编程基础1.1QT6对话框简介1.1.1QT6对话框简介QT6对话框简介
  • 鸿蒙轻内核M核源码分析系列十二 事件Event OpenHarmony_小贾 OpenHarmonyHarmonyOS鸿蒙开发harmonyosopenharmony鸿蒙内核鸿蒙开发移动开发嵌入式硬件驱动开发
    事件（Event）是一种任务间通信的机制，可用于任务间的同步。多任务环境下，任务之间往往需要同步操作，一个等待即是一个同步。事件可以提供一对多、多对多的同步操作。本文通过分析鸿蒙轻内核事件模块的源码，深入掌握事件的使用。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取
  • 鸿蒙轻内核M核源码分析系列四 中断Hwi OpenHarmony_小贾 鸿蒙开发OpenHarmonyHarmonyOSharmonyos单片机OpenHarmony嵌入式硬件鸿蒙开发移动开发鸿蒙内核
    在鸿蒙轻内核源码分析系列前几篇文章中，剖析了重要的数据结构。本文，我们讲述一下中断，会给读者介绍中断的概念，鸿蒙轻内核的中断模块的源代码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1、中断概念介绍中断是指出现需要时，CPU暂停执行当前程序，转而执行新程序的过程。当外设需要CPU时，将通过产生中断信号使CPU立即中断当前任务来响应中断请求。在剖析中断源代码之前，下面介绍些
  • 鸿蒙轻内核M核源码分析系列五 时间管理 OpenHarmony_小贾 HarmonyOSOpenHarmony鸿蒙开发harmonyosopenharmony鸿蒙开发NAPI鸿蒙内核移动开发嵌入式
    在鸿蒙轻内核源码分析上一篇文章中，我们剖析了中断的源码，简单提到了Tick中断。本文会继续分析Tick和时间相关的源码，给读者介绍鸿蒙轻内核的时间管理模块。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。时间管理模块以系统时钟为基础，可以分为2部分，一部分是SysT
  • 鸿蒙轻内核M核源码分析系列六 任务及任务调度（1）任务栈 OpenHarmony_小贾 鸿蒙开发OpenHarmonyHarmonyOSHarmonyOSopenharmony鸿蒙开发移动开发鸿蒙内核驱动开发嵌入式硬件
    继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈是高地址向低地址生长的递减栈，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_INIT代表的数值0xCACACACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最
  • 鸿蒙轻内核M核源码分析系列三 数据结构-任务排序链表 OpenHarmony_小贾 HarmonyOSOpenHarmony鸿蒙开发数据结构harmonyos移动开发OpenHarmony鸿蒙内核鸿蒙开发嵌入式硬件
    在鸿蒙轻内核源码分析系列一和系列二，我们分析了双向循环链表、优先级就绪队列的源码。本文会继续给读者介绍鸿蒙轻内核源码中重要的数据结构：任务排序链表TaskSortLinkAttr。鸿蒙轻内核的任务排序链表，用于任务延迟到期/超时唤醒等业务场景，是一个非常重要、非常基础的数据结构。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1任务排序链表我们先看下任务排序链接的数据结构。任
  • 鸿蒙轻内核A核源码分析系列七 进程管理 (2) OpenHarmony_小贾 HarmonyOS鸿蒙开发OpenHarmonyharmonyosOpenHarmony移动开发驱动开发鸿蒙内核LiteOS-A内核进程通信
    本文先熟悉下进程管理的文件kernel\base\core\los_process.c中的内部接口，读读代码，做些记录。1、LiteOS-A内核进程全局变量⑴是进程池，存放各个进程控制块LosProcessCB的信息。⑵处开始的g_freeProcess是空闲进程链表，挂载各个空闲进程控制块；g_processRecycleList是待回收进程控制块链表，挂载各个等待回收的进程控制块。⑶处开始的g
  • 鸿蒙原生开发——轻内核A核源码分析系列三 物理内存（2） OpenHarmony_小贾 鸿蒙开发HarmonyOSOpenHarmonyharmonyosopenharmony移动开发程序人生鸿蒙开发
    3.1.2.3函数OsVmPhysLargeAlloc当执行到这个函数时，说明空闲链表上的单个内存页节点的大小已经不能满足要求，超过了第9个链表上的内存页节点的大小了。⑴处计算需要申请的内存大小。⑵从最大的链表上进行遍历每一个内存页节点。⑶根据每个内存页的开始内存地址，计算需要的内存的结束地址，如果超过内存段的大小，则继续遍历下一个内存页节点。⑷处此时paStart表示当前内存页的结束地址，接下来
  • JsonCpp源码分析——Reader 哎呦，帅小伙哦 #jsoncppjson
    1、与Writer模块功能相反，可以将Reader理解成一个反序列化的工具，Writer的作用主要是将Value对象转成string或者流式的结构，Reader的作用主要是将流式的结构转成Value类型的对象。Reader类的主要职责有3个，解析JSON字符串：将JSON格式的字符串读取并解析成相应的C++数据结构。处理不同的数据类型，支持解析JSON对象、数组、字符串、数字、布尔值和null。处
  • vue源码分析-挂载流程和模板编译 yyzzabc123 vue.js
    前面几节我们从newVue创建实例开始，介绍了创建实例时执行初始化流程中的重要两步，配置选项的资源合并,以及响应式系统的核心思想，数据代理。在合并章节，我们对Vue丰富的选项合并策略有了基本的认知，在数据代理章节我们又对代理拦截的意义和使用场景有了深入的认识。按照Vue源码的设计思路，初始化过程还会进行很多操作，例如组件之间创建关联，初始化事件中心，初始化数据并建立响应式系统等，并最终将模板和数据
  • 鸿蒙内核解析,鸿蒙内核源码分析(内存概念篇)|解读鸿蒙源码 刘轩鸿 鸿蒙内核解析
    提示：本文基于开源鸿蒙内核分析，官方源码【kernel_liteos_a】官方文档【docs】参考文档【HuaweiLiteOS】本文作者：鸿蒙内核发烧友，用生活场景讲故事的方式去解构内核，一窥究竟，让神秘的内核栩栩如生，浮现眼前。博文全部原创，持续更新，敬请关注。内容仅代表个人观点，错误之处，欢迎大家指正完善。本系列全部文章进入鸿蒙源码分析(总目录)查看目录最难讲的章节坦白讲内存是整个系列里面最
  • 鸿蒙轻内核A核源码分析系列七 进程管理 (3) OpenHarmony_小贾 OpenHarmony鸿蒙开发HarmonyOSharmonyos嵌入式硬件OpenHarmony鸿蒙嵌入式鸿蒙开发鸿蒙内核进程关联
    本文记录下进程相关的初始化函数，如OsSystemProcessCreate、OsProcessInit、OsProcessCreateInit、OsUserInitProcess、OsDeInitPCB、OsUserInitProcessStart等。1、LiteOS-A内核进程创建初始化通用函数先看看一些内部函数，不管是初始化用户态进程还是内核态进程，都会使用这些函数，包含进程控制块初始化函数
  • redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSourceexpire/delincr/lpush数据库分区redis
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷）   1、关于JedisPool.returnSource(Jedis jeids)   这个方法是从red
  • SQL性能优化-持续更新中。。。。。。 atongyeye oraclesql
    1 通过ROWID访问表--索引 你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
         如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
  • lvs- real 男人50 LVS
    #!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #.  /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
  • 生成公钥和私钥 oloz DSA安全加密
    package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
  • UIView 中加入的cocos2d，背景透明 374016526 cocos2dglClearColor
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
  • mysql常用命令 香水浓 mysql
    连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
  • 我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScriptjquerycsshtml5
    系统层面： 高可用性 所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
  • 利用ant进行远程tomcat部署 aijuans tomcat
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
  • 获取复利总收入 baalwolf 获取
           public static void main(String args[]){         int money=200;         int year=1;         double rate=0.1; &
  • eclipse.ini解释 BigBird2012 eclipse
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
  • AngularJS实现分页功能 bijian1013 JavaScriptAngularJS分页
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。   &nbs
  • [Maven学习笔记三]Maven archetype bit1129 ArcheType
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等.   mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式，   mvn archetype   1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
  • 【Java命令三】jps bit1129 Java命令
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看   [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
  • ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
  • unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学unity教程unity视频unity资料unity
    unity 3d还是cocos2dx哪个适合游戏？ 问：unity 3d还是cocos2dx哪个适合游戏？ 答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java算法面试百度招聘
    import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
  • 获取checkbox复选框的值 chiangfai checkbox
    <title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
  • MySQLdb用户指南 chenchao051 mysqldb
    原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
  • HIVE 窗口及分析函数 daizj hive窗口函数分析函数
    窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询 一、分析函数 用于等级、百分点、n分片等。 函数             说明 RANK()     &nbs
  • PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHPzip
    PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
  • 精彩英语贺词 dcj3sjt126com 英语
    I'm always here              我会一直在这里支持你                &nb
  • 基于Java注解的Spring的IoC功能 e200702084 javaspringbeanIOCOffice
                                      
  • java模拟post请求 geeksun java
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。 此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
  • Swift语法之 ---- ?和!区别 hongtoushizi ?swift!
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html   Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
  • centos7安装jdk1.7 jisonami jdkcentos
    安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量 在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
  • 数据源架构模式之数据映射器 home198979 PHP架构数据映射器datamapper
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。   一、概念 数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
  • 在Python中使用MYSQL pda158 mysqlpython
    缘由 　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 数据库中。 　　了解到 Python在这方面有优势，便选用之。 　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 记录一下，大家共勉。 　　 python中mysql的调用 　　 百度之后能够通过MySQLdb进行数据库操作。
  • 单例模式 hxl1988_0311 java单例设计模式单件
    package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
  • 27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他