2. 如何监控Java垃圾回收机制

淡淡的烟草味﹌ 2022-09-24 01:26 143阅读 0赞

http://blog.csdn.net/zhoudaxia/article/details/26102203

本文是成为Java GC专家系列文章的第二篇。在第一篇《[深入浅出Java垃圾回收机制][Java]》中我们学习了不同GC算法的执行过程，GC是如何工作的，什么是新生代和老年代，你应该了解的JDK7中的5种GC类型，以及这5种类型对于应用性能的影响。

在本文中，我将解释**JVM到底是如何执行垃圾回收处理的**。

# **什么是GC监控？** #

**　　垃圾回收收集监控**指的是搞清楚JVM如何执行GC的过程，例如，我们可以查明：

1. 何时一个新生代中的对象被移动到老年代时，所花费的时间。

2. Stop-the-world 何时发生的，持续了多长时间。

GC监控是为了鉴别JVM是否在高效地执行GC，以及是否有必要进行额外的性能调优。基于以上信息，我们可以修改应用程序或者调整GC算法（GC优化）。

# **如何监控GC** #

有很多种方法可以监控GC，但其差别仅仅是GC操作通过何种方式展现而已。GC操作是由JVM来完成，而GC监控工具只是将JVM提供的GC信息展现给你，因此，不论你使用何种方式监控GC都将得到相同的结果。所以你也就不必去学习所有的监控GC的方法。但是因为学习每种监控方法不会占用太多时间，了解多一点可以帮助你根据不同的场景选择最为合适的方式。

下面所列的工具以及JVM参数并不适用于所有的HVM供应商。这是因为并没有关于GC信息的强制标准。本文我们将使用HotSpot JVM (Oracle JVM)。因为NHN 一直在使用Oracle (Sun) JVM，所以用它作为示例来解释我们提到的工具和JVM参数更容易些。  
首先，GC监控方法根据访问的接口不同，可以分成CUI 和GUI 两大类。**CUI GC监控方法使用一个独立的叫做”jstat”的CUI应用，或者在启动JVM的时候选择JVM参数”verbosegc”。  
　　GUI GC监控由一个单独的图形化应用来完成，其中三个最常用的应用是”jconsole”, “jvisualvm” 和 “Visual GC”。**  
　　下面我们来详细学习每种方法。

# **jstat** #

jstat 是HotSpot JVM提供的一个监控工具。其他监控工具还有jps 和jstatd。有些时候，你可能需要同时使用三种工具来监控你的应用。jstat 不仅提供GC操作的信息，还提供类装载操作的信息以及运行时编译器操作的信息。本文将只涉及jstat能够提供的信息中与监控GC操作信息相关的功能。  
　　jstat 被放置在$JDK\_HOME/bin。因此只要java 和 javac能执行，jstat 同样可以执行。  
　　你可以在命令行环境下执行如下语句。

**\[plain\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1. $> jstat –gc  $<vmid$> 1000  
2.    
3. S0C       S1C       S0U    S1U      EC         EU          OC         OU         PC         PU         YGC     YGCT    FGC      FGCT     GCT  
4. 3008.0   3072.0    0.0     1511.1   343360.0   46383.0     699072.0   283690.2   75392.0    41064.3    2540    18.454    4      1.133    19.588  
5. 3008.0   3072.0    0.0     1511.1   343360.0   47530.9     699072.0   283690.2   75392.0    41064.3    2540    18.454    4      1.133    19.588  
6. 3008.0   3072.0    0.0     1511.1   343360.0   47793.0     699072.0   283690.2   75392.0    41064.3    2540    18.454    4      1.133    19.588  
7.    
8. $>

在上图的例子中，实际的数据会按照如下列输出：

**\[plain\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  S0C    S1C     S0U     S1U    EC     EU     OC     OU     PC

vmid (虚拟机 ID)，正如其名字描述的，它是虚拟机的ID，Java应用不论运行在本地还是远程的机器都会拥有自己独立的vmid。运行在本地机器上的vmid称之为lvmid (本地vmid)，通常是PID。如果想得到PID的值你可以使用ps命令或者windows任务管理器，但我们推荐使用jps来获取，因为PID和lvmid有时会不一致。jps 通过Java PS实现，**jps命令会返回vmids和main方法的信息，**正如ps命令展现PIDS和进程名字那样。  
　　首先通过jps命令找到你要监控的Java应用的vmid，并把它作为jstat的参数。当几个WAS实例运行在同一台设备上时，如果你只使用jps命令，将只能看到启动（bootstrap）信息。我们建议在这种情况下使用ps -ef | grep java与jps配合使用。  
　　想要得到GC性能相关的数据需要持续不断地监控，因此在执行jstat时，要规则地输出GC监控的信息。  
　　例如，执行”jstat –gc 1000″ (或 1s)会每隔一秒展示GC监控数据。”jstat –gc 1000 10″会每隔1秒展现一次，且一共10次。

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
 <tr> 
 <td> 参数名称 </td> 
 <td> 描述 </td> 
 </tr> 
 <tr> 
 <td> gc </td> 
 <td> 输出每个堆区域的当前可用空间以及已用空间（伊甸园，幸存者等等），GC执行的总次数，GC操作累计所花费的时间。 </td> 
 </tr> 
 <tr> 
 <td> gccapactiy </td> 
 <td> 输出每个堆区域的最小空间限制（ms）/最大空间限制（mx），当前大小，每个区域之上执行GC的次数。（不输出当前已用空间以及GC执行时间）。 </td> 
 </tr> 
 <tr> 
 <td> gccause </td> 
 <td> 输出-gcutil提供的信息以及最后一次执行GC的发生原因和当前所执行的GC的发生原因 </td> 
 </tr> 
 <tr> 
 <td> gcnew </td> 
 <td> 输出新生代空间的GC性能数据 </td> 
 </tr> 
 <tr> 
 <td> gcnewcapacity </td> 
 <td> 输出新生代空间的大小的统计数据。 </td> 
 </tr> 
 <tr> 
 <td> gcold </td> 
 <td> 输出老年代空间的GC性能数据。 </td> 
 </tr> 
 <tr> 
 <td> gcoldcapacity </td> 
 <td> 输出老年代空间的大小的统计数据。 </td> 
 </tr> 
 <tr> 
 <td> gcpermcapacity </td> 
 <td> 输出持久带空间的大小的统计数据。 </td> 
 </tr> 
 <tr> 
 <td> gcutil </td> 
 <td> 输出每个堆区域使用占比，以及GC执行的总次数和GC操作所花费的事件。 </td> 
 </tr> 
 </tbody> 
</table>

**　　你可以只关心那些最常用的命令，你会经常用到 -gcutil (或-gccause), -gc and –gccapacity。**

·   -gcutil 被用于检查堆间的使用情况，GC执行的次数以及GC操作所花费的时间。

·   -gccapacity以及其他的参数可以用于检查实际分配内存的大小。

**　　使用-gc 参数你可以看到如下输出：**

**\[plain\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  S0C      S1C    …   GCT  
2.  1248.0   896.0  …   1.246  
3.  1248.0   896.0  …   1.246  
4.  …        …      …   …

不同的jstat参数输出不同类型的列，如下表所示，根据你使用的”jstat option”会输出不同列的信息。

<table> 
 <tbody> 
 <tr> 
 <td>列</td> 
 <td>说明</td> 
 <td>Jstat参数</td> 
 </tr> 
 <tr> 
 <td>S0C</td> 
 <td>输出Survivor0空间的大小。单位KB。</td> 
 <td>-gc -gccapacity -gcnew -gcnewcapacity</td> 
 </tr> 
 <tr> 
 <td>S1C</td> 
 <td>输出Survivor1空间的大小。单位KB。</td> 
 <td>-gc -gccapacity -gcnew -gcnewcapacity</td> 
 </tr> 
 <tr> 
 <td>S0U</td> 
 <td>输出Survivor0已用空间的大小。单位KB。</td> 
 <td>-gc -gcnew</td> 
 </tr> 
 <tr> 
 <td>S1U</td> 
 <td>输出Survivor1已用空间的大小。单位KB。</td> 
 <td>-gc -gcnew</td> 
 </tr> 
 <tr> 
 <td>EC</td> 
 <td>输出Eden空间的大小。单位KB。</td> 
 <td>-gc -gccapacity -gcnew -gcnewcapacity</td> 
 </tr> 
 <tr> 
 <td>EU</td> 
 <td>输出Eden已用空间的大小。单位KB。</td> 
 <td>-gc -gcnew</td> 
 </tr> 
 <tr> 
 <td>OC</td> 
 <td>输出老年代空间的大小。单位KB。</td> 
 <td>-gc -gccapacity -gcold -gcoldcapacity</td> 
 </tr> 
 <tr> 
 <td>OU</td> 
 <td>输出老年代已用空间的大小。单位KB。</td> 
 <td>-gc -gcold</td> 
 </tr> 
 <tr> 
 <td>PC</td> 
 <td>输出持久代空间的大小。单位KB。</td> 
 <td>-gc -gccapacity -gcold -gcoldcapacity -gcpermcapacity</td> 
 </tr> 
 <tr> 
 <td>PU</td> 
 <td>输出持久代已用空间的大小。单位KB。</td> 
 <td>-gc -gcold</td> 
 </tr> 
 <tr> 
 <td>YGC</td> 
 <td>新生代空间GC时间发生的次数。</td> 
 <td>-gc -gccapacity -gcnew -gcnewcapacity -gcold -gcoldcapacity -gcpermcapacity -gcutil -gccause</td> 
 </tr> 
 <tr> 
 <td>YGCT</td> 
 <td>新生代GC处理花费的时间。</td> 
 <td>-gc -gcnew -gcutil -gccause</td> 
 </tr> 
 <tr> 
 <td>FGC</td> 
 <td>full GC发生的次数。</td> 
 <td>-gc -gccapacity -gcnew -gcnewcapacity -gcold -gcoldcapacity -gcpermcapacity -gcutil -gccause</td> 
 </tr> 
 <tr> 
 <td>FGCT</td> 
 <td>full GC操作花费的时间</td> 
 <td>-gc -gcold -gcoldcapacity -gcpermcapacity -gcutil -gccause</td> 
 </tr> 
 <tr> 
 <td>GCT</td> 
 <td>GC操作花费的总时间。</td> 
 <td>-gc -gcold -gcoldcapacity -gcpermcapacity -gcutil -gccause</td> 
 </tr> 
 <tr> 
 <td>NGCMN</td> 
 <td>新生代最小空间容量，单位KB。</td> 
 <td>-gccapacity -gcnewcapacity</td> 
 </tr> 
 <tr> 
 <td>NGCMX</td> 
 <td>新生代最大空间容量，单位KB。</td> 
 <td>-gccapacity -gcnewcapacity</td> 
 </tr> 
 <tr> 
 <td>NGC</td> 
 <td>新生代当前空间容量，单位KB。</td> 
 <td>-gccapacity -gcnewcapacity</td> 
 </tr> 
 <tr> 
 <td>OGCMN</td> 
 <td>老年代最小空间容量，单位KB。</td> 
 <td>-gccapacity -gcoldcapacity</td> 
 </tr> 
 <tr> 
 <td>OGCMX</td> 
 <td>老年代最大空间容量，单位KB。</td> 
 <td>-gccapacity -gcoldcapacity</td> 
 </tr> 
 <tr> 
 <td>OGC</td> 
 <td>老年代当前空间容量制，单位KB。</td> 
 <td>-gccapacity -gcoldcapacity</td> 
 </tr> 
 <tr> 
 <td>PGCMN</td> 
 <td>持久代最小空间容量，单位KB。</td> 
 <td>-gccapacity -gcpermcapacity</td> 
 </tr> 
 <tr> 
 <td>PGCMX</td> 
 <td>持久代最大空间容量，单位KB。</td> 
 <td>-gccapacity -gcpermcapacity</td> 
 </tr> 
 <tr> 
 <td>PGC</td> 
 <td>持久代当前空间容量，单位KB。</td> 
 <td>-gccapacity -gcpermcapacity</td> 
 </tr> 
 <tr> 
 <td>PC</td> 
 <td>持久代当前空间大小，单位KB</td> 
 <td>-gccapacity -gcpermcapacity</td> 
 </tr> 
 <tr> 
 <td>PU</td> 
 <td>持久代当前已用空间大小，单位KB</td> 
 <td>-gc -gcold</td> 
 </tr> 
 <tr> 
 <td>LGCC</td> 
 <td>最后一次GC发生的原因</td> 
 <td>-gccause</td> 
 </tr> 
 <tr> 
 <td>GCC</td> 
 <td>当前GC发生的原因</td> 
 <td>-gccause</td> 
 </tr> 
 <tr> 
 <td>TT</td> 
 <td>老年化阈值。被移动到老年代之前，在新生代空存活的次数。</td> 
 <td>-gcnew</td> 
 </tr> 
 <tr> 
 <td>MTT</td> 
 <td>最大老年化阈值。被移动到老年代之前，在新生代空存活的次数。</td> 
 <td>-gcnew</td> 
 </tr> 
 <tr> 
 <td>DSS</td> 
 <td>幸存者区所需空间大小，单位KB。</td> 
 <td>-gcnew</td> 
 </tr> 
 </tbody> 
</table>

jstat 的好处是它可以持续的监控GC操作数据，不论Java应用是运行在本地还是远程，只要有控制台的地方就可以使用。当使用–gcutil 会输出如下信息。**在GC优化的时候，你需要特别注意YGC, YGCT, FGC, FGCT 和GCT。**

**\[plain\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  S0      S1       E        O        P        YGC    YGCT     FGC    FGCT     GCT  
2.  0.00    66.44    54.12    10.58    86.63    217    0.928     2     0.067    0.995  
3.  0.00    66.44    54.12    10.58    86.63    217    0.928     2     0.067    0.995  
4.  0.00    66.44    54.12    10.58    86.63    217    0.928     2     0.067    0.995

这些信息很重要，因为它们展示了GC处理到底花费了多少时间。  
　　在这个例子中，YGC 是217而YGCT 是0.928，这样在简单的计算数据平均数后，你可以知道每次新生代的GC大概需要4ms（0.004秒），而full GC的平均时间为33ms。  
但是，**只看数据平均数经常无法分析出真正的GC问题。这是主要是因为GC操作时间严重的偏差**（换句话说，假如两次full GC的时间是 67ms，那么其中的一次full GC可能执行了10ms而另一个可能执行了57ms。）为了更好地检测每次GC处理时间，最好使用 –verbosegc来替代数据平均数。

# **-verbosegc** #

-verbosegc 是在启动一个Java应用时可以指定的JVM参数之一。而jstat 可以监控任何JVM应用，即便它没有指定任何参数。 -verbosegc 需要在启动的时候指定，因此你可能会认为它没有必要（因为jstat可以替代之）。但是， -verbosegc 会以更浅显易懂的方式展现GC发生的结果，因此他对于监控监控GC信息十分有用。

<table> 
 <tbody> 
 <tr> 
 <td> </td> 
 <td>jstat</td> 
 <td>-verbosegc</td> 
 </tr> 
 <tr> 
 <td>监控对象</td> 
 <td>运行在本机的Java应用可以把日志输出到终端上，或者借助jstatd命令通过网络连接远程的Java应用。</td> 
 <td>只有那些把-verbogc作为启动参数的JVM。</td> 
 </tr> 
 <tr> 
 <td>输出信息</td> 
 <td>堆状态（已用空间，最大限制，GC执行次数/时间，等等）</td> 
 <td>执行GC前后新生代和老年代空间大小，GC执行时间。</td> 
 </tr> 
 <tr> 
 <td>输出时间</td> 
 <td>Every designated time 每次设定好的时间。</td> 
 <td>每次GC发生的时候。</td> 
 </tr> 
 <tr> 
 <td>何时有用。</td> 
 <td>当你试图观察堆空间变化情况</td> 
 <td>当你试图了解单次GC产生的效果。</td> 
 </tr> 
 </tbody> 
</table>

下面是-verbosegc 的可用参数  
· -XX:+PrintGCDetails  
· -XX:+PrintGCTimeStamps  
· -XX:+PrintHeapAtGC  
· -XX:+PrintGCDateStamps (from JDK 6 update 4)

如果只是用了 -verbosegc 。那么默认会加上 -XX:+PrintGCDetails。 –verbosgc 的附加参数并不是独立的。而是经常组合起来使用。  
　　使用 –verbosegc后，每次GC发生你都会看到如下格式的结果。

\[GC \[<collector>: <starting occupancy1> -> <ending occupancy1>, <pause time1> secs\] <starting occupancy3> -> <ending occupancy3>, <pause time3> secs\]

<table> 
 <tbody> 
 <tr> 
 <td>收集器</td> 
 <td>minor gc使用的收集器的名字</td> 
 </tr> 
 <tr> 
 <td>starting occupancy1</td> 
 <td>GC执行前新生代空间大小</td> 
 </tr> 
 <tr> 
 <td>ending occupancy1</td> 
 <td>GC执行后新生代空间大小</td> 
 </tr> 
 <tr> 
 <td>pause time1</td> 
 <td>因为执行minor GC，Java应用暂停的时间</td> 
 </tr> 
 <tr> 
 <td>starting occupancy3</td> 
 <td>GC执行前堆区域总大小</td> 
 </tr> 
 <tr> 
 <td>ending occupancy3</td> 
 <td>GC执行后堆区域总大小</td> 
 </tr> 
 <tr> 
 <td>pause time3</td> 
 <td>Java应用由于执行堆空间GC（包括major GC）而停止的时间</td> 
 </tr> 
 </tbody> 
</table>

这是-verbosegc 输出的minor GC的例子：

**\[plain\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  S0    S1     E      O      P        YGC    YGCT    FGC    FGCT     GCT  
2.  0.00  66.44  54.12  10.58  86.63    217    0.928     2    0.067    0.995  
3.  0.00  66.44  54.12  10.58  86.63    217    0.928     2    0.067    0.995  
4.  0.00  66.44  54.12  10.58  86.63    217    0.928     2    0.067    0.995

这是 Full GC发生时的例子：

**\[plain\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \[Full GC \[Tenured: 3485K->4095K(4096K), 0.1745373 secs\] 61244K->7418K(63104K), \[Perm : 10756K->10756K(12288K)\], 0.1762129 secs\] \[Times: user=0.19 sys=0.00, real=0.19 secs\]

如果使用了 CMS collector，那么如下CMS信息也会被输出。  
　　由于 –verbosegc 参数在每次GC事件发生的时候都会输出日志，我们可以很轻易地观察到GC操作对于堆空间的影响。

# **(Java) VisualVM  + Visual GC** #

Java Visual VM是由Oracle JDK提供的图形化的汇总和监控工具。

![20140518004308171][]  
**图1: VisualVM 截图**

除了JDK中自带的版本，你还可以直接从官网下载Visual VM。出于便利性的考虑，JDK中包含的版本被命名为Java VisualVM (jvisualvm)，而官网提供的版本被命名为Visual VM (visualvm)。两者的功能基本相同，只有一些细小的差别，例如安装组件的时候。就个人而言，我更喜欢可以从官网下载的Visual VM。

![20140518004914406][]

**图 2: Viusal GC 安装截图**

通过Visual GC，你可以更直观的看到执行jstatd 所得到的信息。

![20140518004958875][]  
**图3: Visual GC 执行截图**

# **HPJMeter** #

**　　**[HPJMeter][] 可以很方便的分析 -verbosegc 输出的结果，如果Visual GC可以视作jstat的图形化版本，那么HPJMeter就相当于 –verbosgc的图形化版本。当然，GC分析只是HPJMeter提供的众多功能之一，**HPJMeter是由惠普开发的性能监控工具，他可以支持HP-UX，Linux以及MS Windows。**  
　　起初，一个成为HPTune 被设计用来图形化的分析-verbosegc.输出的结果。但是，随着HPTune的功能被集成到HPJMeter 3.0版本之后，就没有必要单独下载HPTune了。但运行一个应用时， -verbosegc 的结果会被输出到一个独立的文件中。  
　　你可以用HPJMeter直接打开这个文件，以便更直观的分析GC性能数据。

![20140518005329984][]  
图 **4: HPJMeter**

# **下次预告** #

本文我们主要讲述了如果监控GC操作信息，这将是GC优化的前提。就我个人经验而言，我推荐使用jstat 来监控GC操作，如果你感觉到GC操作的执行时间过长，那就可以使用verbosegc 参数来分析GC。GC优化的大体步骤就是在添加verbosegc 参数后，调整GC参数，分析修改后的结果。在下一篇文章中，我们将通过真实的例子来讲解优化GC的最佳选择。  
　　作者：Sangmin Lee, NHN公司，性能工程师实验室高级工程师。

附录：内存泄露

一、Java内存回收机制   
     不论哪种语言的内存分配方式，都需要返回所分配内存的真实地址，也就是返回一个指针到内存块的首地址。Java中对象是采用new或者反射的方法创建的，这些对象的创建都是在堆（Heap）中分配的，所有对象的回收都是由Java虚拟机通过垃圾回收机制完成的。GC为了能够正确释放对象，会监控每个对象的运行状况，对他们的申请、引用、被引用、赋值等状况进行监控，Java会使用有向图的方法进行管理内存，实时监控对象是否可以达到，如果不可到达，则就将其回收，这样也可以消除引用循环的问题。在Java语言中，判断一个内存空间是否符合垃圾收集标准有两个：**一个是给对象赋予了空值null，以下再没有调用过，另一个是给对象赋予了新值，这样重新分配了内存空间。**

二、Java内存泄露引起原因   
首先，什么是内存泄露？经常听人谈起内存泄露，但要问什么是内存泄露，没几个说得清楚。内存泄露是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间的浪费称为内存泄露。内存泄露有时不严重且不易察觉，这样开发者就不知道存在内存泄露，但有时也会很严重，会提示你Out of memory。  
那么，Java内存泄露根本原因是什么呢？**长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露**，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景。具体主要有如下几大类：   
**1、静态集合类引起内存泄露： **  
像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的所有的对象Object也不能被释放，因为他们也将一直被Vector等引用着。   
例:

Static Vector v = new Vector(10); 
 for (int i = 1; i<100; i++) 
 { 
 Object o = new Object(); 
 v.add(o); 
 o = null; 
 }//

在这个例子中，循环申请Object 对象，并将所申请的对象放入一个Vector 中，如果仅仅释放引用本身（o=null），那么 Vector 仍然引用该对象 ，所以这个对象对GC 来说是不可回收的。因此，如果对象加入到Vector 后，还必须从Vector 中删除，最简单的方法就是将Vector对象设置为null。

2、当集合里面的对象属性被修改后，再调用remove（）方法时不起作用。

例：

public static void main(String[] args) 
 { 
 Set<Person> set = new HashSet<Person>(); 
 Person p1 = new Person("唐僧","pwd1",25); 
 Person p2 = new Person("孙悟空","pwd2",26); 
 Person p3 = new Person("猪八戒","pwd3",27); 
 set.add(p1); 
 set.add(p2); 
 set.add(p3); 
 System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:3 个元素! 
 p3.setAge(2); //修改p3的年龄,此时p3元素对应的hashcode值发生改变 
 set.remove(p3); //此时remove不掉，造成内存泄漏
 set.add(p3); //重新添加，居然添加成功 
 System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:4 个元素! 
 for (Person person : set) 
 { 
 System.out.println(person); 
 } 
 }

3、监听器   
在java 编程中，我们都需要和监听器打交道，通常一个应用当中会用到很多监听器，我们会调用一个控件的诸如addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住去删除这些监听器，从而增加了内存泄漏的机会。

4、各种连接   
比如数据库连接（dataSourse.getConnection()），网络连接(socket)和io连接，除非其显式的调用了其close（）方法将其连接关闭，否则是不会自动被GC 回收的。对于Resultset 和Statement 对象可以不进行显式回收，但Connection 一定要显式回收，因为Connection 在任何时候都无法自动回收，而Connection一旦回收，Resultset 和Statement 对象就会立即为NULL。但是如果使用连接池，情况就不一样了，除了要显式地关闭连接，还必须显式地关闭Resultset Statement 对象（关闭其中一个，另外一个也会关闭），否则就会造成大量的Statement 对象无法释放，从而引起内存泄漏。这种情况下一般都会在try里面去的连接，在finally里面释放连接。

5、内部类和外部模块等的引用   
内部类的引用是比较容易遗忘的一种，而且一旦没释放可能导致一系列的后继类对象没有释放。此外程序员还要小心外部模块不经意的引用，例如程序员A 负责A 模块，调用了B 模块的一个方法如：   
public void registerMsg(Object b);   
这种调用就要非常小心了，传入了一个对象，很可能模块B就保持了对该对象的引用，这时候就需要注意模块B 是否提供相应的操作去除引用。

6、单例模式   
不正确使用单例模式是引起内存泄露的一个常见问题，**单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式）**，如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露，考虑下面的例子：

class A{ 
    public A(){ 
    B.getInstance().setA(this); 
    } 
    .... 
    }

//B类采用单例模式

class B{ 
    private A a; 
    private static B instance=new B(); 
    public B(){} 
    public static B getInstance(){ 
    return instance; 
    } 
    public void setA(A a){ 
    this.a=a; 
    } 
    //getter... 
    }

显然B采用singleton模式，它持有一个A对象的引用，而这个A类的对象将不能被回收。想象下如果A是个比较复杂的对象或者集合类型会发生什么情况

英文原文：[http://www.cubrid.org/blog/dev-platform/how-to-monitor-java-garbage-collection/][http_www.cubrid.org_blog_dev-platform_how-to-monitor-java-garbage-collection]

中文参考：[http://www.importnew.com/2057.html][http_www.importnew.com_2057.html]

[Java]: http://www.importnew.com/1993.html
[view plain]: http://blog.csdn.net/zhoudaxia/article/details/26102203#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/355167
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/355167/fork
[20140518004308171]: /images/20220720/b8da44a021e54316853bef3711402836.png
[20140518004914406]: /images/20220720/590f36713cfc4f2e9b485c296f895f90.png
[20140518004958875]: /images/20220720/d5c410bd351e46cc8541dd7224cfb1bc.png
[HPJMeter]: https://h20392.www2.hp.com/portal/swdepot/displayProductInfo.do?productNumber=HPJMETER
[20140518005329984]: /images/20220720/efe54da74b3e408887071a866c09631f.png
[http_www.cubrid.org_blog_dev-platform_how-to-monitor-java-garbage-collection]: http://www.cubrid.org/blog/dev-platform/how-to-monitor-java-garbage-collection/
[http_www.importnew.com_2057.html]: http://www.importnew.com/2057.html