JVM

JVM

JVM的内存结构

JVM的体系概述

Java8以后的JVM

GC的作用域

常见的垃圾回收算法
引用计数

复制

标记清除

标记整理

1、JM垃圾回收的时候如何确定垃圾?是否知道什么是 GC Roots
什么是垃圾：

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

要进行垃圾回收，如何判断一个对象是否可以被回收

引用计数法

Java中,引用和对象是有关联的。如果要操作对象则必须用引用进行
因此,很显然一个简单的办法是通过引用计数来判断一个对象是否可以回收。简单说,给对象中添加一个引用计数器,
每当有一个地方引用它,计数器值加1
每当有一个引用失效时,计数器值减1。
任何时刻计数器值为零的对象就是不可能再被使用的,那么这个对象就是可回收对象
那为什么主流的Java虚拟机里面都没有选用这种算法呢?其中最主要的原因是它很难解决对象之间相互循环引用的问题

枚举根节点做可达性分析（根搜索路径）

Java 可以做GCRoots的对象

虚拟机栈(栈帧中的局部变量区,也叫做局部变量表
方法区中的类静态属性引用的对象。
方法区中常量引用的对象
本地方法栈中N( Native方法)引用的对象

2、你说你做过JVM调优和参数配置，请问如何盘点查看MM系统默认值

JVM的参数类型
标配参数
-verison
-help
java -showversion

X参数（了解）
解释执行
-Xint

第一次使用就编译成本地代码
-Xcomp

混合模式
-Xmixed

XX参数
查看JVM默认值
Boolean类型
公式：-XX：+或者- 某个属性值
+表示开启
-表示关闭

Case：
是否打印GC收集细节：
-XX：+PrintGCDetails
-XX：-PrintGCDetails

是否使用串行垃圾收集器

-XX：-UseSerialGC
-XX：+UseSerialGC

KV设值类型

公式：
-XX：属性key=属性值value

Case
-XX:MetaspaceSize=128m
-XX:MaxTenuringThreshold=15：Y区升到O区活过15次

jinfo举例，如何查看当前运行程序的配置
公式：jinfo -flag 配置项 进程编号
Case1：

Case2：

Case3：

题外话（坑题）
两个经典参数：-Xms和-Xmx
这个你如何解释
-Xms：等价于 -XX:InitialHeapSize 初始堆内存
-Xmx：等价于-XX:MaxHeapSize 最大堆内存

查看JVM默认值
公式：
java -XX:+PrintFlagsInitial -version
java -XX:+PrintFlagsInitial
Case：

-XX:+PrintFlagsFinal：主要查看修改更新
公式：java -XX:+PirntFlagsFinal
java -XX:+PirntFlagsFinal -version

Case：
：=
是人为修改的参数

PrintFlagsFinal举例，运行Java命令的同时打印出参数运行Java代码，并且设置具体的值

-XX:+PrintCommandLineFlags
打印命令行参数

3、你平时工作用过的M常用基本配置参数有哪些?

基础知识复习

-Xms：初始大小内存，默认为物理内存1/64，等价于-XX:InitialHeapSize
-Xmx：最大分配内存，默认为物理内存1/4 等价于-XX:MaxHeapSize
-Xss：设置单个线程栈的大小，一般默认为512K~1024K：等价于-XX:ThreadStackSize
-Xmn：设置年轻代大小
-XX:MetaspaceSize：设置元空间大小

-Xms10m -Xmx10m -XX:MetaspaceSize=1024m -XX:+PrintFlagsFinal
典型设置案例：

-XX:+PrintGCDetails：输出详细GC收集日志信息

GC

FullGC

-XX:SurvivoRatio


Eden:S0:S1 = 8:1:1
-XX:+PrintGCDetails -XX:+UseSerialGC -Xms 10m -Xmx10m -XX:SurvivorRatio=8（先不加这个参数）默认就是8

Eden:S0:S1 = 4:1:1
-XX:+PrintGCDetails -XX:+UseSerialGC -Xms 10m -Xmx1 0m -XX:SurvivorRatio=4

-XX:NewRatio

-XX:MaxTenuringThreshold
最大养老区的吞吐量

设置垃圾最大年龄

强引用、软引用、弱引用、虚引用分别是什么?

整体架构

强引用（默认支持模式）

软引用

public class SoftReferenceDemo
/**
*
内存够用的时候就保留，不够用就回收!
*/
public static void softRef_ Memory_ Enough()
Object 01 = new object();
SoftReference<object> softReference = new SoftReference<>(01);
System. out . println(o1);
System. out . print1n( softReference.get());
01 = nu1l;
System.gc();
System. out . println(01);
System. out . println( softReference.get());
}

/**
* JVM配置，故意产生大对象并配置小的内存，让它内存不够用了导致00M，看软引用的回收情况
* -Xms5m -Xmx5m -XX: +PrintGCDetails
*/
public static void softRef_ Memory_ NotEnough()
Object 01 = new object();
SoftReference<object> softReference = new SoftReference<>(01);
System. out . println(o1);
System. out . println(softReference.get());
01 = null;
try
{
byte[] bytes = new byte[30 * 1024 * 1024];
}catch (Throwable e){
e. printStackTrace();
}final1y {
System. out . println(o1);
System. out . print1n( softReference.get());
}
}

弱引用

public class WeakReferenceDemo{
public static void main(String[] args)
Object 01 = new Object();
WeakReference<object> weakReference = new WeakReference<>(01);
System out  println(01);
System out println(weakReference.get());
01 = nul1;
System.gq();
System. out . println("================");
System. out . println(01);
System. out . println(weakReference. get());
}

弱引用的场景：

你知道弱引用的话，能谈谈WeakHashMap吗？

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

    }

    private static void myHashMap() {

        HashMap<Integer,String >map=new HashMap<>();
        Integer key=new Integer(1);
        String value="HashMap";
        map.put(key,value);
        System.out.println(map);
        key=null;
        System.out.println(map);
        System.gc();
        System.out.println(map);


    }

    /**
     * GC过后被回收了
     */
    private static void myWeakHashMap() {

        WeakHashMap<Integer,String > map=new WeakHashMap<>();
        Integer key=new Integer(2);
        String value="HashMap";
        map.put(key,value);
        System.out.println(map);
        key=null;
        System.out.println(map);
        System.gc();
        System.out.println(map);
    }
}

虚引用

public class PhantomReferenceDemo {
    public static void main(String[] args) throws InterruptedException {

        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        //监控对象的回收信息
        PhantomReference<Object> phantomReference = new PhantomReference<>(o1,referenceQueue);
        //GC之前
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());


        System.out.println("================");
        //GC之后
        o1=null;
        System.gc();
        Thread.sleep(500);
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());



    }
}
E:\jdk1.8.0_221\bin\java.exe "-javaagent:E:\IDER\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=10266:E:\IDER\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath E:\jdk1.8.0_221\jre\lib\charsets.jar;E:\jdk1.8.0_221\jre\lib\deploy.jar;E:\jdk1.8.0_221\jre\lib\ext\access-bridge-64.jar;E:\jdk1.8.0_221\jre\lib\ext\cldrdata.jar;E:\jdk1.8.0_221\jre\lib\ext\dnsns.jar;E:\jdk1.8.0_221\jre\lib\ext\jaccess.jar;E:\jdk1.8.0_221\jre\lib\ext\jfxrt.jar;E:\jdk1.8.0_221\jre\lib\ext\localedata.jar;E:\jdk1.8.0_221\jre\lib\ext\nashorn.jar;E:\jdk1.8.0_221\jre\lib\ext\sunec.jar;E:\jdk1.8.0_221\jre\lib\ext\sunjce_provider.jar;E:\jdk1.8.0_221\jre\lib\ext\sunmscapi.jar;E:\jdk1.8.0_221\jre\lib\ext\sunpkcs11.jar;E:\jdk1.8.0_221\jre\lib\ext\zipfs.jar;E:\jdk1.8.0_221\jre\lib\javaws.jar;E:\jdk1.8.0_221\jre\lib\jce.jar;E:\jdk1.8.0_221\jre\lib\jfr.jar;E:\jdk1.8.0_221\jre\lib\jfxswt.jar;E:\jdk1.8.0_221\jre\lib\jsse.jar;E:\jdk1.8.0_221\jre\lib\management-agent.jar;E:\jdk1.8.0_221\jre\lib\plugin.jar;E:\jdk1.8.0_221\jre\lib\resources.jar;E:\jdk1.8.0_221\jre\lib\rt.jar;E:\prices\out\production\prices;E:\prices\lib\spring-aspects-5.2.3.RELEASE.jar;E:\prices\lib\spring-aop-5.2.3.RELEASE.jar;E:\prices\lib\spring-context-support-5.2.3.RELEASE.jar;E:\prices\lib\spring-core-5.2.3.RELEASE.jar;E:\prices\lib\spring-expression-5.2.3.RELEASE.jar;E:\prices\lib\spring-instrument-5.2.3.RELEASE.jar;E:\prices\lib\spring-jms-5.2.3.RELEASE.jar;E:\prices\lib\spring-jdbc-5.2.3.RELEASE.jar;E:\prices\lib\spring-orm-5.2.3.RELEASE.jar;E:\prices\lib\spring-oxm-5.2.3.RELEASE.jar;E:\prices\lib\spring-messaging-5.2.3.RELEASE.jar;E:\prices\lib\spring-tx-5.2.3.RELEASE.jar;E:\prices\lib\commons-logging-1.2.jar;E:\prices\lib\aopalliance-1.0.jar;E:\prices\lib\spring-test-5.2.3.RELEASE.jar;E:\prices\lib\spring-context-5.2.3.RELEASE.jar;E:\prices\lib\spring-beans-5.2.3.RELEASE.jar com.jvm.ref.PhantomReferenceDemo
java.lang.Object@3764951d
null
null
================
null
null
java.lang.ref.PhantomReference@4b1210ee

java提供了4种引用类型，在垃圾回收的时候，都有自己各自的特点。
ReferenceQueue是用来配合引用工作的，没有ReferenceQueue -一样可以运行。
创建引用的时候可以指定关联的队列，当GC 释放对象内存的时候，会将引用加入到引用队列，
如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动I
这相当于是一.种通知机制。
当关联的引用队列中有数据的时候，意味着引用指向的堆内存中的对象被回收。通过这种方式，JVM允许我们在对象被销毁后，
做一些我们自己想做的事情。

ReferenceQueue

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());//引用队列为null
        System.out.println("==============");
        o1=null;
        System.gc();//GC的时候才会装到引用队列
        Thread.sleep(500);
        System.out.println(o1);
        System.out.println(weakReference.get());
        System.out.println(referenceQueue.poll());//引用队列为null


    }
}
E:\jdk1.8.0_221\bin\java.exe "-javaagent:E:\IDER\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=10592:E:\IDER\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath E:\jdk1.8.0_221\jre\lib\charsets.jar;E:\jdk1.8.0_221\jre\lib\deploy.jar;E:\jdk1.8.0_221\jre\lib\ext\access-bridge-64.jar;E:\jdk1.8.0_221\jre\lib\ext\cldrdata.jar;E:\jdk1.8.0_221\jre\lib\ext\dnsns.jar;E:\jdk1.8.0_221\jre\lib\ext\jaccess.jar;E:\jdk1.8.0_221\jre\lib\ext\jfxrt.jar;E:\jdk1.8.0_221\jre\lib\ext\localedata.jar;E:\jdk1.8.0_221\jre\lib\ext\nashorn.jar;E:\jdk1.8.0_221\jre\lib\ext\sunec.jar;E:\jdk1.8.0_221\jre\lib\ext\sunjce_provider.jar;E:\jdk1.8.0_221\jre\lib\ext\sunmscapi.jar;E:\jdk1.8.0_221\jre\lib\ext\sunpkcs11.jar;E:\jdk1.8.0_221\jre\lib\ext\zipfs.jar;E:\jdk1.8.0_221\jre\lib\javaws.jar;E:\jdk1.8.0_221\jre\lib\jce.jar;E:\jdk1.8.0_221\jre\lib\jfr.jar;E:\jdk1.8.0_221\jre\lib\jfxswt.jar;E:\jdk1.8.0_221\jre\lib\jsse.jar;E:\jdk1.8.0_221\jre\lib\management-agent.jar;E:\jdk1.8.0_221\jre\lib\plugin.jar;E:\jdk1.8.0_221\jre\lib\resources.jar;E:\jdk1.8.0_221\jre\lib\rt.jar;E:\prices\out\production\prices;E:\prices\lib\spring-aspects-5.2.3.RELEASE.jar;E:\prices\lib\spring-aop-5.2.3.RELEASE.jar;E:\prices\lib\spring-context-support-5.2.3.RELEASE.jar;E:\prices\lib\spring-core-5.2.3.RELEASE.jar;E:\prices\lib\spring-expression-5.2.3.RELEASE.jar;E:\prices\lib\spring-instrument-5.2.3.RELEASE.jar;E:\prices\lib\spring-jms-5.2.3.RELEASE.jar;E:\prices\lib\spring-jdbc-5.2.3.RELEASE.jar;E:\prices\lib\spring-orm-5.2.3.RELEASE.jar;E:\prices\lib\spring-oxm-5.2.3.RELEASE.jar;E:\prices\lib\spring-messaging-5.2.3.RELEASE.jar;E:\prices\lib\spring-tx-5.2.3.RELEASE.jar;E:\prices\lib\commons-logging-1.2.jar;E:\prices\lib\aopalliance-1.0.jar;E:\prices\lib\spring-test-5.2.3.RELEASE.jar;E:\prices\lib\spring-context-5.2.3.RELEASE.jar;E:\prices\lib\spring-beans-5.2.3.RELEASE.jar com.jvm.ref.ReferenceQueueDemo
java.lang.Object@3764951d
java.lang.Object@3764951d
null
==============
null
null
java.lang.ref.WeakReference@4b1210ee

GCRoots和四大引用的小总结

5、请谈谈你对ooM的认识

1. Java.lang.StackOverflowError

这是一个错误

public class StackOverflowErrorDemo {
    public static void main(String[] args) {
        stackOverflowError();
    }

    private static void stackOverflowError() {
        //方法的深度调用
        stackOverflowError();
        //Exception in thread "main" java.lang.StackOverflowError
        //	at com.jvm.ref.oom.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:10)
    }
}

2. Java.lang.OutOfMemoryError:Java heap space

也是一个错误

-Xms10m -Xmx10m

public class JavaHeapSpaceDemo {
    public static void main(String[] args) {
        String str="atguigu";
        while (true){
            str+=str+new Random().nextInt(1111111)+new Random().nextInt(222222);
        str.intern();
        }

    }
}

3. Java.lang.OutOfMemeoryError:GC overhead limit exceeded

JVM参数配置演示
-Xms10m -Xmx10m -XX: +PrintGCDetails -XX:MaxDirec tMemorysize=5m
GC回收时间过长时会抛HoutofMemroyError. 过长的定义是，超过98%的时间用来做Gc并且回收了不到2%的堆内存
连续多次GC都只回收了不到2%的极端情况下才会抛出。假如不抛出GC overhead limit 错误会发生什么情况呢?
那就是GC清理的这么点内存很快会再次填满, p迫使GC再次执行，这样就形成恶性循环,
CPU使用率一直是100%， 而GC 却没有任何成果

public class GCOverheadDemo {
    public static void main(String[] args) {
        int i= 0;
        ArrayList<Object> list = new ArrayList<>();
        try {
            while (true){
                list.add(String.valueOf(++i).intern());
            }
        } catch (Exception e) {
            System.out.println("**************"+i);
            e.printStackTrace();
            throw e;
        }
    }

}

4. Java.lang.OutOfMemeoryError:Direct buffer memory

导致原因:
写NIO程序经常使用ByteBuffer来读取或者写入数据,这是-种基于通道(Channel)与缓冲区(Buffer)的I/0方式,
它可以使用Native西数库直接分配堆外内存，然后通过- -个存储在Java堆里面的DirectByteBuffer对象作为这块内存的引用进行操作。
这样能在-些场景中显蓍提高性能，因为避免了在Java堆和Native堆中来回复制数据。
ByteBuffer. al locate(capability)第- -种方式是分配JVM堆内存， 属于GC管辖范围，由于需要拷贝所以速度相对较慢
ByteBuffer. allocteDirect(capability)第2种方式是分配OS本地内存， 不属于GC 管辖范围，由于不需要内存拷贝所以速度相对较快。
但如果不断分配本地内存，堆内存很少使用，那么JVM就不需要执行GC, DirectByteBuffer对象们就不会 被回收,
这时候堆内存充足，但本地内存可能已经使用光了, 再次尝试分配本地内存就会出现OutOfMemoryError, 那程序就直接崩溃了。

图解

5. Java.lang.OutOfMemeoryError:unable to create new native thread

public class UnableCreatNewThreadDemo {
    public static void main(String[] args) {
        for (int i = 0; ; i++) {
            System.out.println("*****"+i);
            new Thread(()->{
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
            
        }
    }
}

服务器级别的参数调优

6. Java.lang.OutOfMemeoryError:Metaspace
使用Java -XX:+PrintFlagsInitial命令查看本机的初始化参数，-XX:MetaspaceSize为21810376B(约20M)

元空间里面创建静态的类

public class MetaspaceOOMTest {
    static class OOMTest{}

    public static void main(String[] args) {
        int i=0;
        try {
            while (true){
                i++;
                Enhancer enhancer=new Enhancer();
                enhancer.setSuperclass(OOMTest.class);
                enhancer.setUseCache(false);
                enhancer.setCallback(new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        return methodProxy.invokeSuper(o,args);
                    }
                });
            }
        } catch (Exception e) {
            System.out.println("发生多少次异常"+i);
            e.printStackTrace();
        }
    }
}

6、G垃圾回收算法和垃圾收集器的关系?分别是什么请你谈谈

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

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

4种主要垃圾收集器
架构图解：

java11到Java12 用 ZGC
对前三个的总结：

串行垃圾回收器（Serial）

它为单线程环境设计并且只使用一个线程进行垃圾回收，会暂停所有的用户线程。所以不适合服务器环境

并行垃圾回收器（Parallel）

多个垃圾回收线程并行工作，此时用户线程是暂停的，适用于科学计算/大数据处理等弱交互场景

并发垃圾回收器（CMS）

用户线程和垃圾收集线程同时执行（不一定是并行，可能交替执行），不需要停顿用户线程
互联网公司多用它，适用于对响应时间有要求的场景

G1垃圾回收器

G1垃圾回收器将堆内存分割成不同的区域然后并发的对其进行垃圾回收

7、怎么查看服务器默认的垃圾收集器是那个?生产上如何配置垃圾收集器的?谈谈你对垃圾收集器的理解?

GC的概览图：

怎么查看默认的垃圾收集器是哪个？

默认的垃圾收集器有哪些

old区的串行垃圾回收已经没有在用了
垃圾收集器


部分参数预先说明

DefNew：Default New Generation
Tenured：Old
ParNew：Parallel New Generation
PSYoungGen：Parallel Scavenge
ParOldGen：Parallel Old Generation

Server/Client模式分别是什么意思

新生代
串行GC（Serial）/（Serial Coping）

并行GC(ParNew)

并行回收GC(Parallel)/(Parallel Scavenge)

老年代
串行回收GC(Serial Old)/(Serial MSC)

并行GC(Parallel Old)/(Parallel MSC)

并发标记清除GC(CMS)
好处是节约内存空间，坏处是内存空间碎片化

4步过程
初始标记(CMS initial mark)

并发标记(CMS concurrent mark)和用户线程一起

重新标记(CMS remark)

并发清除(CMS concurrent sweep)和用户线程一起

总结：

优缺点：
优点：并发收集低停顿
缺点：并发执行，对CPU资源压力大

采用的标记清除算法会导致大量碎片

如何选择垃圾回收器

8、G1垃圾收集器
以前收集器特点：
年轻代和老年代是各自独立且连续的内存块
年轻代收集使用单eden+S0 +S进行复制算法
老年代收集必须扫描整个老年代区域
都是以尽可能少而快速地执行GC为设计原则

G1是什么




G1底层原理
Region区域化垃圾收集器


最大好处是化整为零，避免全内存扫描，只需要按照区域来进行扫描即可

回收步骤

4步过程

常用配置参数(了解)
-XX:+UseG1GC
-XX:G1HeapRegionSize=n : 设置G1区域的大小。值是2的幂，范围是1M到32M。目标是根据最小的Java堆大小划分出约2048个区域
-XX:MaxGCPauseMillis=n : 最大停顿时间，这是个软目标，JVM将尽可能（但不保证）停顿时间小于这个时间
-XX:InitiatingHeapOccupancyPercent=n 堆占用了多少的时候就触发GC，默认是45
-XX:ConcGCThreads=n 并发GC使用的线程数
-XX:G1ReservePercent=n 设置作为空闲空间的预留内存百分比，以降低目标空间溢出的风险，默认值是10%
和CMS相比的优势


SpringBoot和JVM调优
实际工作中如何进行调优？