Java内存使用量测试

JVM内存使用量测试
测试各种不同的数据结构在JVM中的内存使用量

 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;

 import java.lang.management.ManagementFactory;
 import java.lang.management.MemoryMXBean;
 import java.lang.management.MemoryUsage;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 /** JVM内存使用量测试
  * 测试各种不同的数据结构在JVM中的内存使用量
  */
 public class MemUsageTest
 {
     static final long KILO = 1024L;
     static final long MEGA = KILO * KILO;

     static double divide(long a, long b) {
         return ((double)a)/b;
     }
     static StringBuilder sbMem = new StringBuilder(16);
     static String memStr(long mem) {
         return memStr(mem, null);
     }
     static String memStr(long mem, String msg) {
         sbMem.setLength(0);
         if(msg==null || msg.length()==0){

         }else{
             sbMem.append(msg).append(": ");
         }

         if(mem == 0){
             sbMem.append("0");
             return sbMem.toString();
         }

         if(mem < 0){
             sbMem.append("- ");
             mem = -mem;
         }
         if(mem >= MEGA){
             sbMem.append(mem / MEGA);
             sbMem.append("M ");
             mem %= MEGA;
         }
         if(mem >= KILO){
             sbMem.append(mem / KILO);
             sbMem.append("K ");
             mem %= KILO;
         }
         if(mem > 0){
             sbMem.append(mem);
             sbMem.append("B");
         }
         return sbMem.toString();
     }

     static final Runtime RUNTIME = Runtime.getRuntime();
     static final MemoryMXBean MEM_MXBEAN = ManagementFactory.getMemoryMXBean();
     static long LAST_MEM = 0;
     public static void printMemUsage() {
         printMemUsage(null);
     }
     public static void printMemUsage(String msg) {
         if(msg==null || msg.length()==0){
             System.out.println("==================== MemUsage ====================");
         }else{
             System.out.println("==================== MemUsage ("+msg+") ====================");
         }
         System.gc();

         /*System.out.println(divide(RUNTIME.totalMemory()-RUNTIME.freeMemory(), MEGA));//usage.getUsed()
         System.out.println(divide(RUNTIME.totalMemory(), MEGA));//usage.getCommitted()
 */        //System.out.println(divide(RUNTIME.maxMemory(), MEGA));//usage.getMax()

         MemoryUsage usage = MEM_MXBEAN.getHeapMemoryUsage();
         //usage = MEM_MXBEAN.getNonHeapMemoryUsage();
         //System.out.println(memStr(usage.getInit()));
         System.out.println(memStr(usage.getUsed(), "使用量       "));//使用量
         System.out.println(memStr(usage.getUsed()-LAST_MEM, "使用量增量"));//使用量增量
         System.out.println(memStr(usage.getCommitted(), "提交总量   "));//提交总量
         //System.out.println(memStr(usage.getMax()));

         //if(LAST_MEM <= 0){
             LAST_MEM = usage.getUsed();
         //}
     }

     public static int same(int i){
         return i;
     }
     public static Object same(Object i){
         return i;
     }

     static String[] strs;
     static Object[] objs;
     static int[] ints;
     static Integer[] integers;
     static Set<Integer> integerSet;
     public static void main( String[] args )
     {
         printMemUsage();

         //String[]
         //每个对象平均占用60B
         strs = new String[(int) MEGA];
         printMemUsage("String[]");

         int i;
         for(i=0;i<strs.length;i++){
             //strs[i] = "";
             //strs[i] = new String("");
             strs[i] = String.format("%08d", i);
             //strs[i] = String.valueOf(Math.random());
         }
         printMemUsage();

         strs = null;
         printMemUsage();

         //Object[]
         //每个对象平均占用20B
         objs = new Object[(int) MEGA];
         printMemUsage("Object[]");

         for(i=0;i<objs.length;i++){
             objs[i] = new Object();
         }
         printMemUsage();

         objs = null;
         printMemUsage();

         //int[]
         //每个对象平均占用4B
         ints = new int[(int) MEGA];
         printMemUsage("int[]");

         for(i=0;i<ints.length;i++){
             ints[i] = same(i);
         }
         printMemUsage();

         ints = null;
         printMemUsage();

         //Integer[]
         //每个对象平均占用20B
         integers = new Integer[(int) MEGA];
         printMemUsage("Integer[]");

         for(i=0;i<integers.length;i++){
             integers[i] = i;
         }
         printMemUsage();

         integers = null;
         printMemUsage();

         //HashSet<Integer>
         //每个对象平均占用56B
         integerSet = new HashSet<Integer>(1000000);
         printMemUsage("HashSet<Integer>");

         for(i=0;i<MEGA;i++){
             integerSet.add(i);
         }
         printMemUsage();

         integerSet = null;
         printMemUsage();

         //fastutil.IntOpenHashSet
         //每个对象平均占用8B
         integerSet = new IntOpenHashSet(1000000);
         printMemUsage("fastutil.IntOpenHashSet");

         for(i=0;i<MEGA;i++){
             ((IntOpenHashSet)integerSet).add(i);
         }
         printMemUsage();

         integerSet = null;
         printMemUsage();
     }
 }

运行结果如下，由此可见JVM对String、Object、封装类型（如Integer）等的存储均有较大的消耗。

使用fastutil的集合类，可以比Java系统集合类节省不少的内存空间，因为HashMap、HashSet等类不仅不支持直接存放原始类型int，而且还要把存储的对象封装成Node（哈希桶链表的节点），这里消耗的内存空间比fastutil多出了7倍之多！

==================== MemUsage ====================
使用量       : 1M 187K 384B
使用量增量: 1M 187K 384B
提交总量   : 123M
==================== MemUsage (String[]) ====================
使用量       : 4M 546K 128B
使用量增量: 3M 358K 768B
提交总量   : 123M
==================== MemUsage ====================
使用量       : 60M 730K 728B
使用量增量: 56M 184K 600B
提交总量   : 622M 512K
==================== MemUsage ====================
使用量       : 730K 712B
使用量增量: - 60M 16B
提交总量   : 632M 512K
==================== MemUsage (Object[]) ====================
使用量       : 4M 730K 728B
使用量增量: 4M 16B
提交总量   : 606M
==================== MemUsage ====================
使用量       : 20M 730K 728B
使用量增量: 16M
提交总量   : 631M
==================== MemUsage ====================
使用量       : 730K 712B
使用量增量: - 20M 16B
提交总量   : 631M 512K
==================== MemUsage (int[]) ====================
使用量       : 4M 730K 728B
使用量增量: 4M 16B
提交总量   : 629M 512K
==================== MemUsage ====================
使用量       : 4M 730K 728B
使用量增量: 0
提交总量   : 602M
==================== MemUsage ====================
使用量       : 730K 712B
使用量增量: - 4M 16B
提交总量   : 629M
==================== MemUsage (Integer[]) ====================
使用量       : 4M 730K 728B
使用量增量: 4M 16B
提交总量   : 606M
==================== MemUsage ====================
使用量       : 20M 728K 728B
使用量增量: 15M 1022K
提交总量   : 625M 512K
==================== MemUsage ====================
使用量       : 730K 712B
使用量增量: - 19M 1022K 16B
提交总量   : 627M 512K
==================== MemUsage (HashSet<Integer>) ====================
使用量       : 730K 952B
使用量增量: 240B
提交总量   : 627M 512K
==================== MemUsage ====================
使用量       : 56M 729K 368B
使用量增量: 55M 1022K 440B
提交总量   : 628M
==================== MemUsage ====================
使用量       : 731K 288B
使用量增量: - 55M 1022K 80B
提交总量   : 642M
==================== MemUsage (fastutil.IntOpenHashSet) ====================
使用量       : 8M 795K 288B
使用量增量: 8M 64K
提交总量   : 610M
==================== MemUsage ====================
使用量       : 8M 751K 152B
使用量增量: - 44K 136B
提交总量   : 638M
==================== MemUsage ====================
使用量       : 751K 88B
使用量增量: - 8M 64B
提交总量   : 602M