如何做一些简单的JVM调优和Tomcat优化？

1、JVM的运行参数

jvm的参数类型分为三类， 分别是：

1）标准参数

如：

    -help

    -version

2）-X参数 （非标准参数）

如：

    -Xint

    -Xcomp

3）-XX参数（使用率较高）

如：

    -XX:newSize

    -XX:+UseSerialGC

简单记住有这三种参数就可以，具体使用到具体情况下具体对待。

常见的有：

• -Xms 和 -Xmx分别是设置 jvm 的堆内存的初始大小和最大大小。
• -Xmx2048m：等价于-XX:MaxHeapSize，设置JVM最大堆内存为2048M。
• -Xms512m：等价于-XX:InitialHeapSize，设置JVM初始堆内存为512M。

2、JVM内存模型

jdk1.8之前的 jvm 目前使用较少，仅对 jdk1.8 之后的 jvm 进行讨论

jdk1.8的内存模型是由2部分组成，年轻代 + 年老代。

年轻代： Eden + 2*Survivor

年老代： OldGen

特别说明：Metaspace所占用的内存空间不是在虚拟机内部， 而是在本地内存空间中， 这是与1.7的永久代最大的区别所在。

3、线程的运行状态

在Java中线程的状态一共被分成6种：

• 1）初始态（New）：创建一个Thread对象，但还未调用start()启动线程时，线程处于初始态。
• 2）运行态（Runnable）：

        a.就绪态---该状态下的线程已经获得执行所需的所有资源， 只要CPU分配执行权就能运行，所有就绪态的线程存放在就绪队列中。

        b.运行态：获得CPU执行权，正在执行的线程。由于一个CPU同一时刻只能执行一条线程，因此每个CPU每个时刻只有一条运行态的线程。

• 3）阻塞态（Blocked）：

        当一条正在执行的线程请求某一资源失败时， 就会进入阻塞态。

        有一个等待队列存放所有等待态的线程。

        线程处于等待态表示它需要等待其他线程的指示才能继续运行。

        进入等待态的线程会释放CPU执行权， 并释放资源（如： 锁）。

• 4）超时等待态（TIMED_WAITING）：

        当运行中的线程调用sleep(time)、wait、join、parkNanos、parkUntil时，就会进入该状态。

        和等待态一样， 并不是因为请求不到资源，而是主动进入，并且进入后需要其他线程唤醒。

        进入该状态后释放CPU执行权和占有的资源。

        与等待态的区别：到了超时时间后自动进入阻塞队列，开始竞争锁。

• 5）终止态（ TERMINATED）

        线程执行结束后的状态。

4、GC - 垃圾回收常见算法

1）引用计数法

    假设有一个对象A，任何一个对象对 A 的引用，那么对象 A 的引用计数器+1 ，当引用失败时，对象A的引用计数器就 -1 ，如果对象A的计数器的值为0，就说明对象 A 没有引用了，可以被回收。

优点：

• 实时性较高，无需等到内存不够的时候，才开始回收，运行时根据对象的计数器是否为0，就可以直接回收。
• 在垃圾回收过程中，应用无需挂起。如果申请内存时，内存不足，则立刻报outofmember 错误。
• 区域性，更新对象的计数器时，只是影响到该对象，不会扫描全部对象

缺点：

• 每次对象被引用时 都需要去更新计数器，有一点时间开销。
• 浪费CPU资源，即使内存够用，仍然在运行时进行计数器的统计。
• 无法解决循环引用问题。（最大的缺点）

2）标记清除法

标记清除算法，是将垃圾回收分为2个阶段，分别是标记和清除。

• 标记：从根节点开始标记引用的对象。
• 清除：未被标记引用的对象就是垃圾对象，可以被清理。

优点：

• 标记清除算法解决了引 用计数算法中的循环引用的问题， 没有从root节点引用的对象都会被回收。

缺点：

• 效率较低，标记和清除两个动作都需要遍历所有的对象，并且在GC时，需要停止应用程序，对于交互性要求比较高的应用而言这个体验是非常差的。
• 通过标记清除算法清理出来的内存，碎片化较为严重，因为被回收的对象可能存在于内存的各个角落，所以清理出来的内存是不连贯的

3）标记压缩法

标记压缩算法是在标记清除算法的基础之上，做了优化改进的算法。和标记清除算法一样，也是从根节点开始，对对象的引 用进行标记，在清理阶段，并不是简单的清理未标记的对象，而是将存活的对象压缩到内存的一端，然后清理边界以外的垃圾，从而解决了碎片化的问题。

优点：

•  解决了标记清除算法的碎片化的问题

缺点：

• 标记压缩算法多了一步， 对象移动内存位置的步骤， 其效率也有有一定的影响

4）复制算法

复制算法的核心就是，将原有的内存空间一分为二，每次只用其中的一块，在垃圾回收时，将正在使用的对象复制到另一个内存空间中，然后将该内存空间清空，交换两个内存的角色，完成垃圾的回收。

如果内存中的垃圾对象较多，需要复制的对象就较少，这种情况下适合使用该方式并且效率比较高，反之，则不适合。

其中的young_gc:

• 1 . 在GC开始的时候，对象只会存在于Eden区和名为“From”的Survivor区，Survivor区“To”是空的。
• 2. 紧接着进行GC,Eden区中所有存活的对象都会被复制到“To”，而在“From”区中，仍存活的对象会根据他们的年龄值来决定去向。年龄达到一定值(年龄阈值，可以通过-XX:MaxTenuringThreshold来设置)的对象会被移动到年老代中，没有达到阈值的对象会被复制到“To”区域。
• 3. 经过这次GC后，Eden区和From区已经被清空。 这个时候，“From”和“To”会交换他们的角色，也就是新的“To”就是上次GC前的“From”，新的“From”就是上次GC前的“To”。不管怎样，都会保证名为To的Survivor区域是空的。
• 4. GC会一直重复这样的过程，直到“To”区被填满，“To”区被填满之后，会将所有对象移动到年老代中。

优点：

• 在垃圾对象多的情况下，效率较高
• 清理后，内存无碎片

缺点：

• 在垃圾对象少的情况下，不适用，如：老年代内存
• 分配的2块内存空间，在同一个时刻，只能使用一半，内存使用率较低

5）分代算法

分代算法，根据回收对象的特点进行选择，在jvm中，年轻代适合使用复制算法，老年代适合使用标记清除或标记压缩算法。

5、垃圾收集器

垃圾回收算法的具体实现---垃圾收集器

包括： 串行垃圾收集器、 并行垃圾收集器、 CMS（并发） 垃圾收集器、 G1 垃圾收集器。

1）串行垃圾收集器

 使用单线程进行垃圾回收，垃圾回收时，只有一个线程在工作，并且java应用中的所有线程都要暂停，等待垃圾回收的完成。 这种现象称之为STW（ Stop-The-World）。对于交互性较强的应用而言， 这种垃圾收集器是不能够接受的。一般在Javaweb应用中是不会采用该收集器。

设置：

在程序运行参数中添加2个参数， 如下：

• -XX:+UseSerialGC     指定年轻代和老年代都使用串行垃圾收集器
• -XX:+PrintGCDetails  打印垃圾回收的详细信息

2）并行垃圾收集器

在串行垃圾收集器的基础之上做了改进，将单线程改为了多线程进行垃圾回收，这样可以缩短垃圾回收的时间。（这里是指，并行能力较强的机器）当然了，并行垃圾收集器在收集的过程中也会暂停应用程序，这个和串行垃圾回收器是一样的， 只是并行执行，速度更快些，暂停的时间更短一些。

ParNew垃圾收集器是工作在年轻代上的， 只是将串行的垃圾收集器改为了并行。

• 通过-XX:+UseParNewGC参数设置年轻代使用ParNew回收器， 老年代使用的依然是串行收集器。

3）ParallelGC收集器

工作机制和ParNewGC收集器一样，只是在此基础之上，新增了两个和系统吞吐量相关的参数，使得其使用起来更加的灵活和高效。

相关参数如下：

• -XX:+UseParallelGC        年轻代使用ParallelGC垃圾回收器， 老年代使用串行回收器。
• -XX:+UseParallelOldGC   年轻代使用ParallelGC垃圾回收器， 老年代使用ParallelOldGC垃圾回收器。
• -XX:MaxGCPauseMillis    设置最大的垃圾收集时的停顿时间， 单位为毫秒。需要注意的时，ParallelGC为了达到设置的停顿时间，可能会调整堆大小或其他的参数，如果堆的大小设置的较小，就会导致GC工作变得很频繁，反而可能会影响到性能。该参数使用需谨慎
• -XX:GCTimeRatio             设置垃圾回收时间占程序运行时间的百分比，公式为1 /(1 +n)。它的值为0~100之间的数字，默认值为99，也就是垃圾回收时间不能超过1%。
• -XX:UseAdaptiveSizePolicy  自适应GC模式，垃圾回收器将自动调整年轻代、老年代等参数，达到吞吐量、堆大小、停顿时间之间的平衡。一般用于，手动调整参数比较困难的场景，让收集器自动进行调整。

4）CMS收集器全称 Concurrent Mark Sweep

并发的、使用标记-清除算法的垃圾回收器，该回收器是针对老年代垃圾回收的，通过参数

• -XX:+UseConcMarkSweepGC进行设置。

CMS垃圾回收器的执行过程如下：

• 初始化标记(CMS-initial-mark) ,标记root，会导致stw；
• 并发标记(CMS-concurrent-mark)，与用户线程同时运行；
• 预清理（CMS-concurrent-preclean），与用户线程同时运行；
• 重新标记(CMS-remark) ，会导致stw；
• 并发清除(CMS-concurrent-sweep)，与用户线程同时运行；
• 调整堆大小，设置CMS在清理之后进行内存压缩，目的是清理内存中的碎片；
• 并发重置状态等待下次CMS的触发(CMS-concurrent-reset)，与用户线程同时运行

5）G1 垃圾收集器

在jdk1.7中正式使用的全新的垃圾收集器，oracle官方计划在jdk9中将G1变成默认的垃圾收集器，以替代CMS。

G1 的设计原则就是简化JVM性能调优， 开发人员只需要简单的三步即可完成调优：

• 1 . 第一步， 开启 G1 垃圾收集器
• 2. 第二步， 设置堆的最大内存
• 3. 第三步， 设置最大的停顿时间

G1 中提供了三种模式垃圾回收模式， Young GC、 Mixed GC 和 Full GC， 在不同的条件下被触发。

在G1 划分的区域中， 年轻代的垃圾收集依然采用暂停所有应用线程的方式， 将存活对象拷贝到老年代或者Survivor空间， G1 收集器通过将对象从一个区域复制到另外一个区域， 完成了清理工作。这就意味着， 在正常的处理过程中， G1 完成了堆的压缩（至少是部分堆的压缩） ， 这样也就不会有cms内存碎片问题的存在了

在G1 中， 有一种特殊的区域， 叫Humongous区域。如果一个对象占用的空间超过了分区容量50%以上， G1 收集器就认为这是一个巨型对象。这些巨型对象， 默认直接会被分配在老年代， 但是如果它是一个短期存在的巨型对象， 就会对垃圾收集器造成负面影响。为了解决这个问题， G1 划分了一个Humongous区， 它用来专门存放巨型对象。 如果一个H区装不下一个巨型对象， 那么G1 会寻找连续的H分区来存储。 为了能找到连续的H区， 有时候不得不启动Full GC。

1、Young GC

主要是对Eden区进行GC， 它在Eden空间耗尽时会被触发。Eden空间的数据移动到Survivor空间中， 如果Survivor空间不够， Eden空间的部分数据会直接晋升到年老代空间。Survivor区的数据移动到新的Survivor区中， 也有部分数据晋升到老年代空间中。最终Eden空间的数据为空， GC停止工作， 应用线程继续执行。

Remembered Set（已记忆集合）

在GC年轻代的对象时， 我们如何找到年轻代中对象的根对象呢？根对象可能是在年轻代中， 也可以在老年代中， 那么老年代中的所有对象都是根么？如果全量扫描老年代， 那么这样扫描下来会耗费大量的时间。于是， G1 引 进了 RSet的概念。 它的全称是Remembered Set， 其作用是跟踪指向某个堆内的对象引用。

每个Region初始化时， 会初始化一个RSet， 该集合用来记录并跟踪其它Region指向该Region中对象的引 用， 每个Region默认按照51 2Kb划分成多个Card， 所以RSet需要记录的东西应该是 xx Region的 xx Card。

2、Mixed GC

当越来越多的对象晋升到老年代old region时， 为了避免堆内存被耗尽， 虚拟机会触发一个混合的垃圾收集器， 即Mixed GC， 该算法并不是一个Old GC， 除了回收整个YoungRegion， 还会回收一部分的Old Region， 这里需要注意： 是一部分老年代， 而不是全部老年代， 可以选择哪些old region进行收集， 从而可以对垃圾回收的耗时时间进行控制。也要注意的是Mixed GC 并不是 Full GC。

MixedGC什么时候触发？ 由参数

• -XX:InitiatingHeapOccupancyPercent=n

决定。 默认：45%，该参数的意思是：当老年代大小占整个堆大小百分比达到该阀值时触发。

它的GC步骤分2步：

• 1 . 全局并发标记（ global concurrent marking）
• 2. 拷贝存活对象（ evacuation）

全局并发标记

执行过程分为五个步骤：

• 初始标记（ initial mark， STW），标记从根节点直接可达的对象， 这个阶段会执行一次年轻代GC， 会产生全局停顿
• 根区域扫描（ root region scan），G1 GC 在初始标记的存活区扫描对老年代的引 用， 并标记被引 用的对象。该阶段与应用程序（非 STW） 同时运行， 并且只有完成该阶段后， 才能开始下一次 STW 年轻代垃圾回收。
• 并发标记（ Concurrent Marking），G1 GC 在整个堆中查找可访问的（存活的） 对象。 该阶段与应用程序同时运行，可以被 STW 年轻代垃圾回收中断。
• 重新标记（ Remark， STW），该阶段是 STW 回收， 因为程序在运行， 针对上一次的标记进行修正。
• 清除垃圾（ Cleanup， STW），清点和重置标记状态， 该阶段会STW， 这个阶段并不会实际上去做垃圾的收集，等待evacuation阶段来回收。

拷贝存活对象

Evacuation阶段是全暂停的。 该阶段把一部分Region里的活对象拷贝到另一部分Region中， 从而实现垃圾的回收清理。

6）G1收集器相关参数

• -XX:+UseG1 GC        使用 G1 垃圾收集器
• -XX:MaxGCPauseMillis       设置期望达到的最大GC停顿时间指标（ JVM会尽力实现， 但不保证达到） ， 默认值是 200 毫秒。
• -XX:G1 HeapRegionSize=n     设置的 G1 区域的大小。 值是 2 的幂， 范围是 1 MB 到 32 MB 之间。 目 标是根据最小的 Java 堆大小划分出约 2048 个区域。默认是堆内存的1 /2000。
• -XX:ParallelGCThreads=n       设置 STW 工作线程数的值。 将 n 的值设置为逻辑处理器的数量。 n 的值与逻辑处理器的数量相同， 最多为 8。
• -XX:ConcGCThreads=n           设置并行标记的线程数。 将 n 设置为并行垃圾回收线程数 (ParallelGCThreads)的 1 /4 左右。
• -XX:InitiatingHeapOccupancyPercent=n       设置触发标记周期的 Java 堆占用率阈值。 默认占用率是整个 Java 堆的 45%。

7） 对于G1垃圾收集器优化建议

• 年轻代大小：避免使用 -Xmn 选项或 -XX:NewRatio 等其他相关选项显式设置年轻代大小。固定年轻代的大小会覆盖暂停时间目 标。
• 暂停时间目 标不要太过严苛：G1 GC 的吞吐量目 标是 90% 的应用程序时间和 1 0%的垃圾回收时间。评估 G1 GC 的吞吐量时， 暂停时间目 标不要太严苛。 目 标太过严苛表示您愿意。承受更多的垃圾回收开销， 而这会直接影响到吞吐量。

6、Tomcat优化

1）Tomcat配置优化

• 禁用 AJP连接：我们一般是使用Nginx+tomcat的架构， 所以用不着AJP协议， 所以把AJP连接器禁用。修改conf下的server.xml文件， 将AJP服务禁用掉即可

<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
           

• 使用执行器（线程池）：在tomcat中每一个用户请求都是一个线程， 所以可以使用线程池提高性能

2）tomcat的3种运行模式：

• 1 . bio默认的模式,性能非常低下,没有经过任何优化处理和支持.
• 2. nio(new I/O)： 是Java SE 1 .4及后续版本提供的一种新的I/O操作方式(即java.nio包及其子包)。 Java nio是一个基于缓冲区、 并能提供非阻塞I/O操作的Java API， 因此nio也被看成是non-blocking I/O的缩写。 它拥有比传统I/O操作(bio)更好的并发运行性能。
• 3. apr：安装起来最困难,但是从操作系统级别来解决异步的IO问题,大幅度的提高性能.推荐使用nio， 不过， 在tomcat8中有最新的nio2， 速度更快， 建议使用nio2

<Connector executor="tomcatThreadPool" port="8080" protocol="org.apache.coyote.http11.Http11Nio2Protocol"
connectionTimeout="20000" redirectPort="8443" />
           

3）调整JVM参数进行优化

• 设置G1垃圾回收器

StringBuffer是保证线程安全的， 效率是比较低的， 我们更多的是使用场景是不会涉及到线程安全的问题的， 所以更多的时候会选择StringBuilder， 效率会高一些。

7、代码优化

• 1、 尽可能使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中速度较快， 其他变量， 如静态变量、 实例变量等， 都在堆中创建， 速度较慢。 另外， 栈中创建的变量， 随着方法的运行结束， 这些内容就没了， 不需要额外的垃圾回收。

• 2、 尽量减少对变量的重复计算

明确一个概念， 对方法的调用， 即使方法中只有一句语句， 也是有消耗的。 所以例如下面的操作

for (int i = 0; i < list. size() ; i++)
{. . . }

// 建议替换为

int length = list. size() ;
for (int i = 0, i < length; i++)
{. . . }
           

• 3、 尽量采用懒加载的策略， 即在需要的时候才创建

String str = "aaa";
    if (i == 1) {
    list. add(str) ;
}

//建议替换成

if (i == 1) {
    String str = "aaa";
    list. add(str) ;
}
           

• 4、 异常不应该用来控制程序流程

异常对性能不利。 抛出异常首先要创建一个新的对象， Throwable接口的构造函数调用名为fillInStackTrace()的本地同步方 法， fillInStackTrace()方法检查堆栈， 收集调用跟踪信息。 只要有异常被抛出， Java虚拟机就必须调整调用堆栈， 因为在理过程中创建了一个新的对象。 异常只能用于错误处理， 不应该用来控制程序流程。

• 5、 不要将数组声明为public static final

因为这毫无意义， 这样只是定义了引 用为static final， 数组的内容还是可以随意改变的，将数组声明为public更是一个安全漏洞， 这意味着这个数组可以被外部类所改变

• 6、 不要创建一些不使用的对象

不要导入一些不使用的类这毫无意义， 如果代码中出现"The value of the local variable i is not used"、 "Theimport java.util is never used"， 那么请删除这些无用的内容

• 7、 程序运行过程中避免使用反射

反射是Java提供给用户一个很强大的功能， 功能强大往往意味着效率不高。 不建议在程序运行过程中使用尤其是频繁使用反射机制， 特别是 Method的invoke方法。如果确实有必要， 一种建议性的做法是将那些需要通过反射加载的类在项目 启动的时候通过反射实例化出一个对象并放入内存。

• 8、 使用数据库连接池和线程池

这两个池都是用于重用对象的， 前者可以避免频繁地打开和关闭连接， 后者可以避免频繁地创建和销毁线程。

• 9、 容器初始化时尽可能指定长度

容器初始化时尽可能指定长度， 如： new ArrayList<>(1 0); new HashMap<>(32); 避免容器长度不足时， 扩容带来的性能损耗。

• 10、 ArrayList随机遍历快， LinkedList添加删除快
• 11、 使用 Entry遍历Map

Map<String, String> map = new HashMap<>();
for (Map. Entry<String, String> entry : map.entrySet()) {
    String key = entry.getKey() ;
    String value = entry.getValue() ;
}

// 避免使用这种方式

Map<String, String> map = new HashMap<>();
for (String key : map.keySet()) {
    String value = map.get(key) ;
}
           

• 12、 不要手动调用 System.gc()
• 13、 String尽量少用正则表达式

正则表达式虽然功能强大， 但是其效率较低， 除非是有需要， 否则尽可能少用。replace() 不支持正则；replaceAll() 支持正则如果仅仅是字符的替换建议使用replace()。

• 14、 日志的输出要注意级别

// 当前的日志级别是error
LOGGER.info("保存出错！ " + user) ;
           

• 15、 对资源的close()建议分开操作

try{
    XXX.close() ;
    YYY.close() ;
}catch (Exception e) {
    . . .
}

// 建议改为

try{
    XXX. close() ;
}catch (Exception e) {
    . . .
}try{
    YYY. close() ;
}catch (Exception e) {
    . . .
}