Java学习之JVM探究-2021-08-28~31

JVM探究

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

1.JVM的位置

---

2.JVM的体系结构

---

3.类加载器

作用: 加载Class文件~ new Student();

​ 1,虚拟机自带的加载器

​ 2.启动类(根)加载器, Boot 负责加载 Java_HOME/lib 目录中的类库

​ 3,扩展类加载器 Ext 负责加载 Java_HOME/lib/ext 目录中的类库

​ 4·应用程序(系统类)加载器 App 负责加载用户路径（classpath）上的类库

,除了上述几种类加载器,我们也可以通过继承java. lang.ClassLoader实现自定义的类加载器

package com.wyy.jvm;

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(car3.hashCode());
        System.out.println(car3.hashCode());

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

        Class<? extends Car> aClass1 = car1.getClass();

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

    }
}

4·双亲委派机制

---

双亲委派机制是指一个类在收到类加载请求后不会尝试自己加载这个类，而是把该类加载请求向上委派给其父类加载器去完成，其父类加载器在接收到该类加载请求后又会将其委派给自己的父类，以此类推，这样所有的类加载请求都被向上委派到启动类加载器中。若父类加载器在接收到类加载请求后发现自己也无法加载该类（通常原因是该类的Class文件在父类的类加载路径中不存在），则父类会将该信息反馈给子类并向下委派子类加载器加载该类，直到该类被成功加载，若找不到该类，则JVM会抛出ClassNotFoud异常。

将自定义加载器挂载到应用程序类加载器。

1. 应用程序类加载器将类加载请求委托给扩展类加载器。
2. 扩展类加载器将类加载请求委托给启动类加载器。
3. 启动类加载器在加载路径下查找并加载Class文件，如果未找到目标Class文件，则交由扩展类加载器加载。
4. 扩展类加载器在加载路径下查找并加载Class文件，如果未找到目标Class文件，则交由应用程序类加载器加载。
5. 应用程序类加载器在加载路径下查找并加载Class文件，如果未找到目标Class文件，则交由自定义加载器加载。
6. 在自定义加载器下查找并加载用户指定目录下的Class文件，如果在自定义加载路径下未找到目标Class文件，则抛出ClassNotFoud异常。

package java.lang;

public class String {
    // 双亲委派机制:安全
    // 1.APP-->EXC---BOOT(最终执行)
    // app->ext->bootstrape
    // BOOT
    // EXC
    // APP

    public String toString() {
        return "Hello";
    }

    public static void main(String[] args) {

        String string = new String();
        System.out.println(string.getClass().getClassLoader());
        string.toString();

        new Thread().start();
    }
    /**
     * 1·类加载器收到类加载的请求
     * 2．将这个请求向上委托给父类加载器去完成，一直向上委托，知道启动类加载器
     * 3．启动加载器检查是否能够加载当前这个类, 能加载就结束,使用当前的加载器,否则,抛出异常,通知子加载器进行加载
     * 4.重复步骤 3
     *  Class Not Fount ~
     *  null: java调用不到~ C,C++
     *  JAVA = C++:去掉繁琐的东西,指针,内存管理 = C++--
     */

}

package com.wyy.jvm;

public class Student {
    @Override
    public String toString() {
        return "Hello";
    }

    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getClass().getClassLoader());//AppClassLoader
        System.out.println(student.toString());

    }
}

5·沙箱安全机制

---

Java安全模型的核心就是ava沙箱(sandbox) ,什么是沙箱?沙箱是一个限制程序运行的环境。沙箱机制就是将Java代码限定在虚拟机JVM)特定的运行范围中,并且严格限制代码对本地系统资源访问,通过这样的措施来保证对代码的有效隔离,防止对本地系统造成破坏。沙箱主要限制系统资源访问,那系统资源包括什么? CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。

所有的Java程序运行都可以指定沙箱,可以定制安全策略。

在Java中将执行程序分成本地代码和远程代码两种,本地代码默认视为可信任的,而远程代码则被看作是不受信的。对于授信的本地代码,可以访问一切本地资源。而对于非授信的远程代码在早期的Java实现中,安全依赖于沙箱(Sandbox)机制。如下图所示JDK1.0安全模型

但如此严格的安全机制也给程序的功能扩展带来障碍,比如当用户希望远程代码访问本地系统的文件时候,就无法实现。因此在后续的Java 1.1版本中,针对安全机制做了改进,增加了安全策略,允许用户指定代码对本地资源的访问权限。如下图所示JDK1.1安全模型

在Java1.2版本中,再次改进了安全机制,增加了代码签名。不论本地代码或是远程代码,都会按照用户的安全·策略设定,由类加载器加载到虚拟机中权限不同的运行空间,来实现差异化的代码执行权限控制。如下图所示JDK1.2安全模型

当前最新的安全机制实现,则引入了域(Domain)的概念。虚拟机会把所有代码加载到不同的系统域和应用域,系统域部分专门负责与关键资源进行交互,而各个应用域部分则通过系统域的部分代理来对各种需要的资源进行访问。虚拟机中不同的受保护域(Protected Domain),对应不一样的权限(Permission),存在于不同域中的类文件就具有了当前域的全部权限,如下图所示最新的安全模型(jdk 1.6)

组成沙箱的基本组件:

• 字节码校验器( bytecode verifier) :确俐ava类文件遵循Java语言规范。这样可以帮助Java程序实现内存保护。但并不是所有的类文件都会经过字节码校验,比如核心类。
• 类装载器(class loader) :其中类装载器在3个方面对Java沙箱起作用
  • 它防止恶意代码去干涉善意的代码; //双亲委派机制
  • 它守护了被信任的类库边界。
  • 它将代码归入保护域,确定了代码可以进行哪些操作。

虚拟机为不同的类加载器载入的类提供不同的命名空间,命名空间由一系列唯一的名称组成,每一个被装载的类将有一个名字,这个命名空间是由ava虚拟机为每一个类装载器维护的,它们互相之间甚至不可见。

​ 类装载器采用的机制是双亲委派模式。

1,从最内层VM自带类加载器开始加载,外层恶意同名类得不到加载从而无法使用

2,由于严格通过包来区分了访问域,外层恶意的类通过内置代码也无法获得权限访问到内层类,破坏代码就自然无法生效。

• 存取控制器(access controller) :存取控制器可以控制核心API对操作系统的存取权限,而这个控制的策略设定，可以由用户指定。

• 安全管理器(security manager) :是核心API和操作系统之间的主要接口。实现权限控制,比存取控制器优先级高。

• 安全软件包(security package) : java.security下的类和扩展包下的类,允许用户为自己的应用增加新的安全特性,包括:

  • 安全提供者
  • 消息摘要
  • 数字签名 keytools
  • 加密
  • 鉴别

//        Robot robot = new Robot();// 可以操作电脑

6.Native

---

编写一个多线程类启动

public static void main(String[] args) {
    new  Thread(()->{
    hello();
    },"my thread name").start();
}

点进去看start方法的源码

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

凡是带了native关键字的,说明java的作用范围达不到,去调用底层C语言的库!

JNI: Java Native Interface (Java本地方法接口)

凡是带了native关键字的方法就会进入本地方法栈,其他的就是Java栈;

Native Interface本地接口

本地接口的作用是融合不同的编程语言为Java所用,它的初衷是融合C/C++程序, Java在诞生的时候是C/C++横行的时候,想要立足,必须有调用C、 C++的程序,于是就在内存中专门开辟了一块区域处理标记为native的代码,它的具体做法是在Native Method Stack中登记native方法,在( Execution Engine )执行引擎执行的时候加载Native Libraies.

目前该方法使用的越来越少了,除非是与硬件有关的应用,比如通过Java程序驱动打印机或者Java系统管理生产设备,在企业级应用中已经比较少见。因为现在的异构领域间通信很发达,比如可以使用Socket通信,也可以使用Web Service等等,不多做介绍!

Native Method Stack

I它的具体做法是Native Method Stack中登记native方法,在(Execution Engine )执行引擎执行的时候加载Native Libraies. 【本地库】

package com.wyy.jvm;

public class Demo {
    public static void main(String[] args) {
        new  Thread(()->{
        hello();
        },"my thread name").start();
    }
    // native : 凡是带了native关键字的,说叨java的作用范期达不到了,会去调川底层语言的库!
    // 会进入本地方法栈
    // 调用本地方法本地接口 JNI(Java Native Interface)
    // JNI作用: 少展Java的使用,融合不同的编程语言为Java所用! 最初: C.C++.
    // Java诞尘的时候c、C+横行,想要正足,必须要有调用、Ct+的程序~
    // 它在内存区域中专门开辟了一块标i区域: Native Method Stack,登记native方法
    // 在最终执行的时候,加载本地方法库中的方法通过JNI

    // Java程序驱动打印机,管理系统,掌握即可,在企业级应用中较为少见!
    public static native void hello();

    // 调用其他接口:  Socket..WebService~..http~
//球球爱心网: --→输入 (PHP) --> Node]s --> Socket -->ct+-> 游戏刷爱心

}

7.PC寄存器

---

程序计数器: Program Counter Register

每个线程都有一个程序计数器,是线程私有的,就是一个指针,指向方法区中的方法字节码(用来存储指向像一条指令的地址,也即将要执行的指令代码) ,在执行引擎读取下一条指令,是一个非常小的内存空间,几乎可以忽略不计

计数器还有记住下一条jvm指令的执行地址的作用。多线程切换可以继续不乱的往下执行下一个指令。

8.方法区

---

Method Arda方法区

方法区是被所有线程共享,所有字段和方法字节码,以及一些特殊方法,如构造函数,接口代码也在此定义,·简单说,所有定义的方法的信息都保存在该区域**,此区域属于共享区间;**

​ 静态变量、常量、类信息(构造方法、接口定义)、运行时的常量池存在方法区中,但是实例变量存在堆内存中,和方法区无关

static,final,Class,常量池

9.栈

---

栈:数据结构

程序 = 数据结构 + 算法 :持续学习~

程序 = 框架 + 业务逻辑~ : 淘汰! (吃饭用的)

• 栈:先进后出、后进先出: 桶

• 队列: 先进先出(FIFO:First Input First Output)

​ 喝多了吐就是栈,吃多了拉就是队列(弹夹和排队)

为什么main()先执行,最后结束

• 栈: 栈内存,主管程序的运行, 生命周期和线程同步;

  线程结束,栈内存也就释放了,对应栈来说,不存在垃圾回收问题

  一旦线程结束,栈就Over

栈:.8大基本类型+对象引用+实例的方法

栈运行原理: 栈帧

栈满了: StackOverflowError

栈+堆+方法区:交互关系

10.三种IVM

---

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

我们学习都是: Hotspot

11.堆

---

Heap,一个JVM只有一个堆内存,堆内存的大小是可以调节的。

类加载器读取了类文件后,一般会把什么东西放到堆中? 类,方法,常量,变量,保存我们所有引用类型的真实对象;

堆内存中还要细分为三个区域:

• 新生区(伊甸园区) Young/New
• 养老区 oldl
• 永久区 Perm

GC垃圾回收,主要是在伊甸园区和养老区~

假设内存满了, OOM,堆内存不够!

在JDK8以后,永久存储区改了个名字(元空间)

新生区&老年区

新生区

• 类:诞生和成长的地方，甚至死亡;
• 伊甸园,所有的对象都是在伊甸园区new出来的
• 幸存者区(0,1)

真理:经过研究, 99%的对象都是临时对象!

永久区

这个区域常驻内存的。用来存放DK自身携带的Class对象。Interface元数据,存储的是Java运行时的一些环境或类信息-,这个区域不存在垃圾回收!关闭VM虚拟就会释放这个区域的内存~

一个启动类,加载了大量的第三方jar包。Tomcat部署了太多的应用,大量动态生成的反射类。不断的被加载。直到内存满,就会出现OOM;

• jdk1.6之前:永久代,常量池是在方法区;
• jdk1.7 :永久代,但是慢慢的退化了,去永久代,常量池在堆中
• jdk1.8之后:无永久代,常量池在元空间

元空间:逻辑上存在:物理上不存在

在一个项目中,突然出现了00M故障,那么该如何排除~ 研究为什么出错~

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

MAT, Jprofiler作用

• 分析Dump内存文件,快速定位内存泄露;
• 获得堆中的数据
• 获得大的对象～
• …

推荐jdk自带的jvisualvm, 简单实用

堆内存调优

在这里进行打印分析错误的信息

案例代码:

package com.wyy.jvm;

import java.util.ArrayList;


// -Xms设置初始化内存分虎大小/164
// -Xmx设置最大分配内存,默认1/4
// -XX:+PrintGCDetails /打印GC垃圾回收信总
// -XX:+HeapDumpOnOutOfMemoryError //oom DUMP

//-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
public class Demo03 {
    byte[] array = new byte[1 * 1024 * 1024];//1m

    public static void main(String[] args) {
        ArrayList<Demo03> list = new ArrayList<>();

        int count = 0;

        try {
            while (true){
                list.add(new Demo03());
                count++;
            }
        } catch (Error e) {
            System.out.println("count:"+count);
            e.printStackTrace();
        }
        // Throwable
            // Exception
            // error
    }
}

package com.wyy.test;

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");
        System.out.println("total="+total+"字节\t"+(total/1024/1024)+"MB");
        //数认情况下:分配的总内存是电脑内存的1/4,而初始化的内存: 1/64


        //OOM:
            // 1.尝试扩大堆内存看结果
            // 2.分析内存,看一下那个地方出现了问题（专业工具)
        //-Xms1024m -Xmx1024m -XX:+PrintGCDetails

        //      314560K + 699072K = 989.875M
    }
}

package com.wyy.test;

import java.util.Random;

//-Xms8m -Xmx8m -XX:+PrintGCDetails
public class Hello {
    public static void main(String[] args) {
        String str = "shijiujava";
        while (true){
            str += str +new Random().nextInt(8888888)+new  Random().nextInt(9999999);
        }
    }
}

查看生成的错误文件

软件给出了错误的行数

12.GC (垃圾回收)

---

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

• 新生代
• 幸存区(from , to )
• 老年区

GC两种类:轻GC (普通的GC) ,重GC (全局GC)

GC题目:

• JM的内存模型和分区-详细到每个区放什么?

• 堆里面的分区有哪些? Eden, form, to,老年区,说说他们的特点!

• GC的算法有哪些?标记清除法,标记压缩,复制算法,引用计数器, 怎么用?

• 轻GC和重GC分别在什么时候发生?

GC常用算法

引用计数法:

判断是否存活

复制算法:

• 好处:没有内存的碎片
• 坏处:浪费了内存的空间:多了一般空间永远是空 to.假设对象100%存活(极端情况)

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

标记清除法

存活的为绿色的

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

标记压缩

再优化:

标记清除压缩

先标记清除几次

再压缩~

总结:

---

内存效率:复制算法>标记清除算法>标记压缩算法(时间复杂度)

内存整齐度:复制算法=标记压缩算法>标记清除算法

内存利用率:标记压缩算法=标记清除算法>复制算法

---

思考一个问题:难道没有最优算法吗?

答案:没有,没有最好的算法,只有最合适的算法 —> GC: 分代收集算法

---

年轻代：

• 存活率低
• 复制算法!

老年代

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

一天时间学JVM,不现实,要深究,必须要下去花时间,和多看面试题,以及《深入理解JVM》

但是,我们可以掌握一个学习JVM的方法

13.JMM:

---

1.什么是JMM?

• JMM: (Java Memory Model的缩写)---->Java内存模型

2.它干嘛的? :官方,其他人的博客,对应的视频!

• 作用:缓存一致性协议,用于定义数据读写的规则。(遵守,找到这个规则)
• JMM定义了线程工作内存和主内存之间的抽象关系:线程之间的共享变量存储在主内存(Main Memory)中,每个线程都有一个私有的本地内存(Local Memory)

• 解决共享对象可见性这个问题: volilate(volilate 保证可见性，不保证原子性，保证指令不重排)

3,它该如何学习?

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对这八种操作规则和对yolatile的一些特殊规则就能确定哪里操作是线程安全,哪些操作是线程不安全的了。但是这些规则实在复杂,很难在实践中直接分析。所以一般我们也不会通过上述规则进行分析。更多的时候,使用java的happen-before规则来进行分析。

• volilate(volilate 保证可见性，不保证原子性，保证指令不重排)

14.总结

---

学习新东西是常态:.

• netty.
• Spring Cloud Alibaba

面试:

3/10 == pass out,面经=10,分析这10个?触类旁通:百度面试题?

,通过大量的面试总结,得出一套解题思路? 3~4.

怎么学习

1.百度

2.思维导图