Java NIO: DirectBuffer

DirectByteBuffer(int cap) {
    super(-1, 0, cap, cap);
    // 判断是否需要页面对齐，通过参数-XX:+PageAlignDirectMemory控制，默认为false
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    // 如果不设置内存对齐，size和cap值一样
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    //保留待分配内存
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        // 通过unsafe.allocateMemory分配堆外内存，并返回堆外内存的基地址
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
        // 内存分配失败，取消预占内存
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    // 初始化所有内存空间为0
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        // 页对齐
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    // 构建Cleaner对象用于跟踪DirectByteBuffer对象的垃圾回收，以实现当DirectByteBuffer被垃圾回收时，堆外内存也会被释放
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

static void reserveMemory(long size, int cap) {
        if (!memoryLimitSet && VM.isBooted()) {
            maxMemory = VM.maxDirectMemory();
            memoryLimitSet = true;
        }
        // 乐观锁，内部逻辑是尝试循环CAS更新内存占用
        if (tryReserveMemory(size, cap)) {
            return;
        }
        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();

        // jlra.tryHandlePendingReference()会触发一次非堵塞的Reference#tryHandlePending(false)。
        // 该方法会将已经被JVM垃圾回收的DirectBuffer对象的堆外内存释放。
        while (jlra.tryHandlePendingReference()) {
            if (tryReserveMemory(size, cap)) {
                return;
            }
        }
        // 如果已经没有足够空间，则尝试手动触发一次Full GC，触发释放堆外内存
        // 如果显式的设置-XX:+DisableExplicitGC来禁用显式GC，则System.gc()无效
        System.gc();

        // 调用System.gc()并不能够保证Full gc马上就能被执行。
        // 所以接下来while循环尝试了最大9次
        // 如果还是没有足够内存则抛出OutOfMemoryError("Direct buffer memory”)异常。 
        boolean interrupted = false;
        try {
            long sleepTime = 1;
            int sleeps = 0;
            while (true) {
                if (tryReserveMemory(size, cap)) {
                    return;
                }
                if (sleeps >= MAX_SLEEPS) {
                    break;
                }
                if (!jlra.tryHandlePendingReference()) {
                    try {
                        Thread.sleep(sleepTime);
                        sleepTime <<= 1;
                        sleeps++;
                    } catch (InterruptedException e) {
                        interrupted = true;
                    }
                }
            }

            // no luck
            throw new OutOfMemoryError("Direct buffer memory");

        } finally {
            if (interrupted) {
                // don't swallow interrupts
                Thread.currentThread().interrupt();
            }
        }
    }

private static class Deallocator implements Runnable
{
    private static Unsafe unsafe = Unsafe.getUnsafe();
    private long address;
    private long size;
    private int capacity;
    private Deallocator(long address, long size, int capacity) {
        assert (address != 0);
        this.address = address;
        this.size = size;
        this.capacity = capacity;
    }
    public void run() {
        if (address == 0) {
            // Paranoia
            return;
        }
        unsafe.freeMemory(address);
        address = 0;
        Bits.unreserveMemory(size, capacity);
    }
}

 public ByteBuffer get(byte[] dst, int offset, int length) {
  // JNI_COPY_TO_ARRAY_THRESHOLD = 6
  if (((long)length << 0) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
      checkBounds(offset, length, dst.length);
      int pos = position();
      int lim = limit();
      assert (pos <= lim);
      int rem = (pos <= lim ? lim - pos : 0);
      if (length > rem)
          throw new BufferUnderflowException();
          Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
                            (long)offset << 0,
                            (long)length << 0);
      position(pos + length);
  } else {
      super.get(dst, offset, length);
  }
  return this;
}
static void copyToArray(long srcAddr, Object dst, long dstBaseOffset, long dstPos,
                        long length)
{
    long offset = dstBaseOffset + dstPos;
    // 分批进行(UNSAFE_COPY_THRESHOLD= 1024L * 1024L = 1M)
    while (length > 0) {
        long size = (length > UNSAFE_COPY_THRESHOLD) ? UNSAFE_COPY_THRESHOLD : length;
        unsafe.copyMemory(null, srcAddr, dst, offset, size);
        length -= size;
        srcAddr += size;
        offset += size;
    }
}