A heap dump is a snapshot of the memory of a Java process at a certain point of time. There are different formats for persisting this data, and depending on the format it may contain different pieces of information, but in general the snapshot contains information about the java objects and classes in the heap at the moment the snapshot was triggered. Usually a full GC is triggered before the heap dump is written so it contains information about the remaining objects.

　heap dump是特定时间点，java进程的内存快照。它有多种格式存储内存数据，通用的快照被触发时java对象和类在heap中的情况。通常一个gc动作在生成heap dump之前，所以它包含的剩余的没有被gc的对象。一般内存快照生成.hprof 等文件。

　　The Memory Analyzer is able to work with HPROF binary heap dumps, IBM system dumps (after preprocessing them), and IBM portable heap dumps (PHD) from a variety of platforms.

　Memory Analyzer 是一个可以打开很多格式heap dump文件的工具。

　　Typical information which can be found in heap dumps (once more - depending on the heap dump type) is:

　典型的heap dump有下面几个信息：

• All Objects

  　　Class, fields, primitive values and references

  类，属性，原始值，引用。

• All Classes

  　　Classloader, name, super class, static fields

  类加载器，名字，父类，静态属性。

• Garbage Collection Roots

  　　Objects defined to be reachable by the JVM

  jvm使用的对象

• Thread Stacks and Local Variables

  　　The call-stacks of threads at the moment of the snapshot, and per-frame information about local objects

  线程栈，本地对象。

　　A heap dump does not contain allocation information so it cannot resolve questions like who had created the objects and where they have been created.

　　heap dump中不含分配信息，所以不提示对象在哪里分配，被谁分配。

　Shallow heap是对象占用内存的大小。一个引用占 32／64 bits，一个inter占4bytes，一个long占8 bytes等。

　Retained set 是引用的外部对象的集合，它应该被gc回收。

　Retained heap 大小是retained set内应被回收的对象的shallow size总和。

　对象的shallow heap是它在堆上占用的大小。　对象的retained size 是将要释放的堆大小。

　Leading set 是retained set子集，它内存存放一些重要的关键点对象，比如一些特殊的类，或特殊加载类加载的类，或一些有专门工作的对象。retained size就是retained set内所有对象大小之和。　关于Leading set与 Retained Set 请参看下面例子：

　　Memory Analyzer provides a dominator tree of the object graph. The transformation of the object reference graph into a dominator tree allows you to easily identify the biggest chunks of retained memory and the keep-alive dependencies among objects. Bellow is an informal definition of the terms.

　Memory Analyzer工具提供了对象控制者树，它由描述，它可以让你轻松的标识出引用的最大内存块，和其中仍然活跃的对象。　下面是它们之间关系的非正式定义：

　　An object x dominates an object y if every path in the object graph from the start (or the root) node to y must go through x.

　x控制y的定义：从图中开始顶点到顶点 y ,必经过x，那么x控制y。

　　The immediate dominator x of some object y is the dominator closest to the object y.

　y的最近控制者：离y最近的控制y的顶点。

　　A dominator tree is built out of the object graph. In the dominator tree each object is the immediate dominator of its children, so dependencies between the objects are easily identified.

　Dominator tree 是根据控制对象关系的图生成的一棵树，其中每个节点都是它子树的控制者。　它主要有下面几个特点：

　　The dominator tree has the following important properties:

• The objects belonging to the sub-tree of x (i.e. the objects dominated by x ) represent the retained set of x .

  每个节点的大小包含其子树节点大小。

• If x is the immediate dominator of y , then the immediate dominator of x also dominates y , and so on.

  控制有传递性。

• The edges in the dominator tree do not directly correspond to object references from the object graph.

  根节点不对应图中的顶点。如下：

　　Garbage Collections Roots (GC roots) are objects that are kept alive by the Virtual Machines itself. These include for example the thread objects of the threads currently running, objects currently on the call stack and classes loaded by the system class loader.

　　The (reverse) reference chain from an object to a GC root - the so called path to GC roots - explains why the object cannot be garbage collected. The path helps solving the classical memory leak in Java: those leaks exist because an object is still referenced even though the program logic will not access the object anymore.

　GC Roots 是JVM 管理的对象集而非java进程堆中的对象。　这和Figure1 描述的有点不同：　还有些讨论： http://stackoverflow.com/questions/6366211/what-are-the-roots

　　The Garbage Collector (GC)  is responsible for removing objects that will never be accessed anymore. Objects cannot be accessed if they are not reachable through any reference chain. The starting point of this analysis are the Garbage Collection Roots, i.e. objects that are assumed to be reachable by the virtual machine itself. Objects that are reachable from the GC roots remain in memory, objects that are not reachable are garbage collected.

　　Common GC Roots are objects on the call stack of the current thread (e.g. method parameters and local variables), the thread itself, classes loaded by the system class loader and objects kept alive due to native code.

　　GC Roots are very important when determining why an object is still kept in memory: The reference chain from an arbitrary object to the GC roots (Path to GC Roots...) tells who is accidentally keeping a reference.

　　A garbage collection root is an object that is accessible from outside the heap. The following reasons make an object a GC root:

　一个 GC root 是一个内存堆外部的对象，一般产生它的原因如下：

由系统类加载。比如 rt.jar内java.util.*;包下的类。

有本地局部变量的引用，比如在本地jni代码或jvm中。

有本地全局变量的引用，

被阻塞的线程引用。

有没有停止的线程。

同步等待中。静态方法意味着类，非静态方法意味着对象。

本地变量仍然在栈呀线程中。

本地代码的参数或返回值。

对象处在定稿队列。

一个对象拥有还没有定稿的方法，且还没有加入到定稿队列。

一个在mat分析器搜索范围之外的对象。

把Java Stack frames 当作了一个对象。

不识别的类型。