以编程方式计算Java对象占用的内存，包括它引用的对象[重复]

Question

我需要以编程方式准确找出给定 Java 对象占用了多少内存，包括它所引用的对象占用的内存。

我可以生成内存堆转储并使用工具分析结果。但是，生成堆转储以及此类工具读取转储以生成报告需要相当长的时间。鉴于我可能需要多次执行此操作，如果我可以在我的项目中添加一些代码来赋予我“运行时”这个价值，我的工作将会更加灵活。

我怎样才能最好地做到这一点？

ps：具体来说，我有一个 javax.xml.transform.Templates 类型的对象集合

Answer 1

您需要为此使用 反射。生成的代码太复杂了，我无法在此处发布（尽管它很快会作为我正在构建的 GPL 工具包的一部分提供），但主要思想是：

• 对象头使用 8 个字节（用于类指针和引用计数）
• 每个原始字段使用 1、2、4 或 8 个字节，具体取决于实际类型
• 每个对象引用（即非原始）字段使用 4 个字节（引用，加上被引用对象使用的任何内容）

您需要分别处理数组（8 字节的标头、4 字节的长度字段、4*length 字节的表，以及内部对象使用的任何内容）。您需要使用反射处理遍历字段（及其父字段）的其他类型的对象。

你还需要在递归过程中保留一组“seen”对象，以免多次计算多个地方引用的对象。

Answer 2

看起来已经有一个名为Classmexer 的实用程序可以执行此操作。

我自己没有尝试过，但我会在自己推出之前走那条路。

Answer 3

一个好的通用解决方案是使用堆大小增量。这涉及最少的工作，并且可以在任何类型的对象/对象图之间重用。通过多次实例化和销毁您的对象并在其间进行垃圾收集，然后取平均值，您可以避免编译器和 JVM 优化会改变结果并获得相当准确的结果。如果您需要精确到字节的答案，那么这可能不是您的解决方案，但对于我所知道的所有实际应用程序（分析、内存需求计算）来说，它工作得非常好。下面的代码就可以做到这一点。

    public class Sizeof {
      public static void main(String[] args)
          throws Exception {
        // "warm up" all classes/methods that we are going to use:
        runGC();
        usedMemory();

        // array to keep strong references to allocated objects:
        final int count = 10000; // 10000 or so is enough for small ojects
        Object[] objects = new Object[count];

        long heap1 = 0;

        // allocate count+1 objects, discard the first one:
        for (int i = -1; i < count; ++i) {
          Object object;

    //// INSTANTIATE YOUR DATA HERE AND ASSIGN IT TO 'object':


          object=YOUR OBJECT;
    ////end your code here
          if (i >= 0) {
            objects[i] = object;
          }
          else {
            object = null; // discard the "warmup" object
            runGC();
            heap1 = usedMemory(); // take a "before" heap snapshot
          }
        }

        runGC();
        long heap2 = usedMemory(); // take an "after" heap snapshot:

        final int size = Math.round(((float)(heap2 - heap1)) / count);
        System.out.println("'before' heap: " + heap1 +
                           ", 'after' heap: " + heap2);
        System.out.println("heap delta: " + (heap2 - heap1) +
                           ", {" + objects[0].getClass() + "} size = " + size + " bytes");
      }

      // a helper method for creating Strings of desired length
      // and avoiding getting tricked by String interning:
      public static String createString(final int length) {
        final char[] result = new char[length];
        for (int i = 0; i < length; ++i) {
          result[i] = (char)i;
        }

        return new String(result);
      }

      // this is our way of requesting garbage collection to be run:
      // [how aggressive it is depends on the JVM to a large degree, but
      // it is almost always better than a single Runtime.gc() call]
      private static void runGC()
          throws Exception {
        // for whatever reason it helps to call Runtime.gc()
        // using several method calls:
        for (int r = 0; r < 4; ++r) {
          _runGC();
        }
      }

      private static void _runGC()
          throws Exception {
        long usedMem1 = usedMemory(), usedMem2 = Long.MAX_VALUE;

        for (int i = 0; (usedMem1 < usedMem2) && (i < 1000); ++i) {
          s_runtime.runFinalization();
          s_runtime.gc();
          Thread.currentThread().yield();

          usedMem2 = usedMem1;
          usedMem1 = usedMemory();
        }
      }

      private static long usedMemory() {
        return s_runtime.totalMemory() - s_runtime.freeMemory();
      }

      private static final Runtime s_runtime = Runtime.getRuntime();

    } // end of class