java基础-DirectByteBuffer

我们可以通过ByteBuffer创建一块直接内存

ByteBuffer direct = ByteBuffer.allocateDirect(8);//创建8字节空间的直接内存

来看这块内存是如何被分配的

1     public static ByteBuffer allocateDirect(int capacity) {
2         return new DirectByteBuffer(capacity);
3     }

 1     DirectByteBuffer(int cap) {                   // package-private
 2         //mark, position, limit, capacity
 3         super(-1, 0, cap, cap);
 4         //后面的一大堆就是计算分配空间大小、分配、计算空间始址
 5         boolean pa = VM.isDirectMemoryPageAligned();
 6         int ps = Bits.pageSize();
 7         long size = Math.max(1L, (long)cap + (pa ? ps : 0));
 8         Bits.reserveMemory(size, cap);
 9 
10         long base = 0;
11         try {
12             base = unsafe.allocateMemory(size);//使用unsafe来分配直接内存
13         } catch (OutOfMemoryError x) {
14             Bits.unreserveMemory(size, cap);
15             throw x;
16         }
17         unsafe.setMemory(base, size, (byte) 0);
18         if (pa && (base % ps != 0)) {
19             // Round up to page boundary
20             address = base + ps - (base & (ps - 1));
21         } else {
22             //address是始址，可知一个DirectByteBuffer对象存储了内存始址address、内存容量capacity，这已经可以确定一块内存了，再加上position、limited、mark就可以对该内存进行缓存式的读写操作了
23             address = base;
24         }
25         cleaner = Cleaner.create(this, new Deallocator(base, size, cap));//用于回收直接内存
26         att = null;//attachement
27     }

对于内存空间，我们关注的是它的分配和回收，这里使用了unsafe分配，unsafe是一个提供了低等级操作的接口，这里就不研究它了，我们主要来看这块被unsafe分配的直接内存是如何被回收的。

我们知道，ByteBuffer和普通java对象一样，是通过gc回收的，但gc并不管理直接内存，ByteBuffer指向的直接内存空间是如何被释放的呢？

重点来看Cleaner.create(this, new Deallocator(base, size, cap))

Deallocator实现了Runnable，在run方法中使用unsafe.freeMemory(address)释放了内存。

 1     private static class Deallocator
 2         implements Runnable
 3     {
 4 
 5         private static Unsafe unsafe = Unsafe.getUnsafe();
 6 
 7         private long address;
 8         private long size;
 9         private int capacity;
10 
11         private Deallocator(long address, long size, int capacity) {
12             assert (address != 0);
13             this.address = address;
14             this.size = size;
15             this.capacity = capacity;
16         }
17 
18         public void run() {
19             if (address == 0) {
20                 // Paranoia
21                 return;
22             }
23             unsafe.freeMemory(address);
24             address = 0;
25             Bits.unreserveMemory(size, capacity);
26         }
27 
28     }

1     public static Cleaner create(Object var0, Runnable var1) {
2         //add是将cleaner实例存入由Cleaner维护的一个链表中，这里的var0是DirectByteBuffer，var1是Deallocator
3         return var1 == null ? null : add(new Cleaner(var0, var1));
4     }
5     private Cleaner(Object var1, Runnable var2) {
6         //Cleaner继承了PhantomReference，dummyQueue是一个假队列，无用。这里将DirectByteBuffer作为PhantomReference，Deallocator为thunk
7         super(var1, dummyQueue);
8         this.thunk = var2;
9     }

之前有聊过Reference机制对于Cleaner的特殊处理，当HandlerThread从pending队列中取到cleaner后，会执行其clean方法。下面就是clean方法，其中调用了thunk.run，该thunk对应Deallocator，run方法中就包含了unsafe.freeMemory，就此直接内存被释放了。

 1     public void clean() {
 2         if (remove(this)) {//从链表中删除该cleaner
 3             try {
 4                 this.thunk.run();//执行Runnable逻辑
 5             } catch (final Throwable var2) {
 6                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
 7                     public Void run() {
 8                         if (System.err != null) {
 9                             (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
10                         }
11 
12                         System.exit(1);
13                         return null;
14                     }
15                 });
16             }
17         }
18     }

总结一下，申请直接内存其实就是构造了一个DirectByteBuffer实例，该实例会持有一个cleaner实例，当不再有强引用指向我们创建的DirectByteBuffer实例时，gc就会回收该实例，与此同时，PhantomReference类型的Cleaner也会被HandlerThread捕获，并执行clean方法，该clean方法会调用thunk.run，对于DirectByteBuffer来说，thunk就是Deallocator，故直接内存得以释放。

由上述可知，我们也可以自己控制直接内存的分配和释放

1         long address = unsafe.allocateMemory(size);//分配
2         unsafe.freeMemory(address);//释放