一文探讨堆外内存的监控与回收

结论：变量虽然置为了 null，但内存依旧持续占用。

CASE 2：分配 1G DirectByteBuffer，等待用户输入后，赋值为 null，手动触发 GC，之后阻塞持续观察堆外内存变化

			

				
				

					
					

						public class WriteByDirectByteBufferTest { 
					

				

				

					
					

						 public static void main(String[] args) throws IOException, InterruptedException { 
					

				

				

					
					

						 ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * 1024); 
					

				

				

					
					

						 System.in.read(); 
					

				

				

					
					

						 buffer = null; 
					

				

				

					
					

						 System.gc(); 
					

				

				

					
					

						 new CountDownLatch(1).await(); 
					

				

				

					
					

						 } 
					

				

				

					
					

						} 
					

				

			

结论：GC 时会触发堆外空闲内存的回收。

CASE 3：分配 1G DirectByteBuffer，等待用户输入后，手动回收堆外内存，之后阻塞持续观察堆外内存变化

			

				
				

					
					

						public class WriteByDirectByteBufferTest { 
					

				

				

					
					

						 public static void main(String[] args) throws IOException, InterruptedException { 
					

				

				

					
					

						 ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * 1024); 
					

				

				

					
					

						 System.in.read(); 
					

				

				

					
					

						 ((DirectBuffer) buffer).cleaner().clean(); 
					

				

				

					
					

						 new CountDownLatch(1).await(); 
					

				

				

					
					

						 } 
					

				

				

					
					

						} 
					

				

			

结论：手动回收可以立刻释放堆外内存，不需要等待到 GC 的发生。

对于 MappedByteBuffer 这个有点神秘的类，它的回收机制大概和 DirectByteBuffer 类似，体现在右边的 Mapped 之中，我们就不重复 CASE1 和 CASE2 的测试了，直接给出结论，在 GC 发生或者操作系统主动清理时 MappedByteBuffer 会被回收。但也不是不进行测试，我们会对 MappedByteBuffer 进行更有意思的研究。

CASE 4：手动回收 MappedByteBuffer。

			

				
				

					
					

						public class MmapUtil { 
					

				

				

					
					

						 public static void clean(MappedByteBuffer mappedByteBuffer) { 
					

				

				

					
					

						 ByteBuffer buffer = mappedByteBuffer; 
					

				

				

					
					

						 if (buffer == null || !buffer.isDirect() || buffer.capacity() == 0) 
					

				

				

					
					

						 return; 
					

				

				

					
					

						 invoke(invoke(viewed(buffer), "cleaner"), "clean"); 
					

				

				

					
					

						 } 
					

				

				

					
					

						


					

				

				

					
					

						 private static Object invoke(final Object target, final String methodName, final Class... args) { 
					

				

				

					
					

						 return AccessController.doPrivileged(new PrivilegedAction<Object>() { 
					

				

				

					
					

						 public Object run() { 
					

				

				

					
					

						 try { 
					

				

				

					
					

						 Method method = method(target, methodName, args); 
					

				

				

					
					

						 method.setAccessible(true); 
					

				

				

					
					

						 return method.invoke(target); 
					

				

				

					
					

						 } catch (Exception e) { 
					

				

				

					
					

						 throw new IllegalStateException(e); 
					

				

				

					
					

						 } 
					

				

				

					
					

						 } 
					

				

				

					
					

						 }); 
					

				

				

					
					

						 } 
					

				

				

					
					

						


					

				

				

					
					

						 private static Method method(Object target, String methodName, Class[] args) 
					

				

				

					
					

						 throws NoSuchMethodException { 
					

				

				

					
					

						 try { 
					

				

				

					
					

						 return target.getClass().getMethod(methodName, args); 
					

				

				

					
					

						 } catch (NoSuchMethodException e) { 
					

				

				

					
					

						 return target.getClass().getDeclaredMethod(methodName, args); 
					

				

				

					
					

						 } 
					

				

				

					
					

						 } 
					

				

				

					
					

						


					

				

				

					
					

						 private static ByteBuffer viewed(ByteBuffer buffer) { 
					

				

				

					
					

						 String methodName = "viewedBuffer"; 
					

				

				

					
					

						 Method[] methods = buffer.getClass().getMethods(); 
					

				

				

					
					

						 for (int i = 0; i < methods.length; i++) { 
					

				

				

					
					

						 if (methods[i].getName().equals("attachment")) { 
					

				

				

					
					

						 methodName = "attachment"; 
					

				

				

					
					

						 break; 
					

				

				

					
					

						 } 
					

				

				

					
					

						 } 
					

				

				

					
					

						 ByteBuffer viewedBuffer = (ByteBuffer) invoke(buffer, methodName); 
					

				

				

					
					

						 if (viewedBuffer == null) 
					

				

				

					
					

						 return buffer; 
					

				

				

					
					

						 else 
					

				

				

					
					

						 return viewed(viewedBuffer); 
					

				

				

					
					

						 } 
					

				

				

					
					

						} 
					

				

			

这个类曾经在我的《文件 IO 的一些最佳实践》中有所介绍，在这里我们将验证它的作用。编写测试类：

			

				
				

					
					

						public class WriteByMappedByteBufferTest { 
					

				

				

					
					

						 public static void main(String[] args) throws IOException, InterruptedException { 
					

				

				

					
					

						 File data = new File("/tmp/data.txt"); 
					

				

				

					
					

						 data.createNewFile(); 
					

				

				

					
					

						 FileChannel fileChannel = new RandomAccessFile(data, "rw").getChannel(); 
					

				

				

					
					

						 MappedByteBuffer map = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1024L * 1024 * 1024); 
					

				

				

					
					

						 System.in.read(); 
					

				

				

					
					

						 MmapUtil.clean(map); 
					

				

				

					
					

						 new CountDownLatch(1).await(); 
					

				

				

					
					

						 } 
					

				

				

					
					

						} 
					

				

			

结论：通过一顿复杂的反射操作，成功地手动回收了 Mmap 的内存映射。

CASE 5：测试 Mmap 的内存占用

			

				
				

					
					

						public class WriteByMappedByteBufferTest { 
					

				

				

					
					

						 public static void main(String[] args) throws IOException, InterruptedException { 
					

				

				

					
					

						 File data = new File("/tmp/data.txt"); 
					

				

				

					
					

						 data.createNewFile(); 
					

				

				

					
					

						 FileChannel fileChannel = new RandomAccessFile(data, "rw").getChannel(); 
					

				

				

					
					

						 for (int i = 0; i < 1000; i++) { 
					

				

				

					
					

						 fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1024L * 1024 * 1024); 
					

				

				

					
					

						 } 
					

				

				

					
					

						 System.out.println("map finish"); 
					

				

				

					
					

						 new CountDownLatch(1).await(); 
					

				

				

					
					

						 } 
					

				

				

					
					

						} 
					

				

			

我尝试映射了 1000G 的内存，我的电脑显然没有 1000G 这么大内存，那么监控是如何反馈的呢？

几乎在瞬间，控制台打印出了 map finish 的日志，也意味着 1000G 的内存映射几乎是不耗费时间的，为什么要做这个测试？就是为了解释内存映射并不等于内存占用，很多文章认为内存映射这种方式可以大幅度提升文件的读写速度，并宣称“写 MappedByteBuffer 就等于写内存”，实际是非常错误的认知。通过控制面板可以查看到该 Java 进程（pid 39040）实际占用的内存，仅仅不到 100M。(关于 Mmap 的使用场景和方式可以参考我之前的文章)

结论：MappedByteBuffer 映射出一片文件内容之后，不会全部加载到内存中，而是会进行一部分的预读（体现在占用的那 100M 上），MappedByteBuffer 不是文件读写的银弹，它仍然依赖于 PageCache 异步刷盘的机制。通过 Java VisualVM 可以监控到 mmap 总映射的大小，但并不是实际占用的内存量。

总结

本文借助一个线上问题，分析了使用堆内内存仍然会导致堆外内存分析的现象以及背后 JDK 如此设计的原因，并借助安装了插件之后的 Java VisualVM 工具进行了堆外内存的监控，进而讨论了如何正确的回收堆外内存，以及纠正了一个很多人对于 MappedByteBuffer 的错误认知。