1.堆外内存定义：

    堆外内存是相对于堆内内存的一个概念，堆内内存是由JVM所掌控的Java进程内存，我们平时在Java中创建的对象都处于堆内内存中，并且他们遵 循JVM的内存管理机制，JVM会采用垃圾回收机制统一管理它们的内存，那么堆外内存就是存在于JVM管控之外的一块内存区域，因此，它不直接虚拟机被管控。

核心API学习：

public class DirectByteBufferTest1 {

    public static void main(String[] args) {
        testRemaing();
    }

    /**
     * Position的位置是插入数据的当前位置，如果插入数据，就会自动后移.
     *
     * 也就是说，如果存储的是两个字节的数据，position的位置是在第三个字节上，下标就是2。
     */
    public static void testPosition(){
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
        byteBuffer.putChar('a');
        System.out.println(byteBuffer);
        byteBuffer.putChar('b');
        System.out.println(byteBuffer);
        byteBuffer.putInt(10);
        System.out.println(byteBuffer);
    }

    /**
     * capacity是当前申请的直接内存的容量，它是申请后就不会改变的。
     */
    public static void testPosition1(){
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
        System.out.println("capacity:" + byteBuffer.capacity());
    }

    /**
     * 改变这段直接内存的大小,注意limit要比mark和position大，比capacity小.
     */
    public static void testLimit(){
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
        System.out.println(byteBuffer.limit());
        byteBuffer.limit(1000);
        System.out.println(byteBuffer.limit());
    }

    /**
     *  mark，就是一个标记为而已，记录当前的position的值。常用的场景，就是记录某一次插入数据的位置，方便下一次进行回溯。
     */
    public static void testMark(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        buffer.putChar('a');
        buffer.putChar('c');
        System.out.println("插入完数据 " + buffer);
        // 记录mark的位置
        buffer.mark();
        // 设置的position一定要比mark大，否则mark无法重置
        buffer.position(30);
        System.out.println("reset前 " + buffer);
        // 重置reset ，reset后的position=mark
        buffer.reset();
        System.out.println("reset后 " + buffer);
        //清除标记，position变成0，mark变成-1
        buffer.rewind();
        System.out.println("清除标记后 " + buffer);
    }

    /**
     * remaing则表示当前的剩余空间
     */
    public static void testRemaing(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        System.out.println(buffer.remaining());
    }
    
    /**
     * clear清除mark和position，还有limit的位置：
     */
    public static void testClear(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        buffer.clear();
        System.out.println(buffer);
    }

    /**
     * flip:改变当前的Position为limit，主要是用于读取操作.
     */
    public static void testFlip(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        buffer.flip();
        System.out.println(buffer.limit());
        System.out.println(buffer.position());
    }

    /**
     * compact:这个方法在读取一部分数据的时候比较常用。
     *
     * 它会把当前的Position移到0，然后position+1移到1。
     */
    public static void testCompact(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(10);
        byte[] data = {1,2,3,4,5,6,7,8};
        buffer.put(data);
        System.out.println("写byte[]后 " + buffer);
        buffer.compact();
        System.out.println("compact 后：" + buffer);
        System.out.println(buffer.get(1));
    }

    /**
     * isDirect()
     *
     * 这个方法用于判断是否是直接内存。如果是返回true，如果不是返回false。
     */
    public static void testIsDirect(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(10);
        System.out.println(buffer.isDirect());
    }
    }

2. 直接内存读写实现

public class DirectByteBufferTest2 {

    public static void main(String[] args) {
        readFunction1();
    }

    /**
     * 写操作 - 1
     */
    public static void writeFunction1(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(10);
        byte[] data = {1,2};
        buffer.put(data);
        System.out.println("写byte[]后 " + buffer);
    }

    /**
     * 写操作 - 2
     */
    public static void writeFunction2(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(10);
        byte[] data = {1,2};
        buffer.put(data);
        System.out.println("写byte[]后 " + buffer);
        buffer.clear();
        buffer.put("hello".getBytes());
        System.out.println("写string后 " + buffer);
    }

    /**
     * 写操作 - 3
     */
    public static void writeFunction3(){
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        byte[] data = {1,2};
        buffer.put(data);
        System.out.println("写byte[]后 " + buffer);
        buffer.flip();
        System.out.println("");
        buffer.put("hello".getBytes());
        System.out.println("写string后 " + buffer);
    }

    /**
     * 读操作 - 1
     */
    public static void readFunction1() {
        ByteBuffer buffer = ByteBuffer.allocateDirect(10);
        buffer.put(new byte[]{1, 2, 3, 4});
        System.out.println("刚写完数据 " + buffer);
        buffer.flip();
        System.out.println("flip之后 " + buffer);
        byte[] target = new byte[buffer.limit()];
        buffer.get(target);
        //自动读取target.length个数据
        for (byte b : target) {
            System.out.print(b + " ");
        }
    }

}

3.直接内存内存回收原理以及源码分析

  1.作用链
  直接内存作用链：本地I/O -- 直接内存 -- 本地I/O
  堆内内存作用链：本地I/O -- 直接内存 -- 堆内内存 -- 本地I/O
  2.注意事项
  DirectBuffer并没有真正的向操作系统分配内存，其最终还是通过调用Unsafe的allocateMemory()来进行内存分配。不过JVM对    DirectMemory可申请的大小也有限制，可用-XX:MaxDirectMemorySize=1M设置，这部分内存不受JVM垃圾回收管理。
  3.内存分配

DirectByteBuffer(int cap) {                  

    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    /*
         首先向Bits类申请额度，Bits类内部维护着当前已经使用的堆外内存值，
        会check是当前申请的大小与已经使用的内存大小是否超过总的堆外内存大小
        （默认大小与堆内存一样），可以使用 -XX:MaxDirectMemorySize 重新设置。
        如果check不通过，会主动执行System.gc()，然后sleep 100ms，再进行check，
        如果内存还是不足，就抛出OOM Error。
    
    */
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        // 如果check通过，就会调用unsafe.allocateMemory真正分配内存，返回内存地址
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        // Round up to page boundary
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;



}

4.内存回收原理

Cleaner类，内部维护了一个Cleaner对象的链表，通过create(Object, Runnable)方法创建cleaner对象，调用自身的add方法，将其加入到链表中。
更重要的是提供了clean方法，clean方法首先将对象自身从链表中删除，保证只调用一次，然后执行this.thunk的run方法，thunk就是由创建时传入的Runnable参数，也就是说clean只负责触发Runnable的run方法，至于Runnable做什么任务它不关心。那DirectByteBuffer传进来的Runnable是什么呢？

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

}

5.自动回收

自动回收，当然由GC负责回收的，在GC时会扫描DirectByteBuffer对象否有是影响GC的引用，如没有，在回收DirectByteBuffer对象的同时且会回收其占用的堆外内存。但是JVM如何释放其占用的堆外内存呢？如何跟Cleaner关联起来呢？ 这得从Cleaner继承了PhantomReference引用说起。说到Reference，还有SoftReference、WeakReference、FinalReference他们作用各不相同，这里就不展开说了。 简单介绍PhantomReference（虚引用），首先虚引用不会影响JVM是否要GC这个对象的判断，当GC某个对象时，如果有此对象上还有虚引用，会将PhantomReference对象插入ReferenceQueue队列。 PhantomReference插入到哪个队列呢？ 看PhantomReference类代码，其继承自Reference，Reference对象有个ReferenceQueue成员，这个也就是PhantomReference对象插入的ReferenceQueue队列，此成员如果不由外部传入就是ReferenceQueue.NULL。如果需要通过queue拿到PhantomReference对象，这个ReferenceQueue对象还是必须由外部传入。 Reference 类内部static静态块会启动ReferenceHandler线程，线程优先级很高，这个线程是用来处理JVM在gc过程中交接过来的reference，并做一些处理。 我们来看看ReferenceHandler是如何处理的？直接看run方法，首先是个死循环，一直在那不停的干活，synchronized块内的这段主要是交接JVM扔过来的reference（就是pending），再往下看，很明显，调用了cleaner的clean方法。调完之后直接continue结束此次循环，这个reference并没有进入queue，也就是说Cleaner虚引用是不放入ReferenceQueue。

6.手动回收

手动回收，就是由开发手动调用DirectByteBuffer的cleaner的clean方法来释放空间。由于cleaner是private反问权限，所以自然想到使用反射来实现。

public static void clean(final ByteBuffer byteBuffer) {  

 if (byteBuffer.isDirect()) { 

        Field cleanerField = byteBuffer.getClass().getDeclaredField("cleaner");

        cleanerField.setAccessible(true);

        Cleaner cleaner = (Cleaner) cleanerField.get(byteBuffer);

        cleaner.clean();

    }

}

还有另一种方法，DirectByteBuffer实现了DirectBuffer接口，这个接口有cleaner方法可以获取cleaner对象

public static void clean(final ByteBuffer byteBuffer) {  

    if (byteBuffer.isDirect()) {  

        ((DirectBuffer)byteBuffer).cleaner().clean();  

    }  

}

7.Java直接内存与非直接内存性能测试

申请分配地址速度比较

int time = 10000000;
Date begin = new Date();
for(int i=0;i<time;i++){
    ByteBuffer buffer = ByteBuffer.allocate(2);
}
Date end = new Date();
System.out.println(end.getTime()-begin.getTime());
begin = new Date();
for(int i=0;i<time;i++){
    ByteBuffer buffer = ByteBuffer.allocateDirect(2);
}
end = new Date();
System.out.println(end.getTime()-begin.getTime());

测试结果

读写速度比较

int time = 1000;
Date begin = new Date();
ByteBuffer buffer = ByteBuffer.allocate(2*time);
for(int i=0;i<time;i++){
    buffer.putChar('a');
}
buffer.flip();
for(int i=0;i<time;i++){
    buffer.getChar();
}
Date end = new Date();
System.out.println(end.getTime()-begin.getTime());
begin = new Date();
ByteBuffer buffer2 = ByteBuffer.allocateDirect(2*time);
for(int i=0;i<time;i++){
    buffer2.putChar('a');
}
buffer2.flip();
for(int i=0;i<time;i++){
    buffer2.getChar();
}
end = new Date();
System.out.println(end.getTime()-begin.getTime());

测试结果