JVM浅析(中度)

JVM垃圾回收的时候如何确定垃圾

什么死垃圾

简单地说，内存中已经不再被使用到的空间就是垃圾

如何判断一个对象可以被回收

引用计数法

可达性分析

从一组名为“GC Roots”的根节点对象出发，向下遍历。那些没有被遍历到、与GC Roots形成通路的对象，会被标记为“回收”。

GC Roots

1. 虚拟机栈（栈帧中的局部变量）中引用的对象。
2. 本地方法栈（native）中引用的对象。
3. 方法区中常量引用的对象。
4. 方法区中类静态属性引用的对象。

JVM参数

标配参数

比如java -version、 java -help、java -showversion等

X参数(了解即可)

用得不多，比如-Xint，解释执行模式；-Xcomp，编译模式；-Xmixed，开启混合模式（默认）。

比如java -version发现java默认是混合模式，也就是先编译（javac）在执行

XX参数(重要)

用于JVM调优

布尔类型

公式：-XX:+某个属性、-XX:-某个属性，开启或关闭某个功能。

比如-XX:+PrintGCDetails，开启GC详细信息。

比如-XX:-PrintGCDetails，关闭GC详细信息。

KV键值类型

公式：-XX:属性key=值value。
比如-XX:Metaspace=128m、-XX:MaxTenuringThreshold=15

Xms/Xmx

-Xms和-Xmx十分常见，用于设置初始堆大小和最大堆大小。第一眼看上去，既不像X参数，也不像XX参数。实际上-Xms等价于-XX:InitialHeapSize，-Xmx等价于-XX:MaxHeapSize。所以-Xms和-Xmx属于XX参数，只不过有一个类似别名的东西。

JVM 常用参数

1. -Xmx/-Xms
   最大和初始堆大小。最大默认为物理内存的1/4，初始默认为物理内存的1/64。
2. -Xss
   等价于-XX:ThresholdStackSize。用于设置单个栈的大小，系统默认值是0，不代表栈大小为0。而是根据操作系统的不同，有不同的值。比如64位的Linux系统是1024K，而Windows系统依赖于虚拟内存。
3. -Xmn
   新生代大小，一般不调。
4. -XX:MetaspaceSize
   设置元空间大小。
5. -XX:+PrintGCDetails
   输出GC收集信息，包含GC和Full GC信息。
6. -XX:SurvivorRatio
   新生代中，Eden区和两个Survivor区的比例，默认是8:1:1。通过-XX:SurvivorRatio=4改成4:1:1
7. -XX:NewRatio
   老生代和新年代的比列，默认是2，即老年代占2，新生代占1。如果改成-XX:NewRatio=4，则老年代占4，新生代占1。
8. -XX:MaxTenuringThreshold
   新生代设置进入老年代的时间，默认是新生代逃过15次GC后，进入老年代。如果改成0，那么对象不会在新生代分配，直接进入老年代。

JVM参数参看

1. 查看java进程
   jps -l
   

2. 查看某个java进程的参数设置
   查看21472这个Java进程的所有参数配置信息jinfo -flags 21472
   
   查看21472这个Java进程的PrintGCDetails参数配置信息jinfo -flag PrintGCDetails 21472
   

3. 主要查看初始默认值
   java -XX:+PrintFlagsInitial
   

4. 查看修改后的参数
   使用java -XX:PrintFlagsFinal可以查看修改后的参数，与上面类似。只是修改过后是:=而不是=。

5. 查看常见参数
   如果不想查看所有参数，可以用-XX:+PrintCommandLineFlags查看常用参数。
   

JVM4中引用

强引用

使用new方法创造出来的对象，默认都是强引用。GC的时候，就算内存不够，抛出OutOfMemoryError也不会回收对象

public class StrongReferenceDemo {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = o1;
        o1 = null;
        System.gc();
        System.out.println(o2);
    }
}
java.lang.Object@1540e19d

软引用

需要用Object.Reference.SoftReference来显示创建。如果内存够，GC的时候不回收。内存不够，则回收。常用于内存敏感的应用，比如高速缓存

import java.lang.ref.SoftReference;
public class SoftReferenceDemo {
    public static void softRef_Memory_NotEnough() {
        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);
        //我们可以发现o1和softReference引用的地址是一样的
        System.out.println(o1);
        System.out.println(softReference.get());
        o1 = null;
        try {
            //要提前设置一下jvm堆内大小，让运行时内存不足
            //-Xms5m -Xmx5m -XX:+PrintGCDetails
            byte[] bytes = new byte[30 * 1024 * 1024];
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            //结果是两个null，softReference内存不足时直接被回收了
            System.out.println(o1);
            System.out.println(softReference.get());
        }
    }

    public static void main(String[] args) {
        softRef_Memory_NotEnough();
    }
}

应用

必须当前一个应用需要读取大量图片

• 每次读取图片从硬盘读取消耗性能
• 一次性把图片全加到内存容易OOM
  用一个HashMap(图片路径，图片对象的软引用/弱引用)，那内存不足时会自动回收图片对象占用的空间，有效的避免了OOM

弱引用

需要用Object.Reference.WeakReference来显示创建。无论内存够不够，GC的时候都回收，也可以用在高速缓存上

public class WeakReferenceDemo {

    public static void main(String[] args) {
        Object o1 = new Object();
        WeakReference<Object> weakReference = new WeakReference<>(o1);
        System.out.println(o1);
        System.out.println(weakReference.get());
        o1 = null;
        System.gc();
        System.out.println(o1);
        System.out.println(weakReference.get());
    }
}
 
java.lang.Object@1540e19d
java.lang.Object@1540e19d
null
null

WeakHashMap

传统的HashMap就算key==null了，也不会回收键值对。但是如果是WeakHashMap，一旦内存不够用时，且key==null时，会回收这个键值对

public class WeakHashMapDemo {
    public static void main(String[] args) {
        myHashMap();
        System.out.println("--------------------");
        myWeakHashMap();
    }

    public static void myHashMap() {
        HashMap<Integer, String> hashMap = new HashMap<>();
        Integer key = new Integer(1);
        String value = "HashMap";

        hashMap.put(key, value);
        System.out.println(hashMap);

        key = null;
        //hashmap的key是 new Integer(1)，和Integer key没啥关系
        System.out.println(hashMap);

        System.gc();
        System.out.println(hashMap +"  " + hashMap.size());
    }

    public static void myWeakHashMap() {
        WeakHashMap<Integer, String> weakHashMap = new WeakHashMap<>();
        Integer key = new Integer(2);
        String value = "WeakHashMap";

        weakHashMap.put(key, value);
        System.out.println(weakHashMap);

        key = null;
        System.out.println(weakHashMap);

        System.gc();
        System.out.println(weakHashMap + "  " + weakHashMap.size());
    }
}
{1=HashMap}
{1=HashMap}
{1=HashMap}	1
--------------------
{2=WeakHashMap}
{2=WeakHashMap}
{}	1

虚引用

软应用和弱引用可以通过get()方法获得对象，但是虚引用不行。虚引形同虚设，在任何时候都可能被GC，不能单独使用，必须配合引用队列（ReferenceQueue）来使用。设置虚引用的唯一目的，就是在这个对象被回收时，收到一个通知以便进行后续操作，有点像Spring的后置通知

public class PhantomReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference phantomReference = new PhantomReference(o1, referenceQueue);
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());

        System.out.println("===========");

        o1 = null;
        System.gc();
        Thread.sleep(500);
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());
    }
}
java.lang.Object@5f8ed237
null
null
===========
null
null
java.lang.ref.PhantomReference@2f410acf

引用队列ReferenceQueue

弱引用、虚引用被回收后，会被放到引用队列里面，通过poll方法可以得到。关于引用队列和弱、虚引用的配合使用

public class ReferenceQueueDemo {

    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        WeakReference<Object> weakReference = new WeakReference<>(o1, referenceQueue);

        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println(referenceQueue.poll());

        System.out.println("--------------------------");
        o1 = null;
        System.gc();
        Thread.sleep(500);

        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println(referenceQueue.poll());
    }
}
 
软(内存不够时)、弱、虚引用，gc后放到引用队列中
 
java.lang.Object@1540e19d
java.lang.Object@1540e19d
null
--------------------------
null
null
java.lang.ref.WeakReference@677327b6

总结

4中引用机制在GC时候各有各的特点
ReferenceQueue是配合引用一起使用的，没有ReferenceQueue样可以运行

创建引用的时候可以指定关联的队列,GC释放对象内存的时候，会将引用加入到引用队列
如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收前采取必要的行动
相当于一种通知机制

当关联的引用队列中有数据的时候，意味着引用指向的堆内存中的对象被回收，通过这种方式，我们可以在对象被销毁以后，做一些想做的事情

OOM

1. java.lang.StackOverflowError
   栈溢出，比如无限递归
   
2. java.lang.OutOfMemoryError:Java heap space
   堆内存溢出，就是我们常说的堆内存不足
3. java.lang.OutOfMemoryError:GC overhead limit exceeded
   
4. OOM—GC Direct buffer memory
   在写NIO程序的时候，会用到ByteBuffer来读取和存入数据。与Java堆的数据不一样，ByteBuffer使用native方法，直接在堆外分配内存。当堆外内存（也即本地物理内存）不够时，就会抛出这个异常
5. OOM—unable to create new native thread
   在高并发应用场景时，如果创建超过了系统默认的最大线程数，就会抛出该异常。Linux单个进程默认不能超过1024个线程。
   解决方法
   5.1 要么降低程序线程数
   5.2 要么修改系统最大线程数vim /etc/security/limits.d/90-nproc.conf
6. OOM—Metaspace
   元空间满了就会抛出这个异常。
   使用java -XX:+PrintFlagsInitial命令查看本机的初始化参数，-XX:MetaSpaceSize约为22M

JVM垃圾收集器

GC算法（引用计数/复制/标记清除/标记整理）是内存回收的方法论，垃圾收集器是算法的落地实现

目前为止还没有完美的收集器出现，更没有万能的收集器，只有针对具体应用最合适的收集器，进行分代收集

4种类型

1. 串行垃圾回收器Serial
   它为单线程环境设计，且只使用一个线程进行垃圾回收，会暂停所有的用户线程，所以不适合服务器环境
2. 并行垃圾回收器Parrallel
   多个垃圾收集线程并行工作，此时用户线程是暂停的，适用于科学计算/大数据处理首台处理等弱交互场景
3. 并发垃圾回收器concurrent mark sweep
   用户线程和垃圾收集线程同时执行（不一定并行，可能交替执行）不需要停顿用户线程。互联网公司多用，适用对响应时间有要求的场景
4. G1垃圾回收器
   G1垃圾回收器将堆内存分割成不同的区域然后并发地对其进行垃圾回收

7大垃圾收集器

1. Serial
2. Parallel Scavenge
3. ConcMarkSweep（CMS）
4. ParNew
5. ParallelOld
6. G1
7. SerialOld，快被淘汰了

服务区域

• Serial、Parallel、ParNew用户回收新生代；
• SerialOld、ParallelOld、CMS用于回收老年代。
• 而G1收集器，既可以回收新生代，也可以回收老年代
• Java 8默认使用-XX:+UseParallelGC，使用java -XX:+PrintCommandLineFlags即可查看使用的垃圾收集器
  

Serial收集器

年代最久远，是Client VM模式下的默认新生代收集器，使用复制算法。优点：单个线程收集，没有线程切换开销，拥有最高的单线程GC效率。

缺点：收集的时候会暂停用户线程。

使用-XX:+UseSerialGC可以显式开启，开启后默认使用Serial+SerialOld的组合。

ParNew收集器

也就是Serial的多线程版本，GC的时候不再是一个线程，而是多个，是Server VM模式下的默认新生代收集器，采用复制算法。

使用-XX:+UseParNewGC可以显式开启，开启后默认使用ParNew+SerialOld的组合。但是由于SerialOld已经过时，所以建议配合CMS使用。

Parallel Scavenge收集器

SerialOld收集器

Serial的老年代版本，采用标记整理算法。JDK1.5之前跟Parallel Scavenge配合使用，现在已经不了，作为CMS的后备收集器。

ParallelOld收集器

CMS收集器

并发标记清除收集器，是一种以获得最短GC停顿为目标的收集器。
适用在互联网或者B/S系统的服务器上，这类应用尤其重视服务器的响应速度，希望停顿时间最短。是G1收集器出来之前的首选收集器。
使用标清算法。在GC的时候，会与用户线程并发执行，不会停顿用户线程。但是在标记的时候，仍然会STW。

使用-XX:+UseConcMarkSweepGC开启。开启过后，新生代默认使用ParNew，同时老年代使用SerialOld作为备用。

过程

1. 初始标记：只是标记一下GC Roots能直接关联的对象，速度很快，需要STW。
2. 并发标记：主要标记过程，标记全部对象，和用户线程一起工作，不需要STW。
3. 重新标记：修正在并发标记阶段出现的变动，需要STW。
4. 并发清除：和用户线程一起，清除垃圾，不需要STW。

优缺点

优点：停顿时间少，响应速度快，用户体验好。
缺点：

1. 对CPU资源非常敏感：由于需要并发工作，多少会占用系统线程资源。
2. 无法处理浮动垃圾：由于标记垃圾的时候，用户进程仍然在运行，无法有效处理新产生的垃圾。
3. 产生内存碎片：由于使用标清算法，会产生内存碎片。

G1收集器

G1收集器与之前垃圾收集器的一个显著区别就是——之前收集器都有三个区域，新、老两代和元空间。而G1收集器只有G1区和元空间。而G1区，不像之前的收集器，分为新、老两代，而是一个一个Region，每个Region既可能包含新生代，也可能包含老年代。

G1收集器既可以提高吞吐量，又可以减少GC时间。最重要的是STW可控，增加了预测机制，让用户指定停顿时间。

• 使用-XX:+UseG1GC开启
• -XX:G1HeapRegionSize=n设置区域的大小，值是2的幂，范围是1~32M，共2048块
• -XX:MaxGCPauseMillis=n最大GC停顿时间，软目标，JVM尽可能但不保证，停顿小于这个时间

最大的好处是化整为零，避免全内存扫描，只需要按区域来进行扫描即可
比起cms有两个优势：

1. G1不会产生内存碎片
2. 可以精确控制停顿。该收集器把整个堆（新生代、老生代）划分为多个固定大小的区域，每次根据允许停顿的时间去收集垃圾最多的区域。

特点

1. 并行和并发：充分利用多核、多线程CPU，尽量缩短STW。
2. 分代收集：虽然还保留着新、老两代的概念，但物理上不再隔离，而是融合在Region中。
3. 空间整合：G1整体上看是标整算法，在局部看又是复制算法，不会产生内存碎片。
4. 可预测停顿：用户可以指定一个GC停顿时间，G1收集器会尽量满足。

过程

组合选择

生产环境常用linux看命令

生产环境服务器变慢，诊断思路和性能评估

1. top
   主要查看%CPU、%MEM，还有load average。load average后面的三个数字，表示系统1分钟、5分钟、15分钟的平均负载值。如果三者平均值高于0.6，则复杂比较高了。当然，用uptime也可以查看。
2. vmstat
   查看进程、内存、I/O等多个系统运行状态。2表示每两秒采样一次，3表示一共采样3次。procs的r表示运行和等待CPU时间片的进程数，原则上1核CPU不要超过2。b是等待资源的进程数，比如磁盘I/O、网络I/O等。

[root@ ~]# vmstat -n 2 3
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 2  0      0 173188 239748 1362628    0    0     0     3   17    8  0  0 99  0  0
 0  0      0 172800 239748 1362636    0    0     0     0  194  485  1  1 99  0  0
 1  0      0 172800 239748 1362640    0    0     0     0  192  421  1  1 99  0  0

3. pidstat
   查看某个进程的运行信息。
4. free
   查看内存信息。
5. df
   查看磁盘信息。
6. iostat
   查看磁盘I/O信息。比如有时候MySQL在查表的时候，会占用大量磁盘I/O，体现在该指令的%util字段很大。对于死循环的程序，CPU占用固然很高，但是磁盘I/O不高。
7. ifstat
   查看网络I/O信息，需要安装。

CPU占用过高原因定位

1. 先用top找到CPU占用最高的进程
2. 然后用ps -mp pid -o THREAD,tid,time，得到该进程里面占用最高的线程
3. 这个线程是10进制的，将其转成16进制，然后用jstack pid | grep tid可以定位到具体哪一行导致了占用过高。

JVM性能调优和监控工具

1. jps
   Java版的ps -ef查看所有JVM进程。
2. jstack
   查看JVM中运行线程的状态，比较重要。可以定位CPU占用过高位置，定位死锁位置。
3. jinfo/jstat
   jinfo查看JVM的运行环境参数，比如默认的JVM参数等。jstat统计信息监视工具。
4. jmap
   JVM内存映像工具。