一文理清JVM和GC（上）

本文主要介绍JVM和GC解析
本文较长，分为上下篇（可收藏，勿吃尘）
若有须要，能够参考
若有帮助，不忘 点赞 ❥

一文理清JVM和GC下篇

• 一文理清JVM和GC（下）

1、前期预热

1）JVM内存体系

其中方法区和堆被JVM中多个线程共享，好比类的静态常量就被存放在方法区，供类对象之间共享，虚拟机栈、本地方法栈、程序计数器是每一个线程独立拥有的，不会与其余线程共享。因此Java在经过new建立一个类对象实例的时候，一方面会在虚拟机栈中建立一个对该对象的引用，另外一方面会在堆上建立类对象的实例，而后将对象引用指向该对象的实例。对象引用存放在每个方法对应的栈帧中。

图片来源于网上

• 虚拟机栈：虚拟机栈中执行每一个方法的时候，都会建立一个栈帧用于存储局部变量表，操做数栈，动态连接，方法出口等信息。
• 本地方法栈：与虚拟机栈发挥的做用类似，相比于虚拟机栈为Java方法服务，本地方法栈为虚拟机使用的Native方法服务，执行每一个本地方法的时候，都会建立一个栈帧用于存储局部变量表，操做数栈，动态连接，方法出口等信息。
• 方法区：它用于存储已被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据，方法区在JDK1.7版本及以前称为永久代，从JDK1.8以后永久代被移除。
• 堆：堆是Java对象的存储区域，任何new字段分配的Java对象实例和数组，都被分配在了堆上，Java堆可以使用 - Xms / - Xmx 进行内存控制，从JDK1.7版本以后，运行时常量池从方法区移到了堆上。
• 程序计数器：指示Java虚拟机下一条须要执行的字节码指令。

2）JAVA8以后的JVM

从图中咱们能够看出JAVA8的JVM 用元空间取代了永久代

---

---

---

3）GC做用域

---

4）常见垃圾回收算法

• 引用计数法：

JVM的实现通常不采用这种方式

---

缺点：
1. 每次对对象赋值时均要维护引用计数器，且计数器自己也有必定的消耗；
2. 较难处理循环引用；

• 复制算法：

Java 堆从GC的角度能够细分为：新生代（Eden区、From Survivor区 和 To Survivor区）和 老年代。
特色：
复制算法不会产生内存碎片，但会占用空间。用于新生代。

---

MinorGC的过程（复制 --> 清空 --> 互换）

1. 复制： （Eden、SurvivorFrom 复制到 SurvivorTo，年龄加1）
   首先，当Eden区满的时候会触发第一次GC，把还活着的对象拷贝到SurvivorFrom区，当Eden区再次触发GC的时候会扫描Eden区域和From区域，对这两个区域进行垃圾回收，通过此次回收后还存活的对象，则直接复制到To区域（若是有对象的年龄已经到达了老年的标准，则复制到老年代区），同时把这些对象的年龄加1。
2. 清空：（清空Eden、SurvivorFrom）
   清空Eden和SurvivorFrom中的对象，也即复制以后有交换，谁空谁是to。
3. 互换：(SurvivorTo和SurvivorFrom 互换)
   最后，SurvivorTo和SurvivorFrom 互换，原SurvivorTo成为下一次GC是的SurvivorFrom区。

• `标记清除法`

算法分红标记和清除两个阶段，先标记出要回收的对象，而后统一回收这些。
特色：
不会占用额外空间，但会扫描两次，耗时，容易产生碎片，用于老年代

---

• `标记压缩法`

优势：
没有内存碎片，能够利用bump
缺点：
须要移动对象的成本，用于老年代
原理：

1. 标记：与标记清除同样
   

   

   ---

   
   2.压缩：再次扫描，并往一段滑动存活对象
   

   

   ---

2、正文接入

1）判断对象是否可回收

• `引用计数法`

Java中，引用和对象是有关联的。若是要操做对象则必须用引用进行。
所以，很显然的一个方法就是经过引用计数来判断一个对象是否能够回收。简单来讲就是给对象添加一个引用计数器。每当有一个地方引用它，计数器的值加1，每当有一个引用失效时，计数器的值减1。
任什么时候刻计数器值为0的对象就是不可能再被使用的，那么这个对象就是可回收对象。
缺点： 很难解决对象之间相互循环引用的问题

---

• `枚举根节点作可达性分析(根搜索路径)`

所谓“GC roots” 或者说tracing GC 的 "根集合" 就是一组必须活跃的引用。
基本思路就是经过一系列名为“GC Roots” 的对象做为起始点，从这个被称为GC Roots的对象开始向下搜索，如GC Roots没有任何引用链相连是，则说明此对象不可用。也即给定一个集合的引用做为根出发，经过引用关系

图片来源于网上

2）哪些能够作GCRoots对象

• 虚拟机栈（栈帧中的局部变量区，也叫作局部变量表）
• 方法区中的类静态属性引用的对象
• 方法区中常量引用的对象
• 本地方法栈中N（Native方法）引用的对象

3）JVM的参数类型

• 标配参数
  • java -version
  • java -help
    

    

    ---

• X参数
  • java -Xint -version ：解释执行
  • java -Xcomp -version ：第一次使用就编译成本地代码
  • java -Xmixed ：混合模式
    

    

    ---

• XX参数
  • Boolean类型
    > -XX：+ 或者 - 某个属性值
    > +：表示开启
    > -：表示关闭
    > `例子：`
    > -XX: +PrintGCDetails： 开启打印GC收集细节
    > -XX: -PrintGCDetails： 关闭打印GC收集细节
    > -XX: +UseSerialGC： 开启串行垃圾收集器
    > -XX: -UseSerialGC： 关闭串行垃圾收集器
  • KV设置类型
    > -XX: 属性key = 属性value
    > `例子：`
    > -XX: MetaspaceSize = 128m：设置元空间大小为128m
    > -XX:MaxTenuringThreshold = 15： 控制新生代须要经历多少次GC晋升到老年代中的最大阈值
  • jinfo-查看当前运行程序的配置
    > 公式： jinfo -flag 配置项 进程编号
    > `例子：`
    > 1. 查看初始堆大小：
    

    

    ---

    
    >2. 查看其余参数
    

    

    ---

    
    > 3. 查看使用哪一种垃圾回收器
    

    

    ---

• 两个经典参数
  • -Xms 等价于 -XX: InitialHeapSize
  • -Xmx 等价于 -XX: MaxHeapSize

4）查看JVM默认值

• -XX:+PrintFlagsInitial 查看默认初始值
• java -XX: +PrintFlagsInitial -version
• java -XX: +PrintFlagsInitial
  

  

  ---

• -XX:+PrintFlagsFinal 查看修改更新
  • java -XX:+PrintFlagsFinal
  • java -XX:+PrintFlagsFinal -version
  • java -XX:+PrintCommandedLineFlags
    

    

    ---

5）经常使用的配置参数

经典案例设置：
-Xms128m -Xmx4096m -Xss1024k -XX:Metaspacesize=512m -XX:+PrintCommandLineFlags -XX:PrintGCDetails -XX:UseSerialGC

• -Xms

初始化大小内存，默认为物理内存1/64
等价于 -XX:InitialHeapSize

• -Xmx

最大分配内存，默认为物理内存1/4
等价于 -XX:MaxHeapSize

• -Xss

设置单个线程的大小，通常默认为5112K~1024K
等价于 -XX:ThreadStackSize

• -Xmn

设置年轻代大小

• -XX:MetaspaceSize

设置元空间大小

---

• -XX:+PrintGCdetails

输出详细的GC收集日志信息

---

---

• -XX:SurvivorRatio

设置新生代中eden和S0/S1空间的比例
默认：
-XX:SurvivorRatio=8 --> Eden:S0:S1=8:1:1
修改：
-XX:SurvivorRatio=4 --> Eden:S0:S1=4:1:1
SurvivorRatio值就是设置eden区的比例占多少，S0/S1相同

• -XX:NewRatio

设置年轻代与老年代在堆结构的占比
默认
-XX:NewRatio=2 新生代占1，老年代占2，年轻代占整个堆的1/3
修改
-XX:NewRatio=4 新生代占1，老年代占4，年轻代占整个堆的1/5
NewRatio值就是设置老年代的占比，剩下的1给新生代

• -XX:MaxTenuringThreshold

设置垃圾最大年龄
-XX:MaxTenuringThreshold=0：设置垃圾最大年龄。若是设置为0的话，则年轻代对象不通过Survivor区，直接进入老年代。对于老年代比较多的应用，能够提升效率。若是将此值设置为一个较大值，则年轻代对象会在Survivor区进行屡次复制，这样能够增长对象在年轻代的存活时间，增长年轻代被回收的概论。

6）强软弱虚

图片来源于网络

图片来源于网络

• 强引用
  • 当内存不足，JVM开始垃圾回收，对于强引用的对象，就算出现了OOM也不会对该对象进行回收，死都不收
  • 强引用是咱们最多见的普通对象引用，只要还有强引用指向一个对象，就能表名对象还“活着”，垃圾收集器不会碰这种对象。在Java中最多见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的。即便该对象之后永远都不会被用到，JVM也不会回收。 所以强引用是形成Java内存泄漏的主要缘由之一。
  • 对于一个普通的对象，若是没有其余的引用关系，只要超过了引用的做用域或者显式地将相应（强）引用赋值为null，通常就是认为能够被垃圾收集（具体看垃圾收集策略）

public static void main(String[] args) {
        Object o1 = new Object();   //默认为强引用
        Object o2 = o1;     //引用赋值
        o1 = null;          //置空 让垃圾收集
        System.gc();
        System.out.println(o1);     // null
        System.out.println(o2);     // java.lang.Object@1540e19d
    }
复制代码

• 软引用
  • 软引用就是一种相对强引用弱化了一些的引用。须要用java.lang.ref.SoftReference类来实现，可让对象豁免一些垃圾收集。
  • 系统内存充足 -> 不会回收
  • 系统内存不足 -> 会回收
  • 软引用一般用在对内存敏感的程序中，好比高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收

    public static void main(String[] args) {
        Object o1 = new Object();
        SoftReference softReference = new SoftReference(o1);
        o1 = null;
        System.gc();
        System.out.println(o1);
        System.out.println(softReference.get());
    }
复制代码

• 弱引用
  • 弱引用须要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短
  • 对于弱引用的对象，只要垃圾回收机制一运行，无论JVM的内存空间是否足够，都会回收该对象占用的内存。

    public static void main(String[] args) {
        Object o1 = new Object();
        WeakReference weakReference = new WeakReference(o1);
        o1 = null;
        System.gc();
        System.out.println(o1);                     //null
        System.out.println(weakReference.get());    //null
    }
复制代码

• 虚引用
  • 虚引用须要java.lang.ref.PhantomReference类来实现。
  • 形如虚设，它不会决定对象的生命周期。
  • 若是一个对象持有虚引用，那么它就和没有任何同样，在任什么时候候均可能被垃圾回收器回收， 它不能单独使用也不能经过它来访问对象，虚引用必须和引用队列（ReferenceQueue）联合使用。
  • 虚引用的主要做用是跟踪对象被垃圾回收的状态，仅仅是提供了一种确保对象被finalize之后，作某些事情的机制。PhantomReference的get方法老是返回null，所以没法访问对应的引用对象。其意义在于说明一个对象已经进入finalization阶段，能够被gc回收，用来实现比finalization机制更灵活的回收操做。

public static void main(String[] args) {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomReference = new PhantomReference<>(o1,referenceQueue);
        System.out.println(o1);                         //java.lang.Object@1540e19d
        System.out.println(phantomReference.get());     //null
        System.out.println(referenceQueue.poll());      //null
    }
复制代码

• 扩展
  • 软弱引用适用场景 > 假若有一个引用须要读取大量的本地图片 >存在问题：
    1. 若是每次读取图片都从硬盘读取则会严重影响性能。
    2. 若是一次性所有加载到内存中有可能形成内存溢出。
       >解决思路：
       > 用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。
       Map imgMap = new HashMap();
  • WeakHashMap

public static void main(String[] args) {
        WeakHashMap<Integer,String> weakHashMap = new WeakHashMap<>();
        Integer key = new Integer(1);
        weakHashMap.put(key,"测试1");
        System.out.println(weakHashMap);    //{1=测试1}
        key=null;
        System.out.println(weakHashMap);    //{1=测试1}
        System.gc();
        System.out.println(weakHashMap+"\t"+weakHashMap.size());    //{} 0
    }
复制代码

看完不赞，都是坏蛋

本文较长，能看到这里的都是好样的，成长之路学无止境
今天的你多努力一点，明天的你就能少说一句求人的话！
好久好久以前，有个传说，听说：
看完不赞，都是坏蛋