JVM

JVM探究

• 请你谈谈你对JVM的理解，java8虚拟机和之前的变化更新？
• 什么是OOM，什么是栈溢出StackOverFlowError？怎么分析
• JVM的常用调优参数有哪些？
• 内存快照如何抓取，怎么分析Dump文件？
• 谈谈JVM中，你对类加载器的认识？

1.JVM的位置

2.JVM的体系结构



3.类加载器
作用：加载Class文件～

• 虚拟机自带的加载器
• 启动类（根）加载器
• 扩展类加载器
• 应用程序加载器

public class Car {
    public int age;
    public static void main(String[] args) {
        //类是模版，对象是具体的
        Car car1=new Car();
        Car car2=new Car();
        Car car3=new Car();

        System.out.println(car1.hashCode());
        System.out.println(car2.hashCode());
        System.out.println(car3.hashCode());
        Class<? extends Car> aClass1 = car1.getClass();

        ClassLoader classLoader = aClass1.getClassLoader();//AppClassLoader
        System.out.println(classLoader.getParent());//ExtClassLoader  /jre/lib/ext
        System.out.println(classLoader.getParent().getParent());//null 1.不存在 2.Java程序获取不到 rt.jar
    }
}

4.双亲委派机制

 * 1.类加载器收到类加载的请求
 * 2.将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类加载器
 * 3.启动类加载器检查是否能够加载当前这个类，能加载就结束，使用当前加载器，否则抛出异常，通知子加载器加载
 * 4.重复步骤3
 * Class Not Found
 * null ：Java调用不到 c、c++

package java.lang;

public class String {
    //双亲委派机制：安全
    //1.App-->EXC-->BOOT(最终执行根加载器)
    @Override
    public String toString(){
    return "Hello";
    }

    public static void main(String[] args) {
        String s = new String();
        s.toString();
    }
     /**
     * 1.类加载器收到类加载的请求
     * 2.将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类加载器
     * 3.启动类加载器检查是否能够加载当前这个类，能加载就结束，使用当前加载器，否则抛出异常，通知子加载器加载
     * 4.重复步骤3
     *Class Not Found
     * null ：Java调用不到 c、c++
     */
}

5.沙箱安全机制（代码是安全的，了解）
6.Native

• native: 凡是带了native关键字，说明Java的作用范围达不到了，会去调用底层C语言的库
• 会进入本地方法栈
• 调用本地方法接口 JNI
• JNI作用：扩展Java的使用，融合不同的编程语言为JAVA所用，最初：C、C++
• Java诞生的时候 C、C++ 横行，想要立足，必须要有调用C、C++的程序
• 他在内存区域中专门开辟了一块标记区域：Native Method Stack 登记 native 方法
• 在最终执行的时候，加载本地方法库中的方法通过JNI

public class Demo {
    public static void main(String[] args) {
new Thread(()->{

},"my thread name").start();
    }
    //native: 凡是带了native关键字，说明Java的作用范围达不到了，会去调用底层C语言的库
    //会进入本地方法栈
    //调用本地方法接口 JNI
    //JNI作用：扩展Java的使用，融合不同的编程语言为JAVA所用，最初：C、C++
    //Java诞生的时候 C、C++ 横行，想要立足，必须要有调用C、C++的程序
    //他在内存区域中专门开辟了一块标记区域：Native Method Stack 登记 native 方法
    //在最终执行的时候，加载本地方法库中的方法通过JNI

    //Java程序驱动打印 管理系统 Robot
    private native void start0();

    //调用其他接口：Socket webService http
}

7.PC寄存器
程序计数器：Program Counter Register
每个线程都有一个程序计数，是线程私有的，就是一个指针，指向方法区中的方法字节码，（用来存储指向一条指令的地址，也即将要执行的指令代码），在执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不计
8.方法区
Method Area 方法区
方法区是被所有线程共享的，所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义，简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间
静态变量、常量、类信息（构造方法、接口定义）、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关
static、final、Class、常量池
9.栈：数据结构

• 程序=数据结构+算法
• 栈：先进后出、后进先出
• 队列：先进先出（FIFO：First Input First Output）
• 栈：栈内存，主管程序运行，生命周期和线程同步；线程结束，栈内存也就释放了，对于栈来说，不存在垃圾回收问题，一旦线程结束，栈就Over了
• 存放：8大基本类型+对象引用+实例的方法
• 栈运行原理：栈帧
• 栈满了：StackOverflowError
  
• 栈+堆+方法区交互关系
  

喝多了吐就是栈，吃多了拉就是队列

10.三种JVM

• Sun公司 HotSpot Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.6+8-LTS, mixed mode)
• BEA JRockit
• IBM J9VM

11.堆 Heap

• 一个JVM只有一个堆内存，堆内存的大小是可以调节的
• 类加载器读取完类文件之后，一般把类、方法、常量、变量放在堆中，会保存我们所有引用类型的真实对象
• 堆内存中还要细分为三个区域：
  • 新生区（伊甸园区）
  • 养老区
  • 永久区
    
    GC垃圾回收，主要在伊甸园区和养老区
    假设内存满了，OOM，堆内存不够 java.lang.OutOfMemoryError:Java heap space
    在JDK8以后，永久存储区改了名字（元空间）

12.新生区、老年区、永久区

• 新生区：

  • 类：诞生和成长的地方，甚至死亡
  • 伊甸园区
  • 幸存者区（0，1）

• 老年区：

经过研究，99%的对象都是临时对象

• 永久区：这个区域常驻内存的，用来存放JDK自身携带的Class对象，Interface元数据，存储的是Java运行时的一些环境或类信息，这个区域不存在垃圾回收！关闭虚拟机就会释放这个区域的内存
  一个启动类，加载了大量的第三方jar包。tomcat部署了太多的应用，大量动态生成的反射类，不断被加载，直到内存满，就会出现OOM
  • jdk1.6之前：永久代，常量池在方法区中
  • jdk1.7：永久代，但是慢慢的退化了去永久代，常量池在堆中
  • jdk1.8之后：无永久代，常量池在元空间

元空间：逻辑上存在，物理上不存在

public class Demo02 {
    public static void main(String[] args) {
        //返回虚拟机试图使用的最大内存
        long max=Runtime.getRuntime().maxMemory();//字节 1024*1024
        //返回jvm的初始化总内存
        long total=Runtime.getRuntime().totalMemory();
        System.out.println("max+"+max+"字节\t"+(max/1024/1024)+"MB");//1082M
        System.out.println("total+"+total+"字节\t"+(total/1024/1024)+"MB");//123M
        //默认情况下，分配的总内存是电脑内存的1/4，而初始化的内存1/64

        //OOM
        //1.尝试扩大堆内存
        //2.分析内存，看一下哪个地方出现了问题（专业工具）
    }
}

在一个项目中，突然出现OOM故障，那么该如何排除，研究为什么出错

• 能够看到第几行代码出错：内存快照分析工具，MAT，Jprofiler
• Debug，一行行代码分析

MAT，Jprofiler作用：

• 分析Dump内存文件，快速定位内存泄漏；
• 获得堆中的数据
• 获得大的对象

//-Xms 设置初始化内存分配大小
//-Xmx 设置最大分配内存
//-XX:+PrintGCDetails   打印GC垃圾回收信息
//-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError  //oom DUMP
public class Demo03 {
    byte[] array = new byte[1 * 1024 * 1024];

    public static void main(String[] args) {
        ArrayList<Demo03> list = new ArrayList<>();
        int count = 0;
        try {
            while (true) {
                list.add(new Demo03());//问题所在
                count++;
            }
        } catch (Exception e) {
            System.out.println("count:"+count);
            e.printStackTrace();
        }


    }
}

下载Jprofiler使用

12.GC 垃圾回收 — 常用算法

JVM在进行GC时，并不是对这三个区域统一回收，大部分时候回收都是新生代

• 新生代
• 幸存区（from， to）
• 老年代

GC两种类：轻GC（普通GC），重GC（全局GC）

题目：

• JVM的内存模型和分区 详细到每个区放什么
• 堆里面的分区有哪些？ Eden，from，to，老年区，说说特点
• GC的算法有哪些？标记清除法，标记压缩，复制算法，引用计数器，怎么使用
• 轻GC和重GC分别在什么时候发生？

引用计数法：

复制算法：

• 好处：没有内存的碎片
• 坏处：浪费了内存空间：多了一半空间永远是空的 to。假设对象100%存活（极端情况）

复制算法最佳使用场景：对象存活度较低的时候：新生区～

标记清除算法：

• 优点：不需要额外的空间
• 缺点：两次扫描，严重浪费时间，会产生内存碎片

标记压缩

再优化：

总结：
内存效率：复制算法>标记清除算法>标记压缩算法（时间复杂度）
内存整齐度：复制算法=标记压缩算法>标记清除算法
内存利用率：标记压缩算法=标记清除算法>复制算法

年轻代：

• 存活率低
• 复制算法

老年代：

• 区域大：存活率
• 标记清除（内存碎片不是太多）+标记压缩混合实现

13.JMM ：Java Memory Model

• 什么是JMM？
  Java内存模型（百度百科）

• 干嘛的？

  • 作用：缓存一致性协议，用于定义数据读写规则

  • JMM定义了线程工作内存和主内存之间的抽象关系：线程之间的共享变量存储在主内存（Main
    Memory）中，每个线程都有一个私有的本地内存（Local Memory）

    • 解决共享对象可见性问题：volatile

• 如何学习？

  • JMM：抽象概念，理论

  • JMM对这八种指令的使用，制定了如下规则：

    • 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
    • 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
    • 不允许一个线程将没有assign的数据从工作内存同步回主内存
    • 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
    • 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
    • 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
    • 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
    • 对一个变量进行unlock操作之前，必须把此变量同步回主内存
      　　JMM对这八种操作规则和对volatile的一些特殊规则就能确定哪里操作是线程安全，哪些操作是线程不安全的了。但是这些规则实在复杂，很难在实践中直接分析。所以一般我们也不会通过上述规则进行分析。更多的时候，使用java的happen-before规则来进行分析

  • volatile