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     }

 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     }

 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     }

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