JVM调优

数据类型

Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。

基本类型包括：byte,short,int,long,char,float,double,Boolean,returnAddress

引用类型包括：类类型，接口类型和数组。

堆与栈

堆和栈是程序运行的关键，很有必要把他们的关系说清楚。

栈是运行时的单位，而堆是存储的单位。

栈解决程序的运行问题，即程序如何执行，或者说如何处理数据；堆解决的是数据存储的问题，即数据怎么放、放在哪儿。

在Java中一个线程就会相应有一个线程栈与之对应，这点很容易理解，因为不同的线程执行逻辑有所不同，因此需要一个独立的线程栈。而堆则是所有线程共享的。栈因为是运行单位，因此里面存储的信息都是跟当前线程（或程序）相关信息的。包括局部变量、程序运行状态、方法返回值等等；而堆只负责存储对象信息。

为什么要把堆和栈区分出来呢？栈中不是也可以存储数据吗？

第一，从软件设计的角度看，栈代表了处理逻辑，而堆代表了数据。这样分开，使得处理逻辑更为清晰。分而治之的思想。这种隔离、模块化的思想在软件设计的方方面面都有体现。

第二，堆与栈的分离，使得堆中的内容可以被多个栈共享（也可以理解为多个线程访问同一个对象）。这种共享的收益是很多的。一方面这种共享提供了一种有效的数据交互方式(如：共享内存)，另一方面，堆中的共享常量和缓存可以被所有栈访问，节省了空间。

第三，栈因为运行时的需要，比如保存系统运行的上下文，需要进行地址段的划分。由于栈只能向上增长，因此就会限制住栈存储内容的能力。而堆不同，堆中的对象是可以根据需要动态增长的，因此栈和堆的拆分，使得动态增长成为可能，相应栈中只需记录堆中的一个地址即可。

第四，面向对象就是堆和栈的完美结合。其实，面向对象方式的程序与以前结构化的程序在执行上没有任何区别。但是，面向对象的引入，使得对待问题的思考方式发生了改变，而更接近于自然方式的思考。当我们把对象拆开，你会发现，对象的属性其实就是数据，存放在堆中；而对象的行为（方法），就是运行逻辑，放在栈中。我们在编写对象的时候，其实即编写了数据结构，也编写的处理数据的逻辑。不得不承认，面向对象的设计，确实很美。

在Java中，Main函数就是栈的起始点，也是程序的起始点。

程序要运行总是有一个起点的。同C语言一样，java中的Main就是那个起点。无论什么java程序，找到main就找到了程序执行的入口：）

堆中存什么？栈中存什么？

堆中存的是对象。栈中存的是基本数据类型和堆中对象的引用。一个对象的大小是不可估计的，或者说是可以动态变化的，但是在栈中，一个对象只对应了一个4btye的引用（堆栈分离的好处：））。

为什么不把基本类型放堆中呢？因为其占用的空间一般是1~8个字节——需要空间比较少，而且因为是基本类型，所以不会出现动态增长的情况——长度固定，因此栈中存储就够了，如果把他存在堆中是没有什么意义的（还会浪费空间，后面说明）。可以这么说，基本类型和对象的引用都是存放在栈中，而且都是几个字节的一个数，因此在程序运行时，他们的处理方式是统一的。但是基本类型、对象引用和对象本身就有所区别了，因为一个是栈中的数据一个是堆中的数据。最常见的一个问题就是，Java中参数传递时的问题。

Java中的参数传递时传值呢？还是传引用？

要说明这个问题，先要明确两点：

1. 不要试图与C进行类比，Java中没有指针的概念

2. 程序运行永远都是在栈中进行的，因而参数传递时，只存在传递基本类型和对象引用的问题。不会直接传对象本身。

明确以上两点后。Java在方法调用传递参数时，因为没有指针，所以它都是进行传值调用（这点可以参考C的传值调用）。因此，很多书里面都说Java是进行传值调用，这点没有问题，而且也简化的C中复杂性。

但是传引用的错觉是如何造成的呢？在运行栈中，基本类型和引用的处理是一样的，都是传值，所以，如果是传引用的方法调用，也同时可以理解为“传引用值”的传值调用，即引用的处理跟基本类型是完全一样的。但是当进入被调用方法时，被传递的这个引用的值，被程序解释（或者查找）到堆中的对象，这个时候才对应到真正的对象。如果此时进行修改，修改的是引用对应的对象，而不是引用本身，即：修改的是堆中的数据。所以这个修改是可以保持的了。

对象，从某种意义上说，是由基本类型组成的。可以把一个对象看作为一棵树，对象的属性如果还是对象，则还是一颗树（即非叶子节点），基本类型则为树的叶子节点。程序参数传递时，被传递的值本身都是不能进行修改的，但是，如果这个值是一个非叶子节点（即一个对象引用），则可以修改这个节点下面的所有内容。

堆和栈中，栈是程序运行最根本的东西。程序运行可以没有堆，但是不能没有栈。而堆是为栈进行数据存储服务，说白了堆就是一块共享的内存。不过，正是因为堆和栈的分离的思想，才使得Java的垃圾回收成为可能。

Java中，栈的大小通过-Xss来设置，当栈中存储数据比较多时，需要适当调大这个值，否则会出现java.lang.StackOverflowError异常。常见的出现这个异常的是无法返回的递归，因为此时栈中保存的信息都是方法返回的记录点。

按照基本回收策略分

引用计数（Reference Counting）:

比较古老的回收算法。原理是此对象有一个引用，即增加一个计数，删除一个引用则减少一个计数。垃圾回收时，只用收集计数为0的对象。此算法最致命的是无法处理循环引用的问题。

标记-清除（Mark-Sweep）:

此算法执行分两阶段。第一阶段从引用根节点开始标记所有被引用的对象，第二阶段遍历整个堆，把未标记的对象清除。此算法需要暂停整个应用，同时，会产生内存碎片。

复制（Copying）:

此算法把内存空间划为两个相等的区域，每次只使用其中一个区域。垃圾回收时，遍历当前使用区域，把正在使用中的对象复制到另外一个区域中。次算法每次只处理正在使用中的对象，因此复制成本比较小，同时复制过去以后还能进行相应的内存整理，不会出现“碎片”问题。当然，此算法的缺点也是很明显的，就是需要两倍内存空间。

标记-整理（Mark-Compact）:

此算法结合了“标记-清除”和“复制”两个算法的优点。也是分两阶段，第一阶段从根节点开始标记所有被引用对象，第二阶段遍历整个堆，把清除未标记对象并且把存活对象“压缩”到堆的其中一块，按顺序排放。此算法避免了“标记-清除”的碎片问题，同时也避免了“复制”算法的空间问题。

按分区对待的方式分

增量收集（Incremental Collecting）:实时垃圾回收算法，即：在应用进行的同时进行垃圾回收。不知道什么原因JDK5.0中的收集器没有使用这种算法的。

分代收集（Generational Collecting）:基于对对象生命周期分析后得出的垃圾回收算法。把对象分为年青代、年老代、持久代，对不同生命周期的对象使用不同的算法（上述方式中的一个）进行回收。现在的垃圾回收器（从J2SE1.2开始）都是使用此算法的。

按系统线程分

串行收集:串行收集使用单线程处理所有垃圾回收工作，因为无需多线程交互，实现容易，而且效率比较高。但是，其局限性也比较明显，即无法使用多处理器的优势，所以此收集适合单处理器机器。当然，此收集器也可以用在小数据量（100M左右）情况下的多处理器机器上。

并行收集:并行收集使用多线程处理垃圾回收工作，因而速度快，效率高。而且理论上CPU数目越多，越能体现出并行收集器的优势。

并发收集:相对于串行收集和并行收集而言，前面两个在进行垃圾回收工作时，需要暂停整个运行环境，而只有垃圾回收程序在运行，因此，系统在垃圾回收时会有明显的暂停，而且暂停时间会因为堆越大而越长。

为什么要分代

分代的垃圾回收策略，是基于这样一个事实：不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的收集方式，以便提高回收效率。

在Java程序运行的过程中，会产生大量的对象，其中有些对象是与业务信息相关，比如Http请求中的Session对象、线程、Socket连接，这类对象跟业务直接挂钩，因此生命周期比较长。但是还有一些对象，主要是程序运行过程中生成的临时变量，这些对象生命周期会比较短，比如：String对象，由于其不变类的特性，系统会产生大量的这些对象，有些对象甚至只用一次即可回收。

试想，在不进行对象存活时间区分的情况下，每次垃圾回收都是对整个堆空间进行回收，花费时间相对会长，同时，因为每次回收都需要遍历所有存活对象，但实际上，对于生命周期长的对象而言，这种遍历是没有效果的，因为可能进行了很多次遍历，但是他们依旧存在。因此，分代垃圾回收采用分治的思想，进行代的划分，把不同生命周期的对象放在不同代上，不同代上采用最适合它的垃圾回收方式进行回收。

如何分代

虚拟机中的共划分为三个代：年轻代（Young Generation）、年老点（Old Generation）和持久代（Permanent Generation）。其中持久代主要存放的是Java类的类信息，与垃圾收集要收集的Java对象关系不大。年轻代和年老代的划分是对垃圾收集影响比较大的。

年轻代:

所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。年轻代分三个区。一个Eden区，两个Survivor区(一般而言)。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来 对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。同时，根据程序需要，Survivor区是可以配置为多个的（多于两个），这样可以增加对象在年轻代中的存在时间，减少被放到年老代的可能。

年老代:

在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。

持久代:

用于存放静态文件，如今Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=<N>进行设置。

1.Heap设定与垃圾回收

JavaHeap分为3个区，Young，Old和Permanent。Young保存刚实例化的对象。当该区被填满时，GC会将对象移到Old区。Permanent区则负责保存反射对象，本文不讨论该区。

JVM的Heap分配可以使用-X参数设定，

-Xms初始Heap大小

-Xmxjavaheap最大值

-Xmnyounggeneration的heap大小

JVM 有2个GC线程。第一个线程负责回收Heap的Young区。第二个线程在Heap不足时，遍历Heap，将Young区升级为Older区。 Older区的大小等于-Xmx减去-Xmn，不能将-Xms的值设的过大，因为第二个线程被迫运行会降低JVM的性能。

为什么一些程序频繁发生GC？有如下原因：

1）程序内调用了System.gc()或Runtime.gc()。

2）一些中间件软件调用自己的GC方法，此时需要设置参数禁止这些GC。

3）Java的Heap太小，一般默认的Heap值都很小。

4）频繁实例化对象，Release对象。此时尽量保存并重用对象，例如使用StringBuffer()和String()。

如果你发现每次GC后，Heap的剩余空间会是总空间的50%，这表示你的Heap处于健康状态。许多Server端的Java程序每次GC后最好能有65%的剩余空间。

经验之谈：

1）Server端JVM最好将-Xms和-Xmx设为相同值。为了优化GC，最好让-Xmn值约等于-Xmx的1/3[2]。

2）一个GUI程序最好是每10到20秒间运行一次GC，每次在半秒之内完成[2]。

注意：

1）增加Heap的大小虽然会降低GC的频率，但也增加了每次GC的时间。并且GC运行时，所有的用户线程将暂停，也就是GC期间，Java应用程序不做任何工作。

2）Heap大小并不决定进程的内存使用量。进程的内存使用量要大于-Xmx定义的值，因为Java为其他任务分配内存，例如每个线程的Stack等。

2．Stack的设定

每个线程都有他自己的Stack。

-Xss每个线程的Stack大小

Stack的大小限制着线程的数量。如果Stack过大就好导致内存溢漏。-Xss参数决定Stack大小，例如-Xss1024K。如果Stack太小，也会导致Stack溢漏。

3．硬件环境

硬件环境也影响GC的效率，例如机器的种类，内存，swap空间，和CPU的数量。

如果你的程序需要频繁创建很多transient对象，会导致JVM频繁GC。这种情况你可以增加机器的内存，来减少Swap空间的使用[2]。

4．4种GC

第一种为单线程GC，也是默认的GC。，该GC适用于单CPU机器。

第二种为ThroughputGC，是多线程的GC，适用于多CPU，使用大量线程的程序。第二种GC与第一种GC相似，不同在于GC在收集Young区是多线程的，但在Old区和第一种一样，仍然采用单线程。-XX:+UseParallelGC参数启动该GC。

第三种为ConcurrentLowPauseGC，类似于第一种，适用于多CPU，并要求缩短因GC造成程序停滞的时间。这种GC可以在Old区的回收同时，运行应用程序。-XX:+UseConcMarkSweepGC参数启动该GC。

第四种为IncrementalLowPauseGC，适用于要求缩短因GC造成程序停滞的时间。这种GC可以在Young区回收的同时，回收一部分Old区对象。-Xincgc参数启动该GC。

最后附上用java-X命令查看JVM的配置说明：

D:/j2sdk15/bin>java-X

-Xmixedmixedmodeexecution(default)

-Xintinterpretedmodeexecutiononly

-Xbootclasspath:<directoriesandzip/jarfilesseparatedby;>

setsearchpathforbootstrapclassesandresources

-Xbootclasspath/a:<directoriesandzip/jarfilesseparatedby;>

appendtoendofbootstrapclasspath

-Xbootclasspath/p:<directoriesandzip/jarfilesseparatedby;>

prependinfrontofbootstrapclasspath

-Xnoclassgcdisableclassgarbagecollection

-Xincgcenableincrementalgarbagecollection

-Xloggc:<file>logGCstatustoafilewithtimestamps

-Xbatchdisablebackgroundcompilation

-Xms<size>setinitialJavaheapsize

-Xmx<size>setmaximumJavaheapsize

-Xss<size>setjavathreadstacksize

-Xprofoutputcpuprofilingdata

-Xfutureenablestrictestchecks,anticipatingfuturedefault

-XrsreduceuseofOSsignalsbyJava/VM(seedocumentation)

-Xcheck:jniperformadditionalchecksforJNIfunctions

-Xshare:offdonotattempttousesharedclassdata

-Xshare:autousesharedclassdataifpossible(default)

-Xshare:onrequireusingsharedclassdata,otherwisefail.

The-Xoptionsarenon-standardandsubjecttochangewithoutnotice.

-----------------------------------------------------------------------
JVM配置参数中文说明：
-----------------------------------------------------------------------

1、-Xmixedmixedmodeexecution(default)

混合模式执行

2、-Xintinterpretedmodeexecutiononly

解释模式执行

3、-Xbootclasspath:<directoriesandzip/jarfilesseparatedby;>

setsearchpathforbootstrapclassesandresources

设置zip/jar资源或者类（.class文件）存放目录路径

3、-Xbootclasspath/a:<directoriesandzip/jarfilesseparatedby;>

appendtoendofbootstrapclasspath

追加zip/jar资源或者类（.class文件）存放目录路径

4、-Xbootclasspath/p:<directoriesandzip/jarfilesseparatedby;>

prependinfrontofbootstrapclasspath

预先加载zip/jar资源或者类（.class文件）存放目录路径

5、-Xnoclassgcdisableclassgarbagecollection

关闭类垃圾回收功能

6、-Xincgcenableincrementalgarbagecollection

开启类的垃圾回收功能

7、-Xloggc:<file>logGCstatustoafilewithtimestamps

记录垃圾回日志到一个文件。

8、-Xbatchdisablebackgroundcompilation

关闭后台编译

9、-Xms<size>setinitialJavaheapsize

设置JVM初始化堆内存大小

10、-Xmx<size>setmaximumJavaheapsize

设置JVM最大的堆内存大小

11、-Xss<size>setjavathreadstacksize

设置JVM栈内存大小

12、-Xprofoutputcpuprofilingdata

输入CPU概要表数据

13、-Xfutureenablestrictestchecks,anticipatingfuturedefault

执行严格的代码检查，预测可能出现的情况

14、-XrsreduceuseofOSsignalsbyJava/VM(seedocumentation)

通过JVM还原操作系统信号

15、-Xcheck:jniperformadditionalchecksforJNIfunctions

对JNI函数执行检查

16、-Xshare:offdonotattempttousesharedclassdata

尽可能不去使用共享类的数据

17、-Xshare:autousesharedclassdataifpossible(default)

尽可能的使用共享类的数据

18、-Xshare:onrequireusingsharedclassdata,otherwisefail.

尽可能的使用共享类的数据，否则运行失败

The-Xoptionsarenon-standardandsubjecttochangewithoutnotice.

调整JVMGC(GarbageCollection)，可以极大的减少由于GC工作，而导致的程序运行中断方面的问题，进而适当的提高Java程序的工作效率。但是调整GC是以个极为复杂的过程，

由于各个程序具备不同的特点，如：web和GUI程序就有很大区别（Web可以适当的停顿，但GUI停顿是客户无法接受的），而且由于跑在各个机器上的配置不同（主要cup个数，内存不同），

所以使用的GC种类也会不同。接下来，我简单介绍一下如何调整GC。

首先说一下如何监视GC，你可以使用我以前文章中提到的JDK中的jstat工具，也可以在java程序启动的opt里加上如下几个参数（注:这两个参数只针对SUN的HotSpotVM）：

-XX:-PrintGCPrintmessagesatgarbagecollection.Manageable.

-XX:-PrintGCDetailsPrintmoredetailsatgarbagecollection.Manageable.(Introducedin1.4.0.)

-XX:-PrintGCTimeStampsPrinttimestampsatgarbagecollection.Manageable(Introducedin1.4.0.)

当把-XX:-PrintGCDetails加入到javaopt里以后可以看见如下输出：

[GC[DefNew:34538K->2311K(36352K),0.0232439secs]45898K->15874K(520320K),0.0233874secs]

[FullGC[Tenured:13563K->15402K(483968K),0.2368177secs]21163K->15402K(520320K),[Perm:28671K->28635K(28672K)],0.2371537secs]

他们分别显示了GC的过程，清理出了多少空间。第一行GC使用的是‘普通GC’(MinorCollections)，第二行使用的是‘全GC’(MajorCollections)。他们的区别很大，在第一行最后

我们可以看见他的时间是0.0233874秒，而第二行的FullGC的时间是0.2371537秒。第二行的时间是第一行的接近10倍，也就是我们这次调优的重点，减少FullGC的次数，因为FullGC

会暂停程序比较长的时间，如果FullGC的次数比较多。程序就会经常性的假死。当然这只是他们的表面现象，接下来我仔细介绍一下GC，和FullGC（为后面的调优做准备）。

我们知道Java和C++的区别主要是，Java不需要像c++那样，由程序员主动的释放内存。而是由JVM里的GC(GarbageCollection)来，在适当的时候替我们释放内存。GC的内部工作，

即GC的算法有很多种,如：标记清除收集器，压缩收集器，分代收集器等等。现在比较常用的是分代收集（也是SUNVM使用的），即将内存分为几个区域，将不同生命周期的对象放在不同区域里

（新的对象会先生成在Youngarea，在几次ＧＣ以后，如过没有收集到，就会逐渐升级到Tenuredarea）。在GC收集的时候，频繁收集生命周期短的区域(Youngarea)，因为这个区域内的

对象生命周期比较短，GC效率也会比较高。而比较少的收集生命周期比较长的区域(OldareaorTenuredarea)，以及基本不收集的永久区(Permarea)。

注：Youngarea又分为三个区域分别叫Eden，和俩个Survivorspaces。Eden用来存放新的对象，Survivorspaces用于新对象升级到Tenuredarea时的拷贝。

我们管收集生命周期短的区域(Youngarea)的收集叫GC，而管收集生命周期比较长的区域(OldareaorTenuredarea)的收集叫FullGC，因为他们的收集算法不同，

所以使用的时间也会不同。我们要尽量减少FullGC的次数。

接下来介绍一下HotSpotVMGC的种类，GC在HotSpotVM5.0里有四种。一种是默认的叫serialcollector，另外几种分别叫throughputcollector，concurrent

lowpausecollector，incremental(sometimescalledtrain)lowpausecollector（废弃掉了）。以下是SUN的官方说明：

1.Thethroughputcollector:thiscollectorusesaparallelversionoftheyounggenerationcollector.Itisusedifthe

-XX:+UseParallelGCoptionispassedonthecommandline.Thetenuredgenerationcollectoristhesameastheserialcollector.

2.Theconcurrentlowpausecollector:thiscollectorisusedifthe-Xincgc&#8482;or-XX:+UseConcMarkSweepGCispassedonthecommandline.

Theconcurrentcollectorisusedtocollectthetenuredgenerationanddoesmostofthecollectionconcurrentlywiththeexecutionof

theapplication.Theapplicationispausedforshortperiodsduringthecollection.Aparallelversionoftheyounggenerationcopying

collectorisusedwiththeconcurrentcollector.Theconcurrentlowpausecollectorisusediftheoption-XX:+UseConcMarkSweepGCis

passedonthecommandline.

3.Theincremental(sometimescalledtrain)lowpausecollector:thiscollectorisusedonlyif-XX:+UseTrainGCispassedonthe

commandline.ThiscollectorhasnotchangedsincetheJ2SEPlatformversion1.4.2andiscurrentlynotunderactivedevelopment.

Itwillnotbesupportedinfuturereleases.Pleaseseethe1.4.2GCTuningDocumentforinformationonthiscollector.

简单来说就是throughputcollector和concurrentlowpausecollector:使用多线程的方式，利用多CUP来提高GC的效率，而throughputcollector与concurrent

lowpausecollector的去别是throughputcollector只在youngarea使用使用多线程，而concurrentlowpausecollector则在tenuredgeneration也使用多线程。

根据官方文档，他们俩个需要在多CPU的情况下，才能发挥作用。在一个CPU的情况下，会不如默认的serialcollector，因为线程管理需要耗费CPU资源。而在两个CPU的情况下，

也挺高不大。只是在更多CPU的情况下，才会有所提高。当然concurrentlowpausecollector有一种模式可以在CPU较少的机器上，提供尽可能少的停顿的模式，见下文。

当要使用throughputcollector时，在javaopt里加上-XX:+UseParallelGC，启动 throughputcollector收集。也可加上-XX:ParallelGCThreads=<desirednumber>来改变线程数。

还有两个参数-XX:MaxGCPauseMillis=<nnn>和-XX:GCTimeRatio=& lt;nnn>，MaxGCPauseMillis=<nnn>用来控制最大暂停时间，而-XX:GCTimeRatio可以提高 GC说占CPU的比，

以最大话的减小heap。

当要使用concurrentlowpausecollector时，在java的opt里加上-XX:+UseConcMarkSweepGC。concurrentlowpausecollector还有一种为CPU少的机器

准备的模式，叫Incrementalmode。这种模式使用一个CPU来在程序运行的过程中GC，只用很少的时间暂停程序，检查对象存活。

在Incrementalmode里，每个收集过程中，会暂停两次，第二次略长。第一次用来，简单从root查询存活对象。第二次用来，详细检查存活对象。整个过程如下：

*stopallapplicationthreads;dotheinitialmark;resumeallapplicationthreads（第一次暂停，初始话标记）

*dotheconcurrentmark(usesoneprocesorfortheconcurrentwork)（运行是标记）

*dotheconcurrentpre-clean(usesoneprocessorfortheconcurrentwork)（准备清理）

*stopallapplicationthreads;dotheremark;resumeallapplicationthreads（第二次暂停，标记，检查）

*dotheconcurrentsweep(usesoneprocessorfortheconcurrentwork)(运行过程中清理)

*dotheconcurrentreset(usesoneprocessorfortheconcurrentwork)(复原)

当要使用Incrementalmode时，需要使用以下几个变量：

-XX:+CMSIncrementalModedefault:disabled启动i-CMS模式（mustwith-

XX:+UseConcMarkSweepGC）

-XX:+CMSIncrementalPacingdefault:disabled提供自动校正功能

-XX:CMSIncrementalDutyCycle=<N>default:50启动CMS的上线

-XX:CMSIncrementalDutyCycleMin=<N>default:10启动CMS的下线

-XX:CMSIncrementalSafetyFactor=<N>default:10用来计算循环次数

-XX:CMSIncrementalOffset=<N>default:0最小循环次数（Thisisthepercentage(0-

100)bywhichtheincrementalmodedutycycleisshiftedtotherightwithintheperiod

betweenminorcollections.）

-XX:CMSExpAvgFactor=<N>default:25提供一个指导收集数

SUN推荐的使用参数是：

-XX:+UseConcMarkSweepGC/

-XX:+CMSIncrementalMode/

-XX:+CMSIncrementalPacing/

-XX:CMSIncrementalDutyCycleMin=0/

-XX:CMSIncrementalDutyCycle=10/

-XX:+PrintGCDetails/

-XX:+PrintGCTimeStamps/

-XX:-TraceClassUnloading

注：如果使用throughputcollector和concurrentlowpausecollector，这两种垃圾收集器，需要适当的挺高内存大小，以为多线程做准备。