第43天学习打卡（JVM探究）

JVM探究

请你谈谈你对JVM的理解？Java8虚拟机和之前的变化更新？

什么是OOM,什么是栈溢出StackOverFlowError? 怎么分析？

JVM的常用调优参数有哪些？

内存快照如何抓取，怎么分析Dump文件？

谈谈JVM中，类加载器的认识？ rt-jar ext application

1.JVM的位置

我们学习的是HotSpot虚拟机。

2.JVM的体系结构

Java ---->Class Fiel------>类加载器（Class Loader）:

方法区（Methode Area） Java栈(Stack) 本地方法栈(Native Method Stack)

堆 (Heap) 程序计数器

执行引擎 本地方法接口

调优99%调的是堆

3.类加载器

作用：加载Class文件

类是模板抽象的， 对象是具体的

1.虚拟机自带的加载器

2.启动类（根）加载器

3.扩展类加载器

4.应用程序（系统类）加载器

4.双亲委派机制（安全）：向上委派 再向下委派

APP--->EXC--->BOOT（最终执行）

BootstrapClassLoader(启动类加载器)：c++编写，加载java核心库java*,构造ExtClassLoader和AppClassLoader。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。

ExtClassLoader(标准扩展类加载器)：java 编写，加载扩展库classpath的jre,javax.*或者java.ext.dir 指定位置中的类，开发者可以直接使用标准扩展类加载器。

AppClassLoader(系统类加载器):java编写，加载程序所在的目录，如user.dir所在的位置的class

双亲指EXT 和Boot,即APP的父亲和爷爷类

1.类加载器收到类加载的请求

2.将这个请求向上委托给父类加载器区完成，一直向上委托。直到启动类加载器

3.启动加载器检查是否能够加载当前这个类，能加载就结束，使用当前的加载器，否则，抛出异常，通知子加载器进行加载

4.重复步骤3

null:表示Java调用不到 因为是用C、 C++写的

5.沙箱安全机制

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

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

在java中将执行程序分成本地代码和远程代码两种，本地代码默认视为可信任的，而远程代码则被看作是不受信的。对于授信的本地代码，可以访问一切本地资源。而对于非授信的远程代码在早期的Java实现中，安全依赖于沙箱（Sanbox）机制。

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

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

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

组成沙箱的基本组件：

字节码校验器（bytecode verifier）:确保java类文件遵循java语言规范。这样可以帮助Java程序实现内存保护。但并不是所有的类文件都会经过字节码校验，比如核心类。

类装载器（class loader）:其中类装载器在3个方面对java沙箱起作用。

它防止恶意代码去干涉善意的代码；//双亲委派机制

它守护了被信任的类库边界；

它将代码归入保护域，确定了代码可以进行哪些操作。

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

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

1.最内存JVM自带类加载器开始加载，外层恶意同名类得不到加载从而无法使用；

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

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

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

安全软件包（security pakage）:java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括：

安全提供者

消息摘要

数字签名：keytools

加密

鉴别

6.Native

 package com.kuang;
 ​
 public class Demo {
     public static void main(String[] args) {
         new Thread(()->{
 ​
         },"my thread name").start();
     }
 ​
     //native:凡是带了native关键字的，说明java的作用范围达不到了，回去调用底层c语言的库
     //会进入本地方法栈
     //调用本地方法接口 JNI
     //JNI作用：扩展java的使用，融合不同的编程语言为Java所用！
     //java诞生的时候C、C++横行，想要立足，必须要有调用C、C++的程序
     //它在内存区域中专门开辟了一块标记区域、；Native Method Stach,登记native方法
     //在最终执行的时候，加载本地方法库中的方法通过JNI
     private native void start0();
 ​
     //调用其他接口：Socket.. WebService  http~
 ​
 }
 ​

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

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

Native Method Stack

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

7.PC寄存器

程序计数器：Program Counter Register

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

8.方法区

Method Area方法区

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

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

 static final Class 常量池

9.栈:数据结构

程序 = 数据结构 + 算法

栈：先进后出 后进先出:类似于桶结构

队列：先进先出（FIFO:First Input First Output）

栈：栈内存，主管程序的运行，生命周期和线程同步；线程结束，栈内存也就释放，对于栈来说，不存在垃圾回收问题，一旦线程结束，栈也结束。

线程是私有的。

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

栈运行原理：栈帧

栈满了：StackOverflowError

程序正在执行的方法，一定在栈的顶部。

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

10.三种JVM

Sun公司HotSpot Java HotSpot(TM) 64-Bit Server VM (build 25.281-b09, mixed mode)

BEA公司： JRockit

IBM:J9 VM

我们学习的都是HotSpot

11 .堆

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

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

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

新生区（伊甸园区）Young/New:

伊甸园（Eden Space）

幸存区0区

幸存区1区

养老区 old

永久区Perm

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

假设内存满了，OOM，堆内存不够！java.lang.OutOfMemoryError:Java heap space

在JDK8以后，永久存储区给了个名字（元空间）

12 .新生区

类：诞生和成长的地方，甚至死亡；

伊甸园：所有的对象都是在伊甸园区new出来的！

幸存区（0，1）

真理：经过研究，99%的对象都是临时对象！

老年区

13. 永久区

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

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

jdk1.6之前:永久代，常量池是在方法区

jdk1.7：永久代，但是慢慢的退化了，去永久代，常量池在堆中

jdk1.8之后：无永久代，常量池在元空间

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

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

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

Dubug.一行行分析代码。

MAT,Jprofiler作用：

分析Dump内存文件，快速定位内存泄露；

获得堆中的数据

获得大的对象...

内存设置 首先点击菜单栏的Run-->EditConfiguration-->之后点击图片上的位置进行设置（Modify option-->Add VM options）

 package com.kuang.demo05;
 ​
 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/(double)1024/1024)+"MB");
         System.out.println("total"+max+"字节\t"+(total/(double)1024/1024)+"MB");
         //默认情况下：分配的内存 是电脑内存的1/4,而初始化的内存：1/64
 ​
         //-Xms1024m -Xmx1024m -XX:+PrintGCDetails
     }
     //遇到OOM的解决方法:
        //1.尝试扩大堆内存看结果
         //2.分析内存，看一下那个地方出现了问题（专业工具）
     //-Xms1024m -Xmx1024m -XX:+PrintGCDetails
 ​
     //305664K + 699392K = 1,005,056K = 981.5M
 }
 ​

输出结果：

max1029177344字节 981.5MB total1029177344字节 981.5MB Heap PSYoungGen total 305664K, used 20971K [0x00000000eab00000, 0x0000000100000000, 0x0000000100000000) eden space 262144K, 8% used [0x00000000eab00000,0x00000000ebf7afb8,0x00000000fab00000) from space 43520K, 0% used [0x00000000fd580000,0x00000000fd580000,0x0000000100000000) to space 43520K, 0% used [0x00000000fab00000,0x00000000fab00000,0x00000000fd580000) ParOldGen total 699392K, used 0K [0x00000000c0000000, 0x00000000eab00000, 0x00000000eab00000) object space 699392K, 0% used [0x00000000c0000000,0x00000000c0000000,0x00000000eab00000) Metaspace used 3234K, capacity 4496K, committed 4864K, reserved 1056768K class space used 354K, capacity 388K, committed 512K, reserved 1048576K

Process finished with exit code 0

14 .堆内存调优

 package com.kuang.demo05;
 ​
 import java.util.ArrayList;
 //-Xms 设置初始化内存分配大小1/64
 //-Xmx 设置最大分配内存 默认1/4
 //-XX:+PrintGCDetails  打印垃圾回收信息
 //-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<Object> list = new ArrayList<>();
         int count = 0;
         try {
             while(true){
                 list.add(new Demo03());//问题所在
                 count = count+1;
             }
         }catch (Error e){
             System.out.println("count:" + count );
             e.printStackTrace();
 ​
         }
     }
 }
 ​

15 .GC:垃圾回收

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

新生代

幸存区（from to）

老年区

GC两种类：轻GC(普通的GC)、重GC(全局GC)

GC的算法：标记清除算法 标记压缩 复制算法 引用计数器

引用计数法：

每次GC都会Eden 活的对象移到幸存区中：一旦Eden区域被GC后，就会是空。

谁空谁是to

当一个对象经历了15次（年龄标志位只有4位 所以15为最大次数）GC，都还没有死，-XX: -XX:MaxTenuringThreshold=9999 通过这个参数可以设定进入老年代的时间

好处：没有内存的碎片

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

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

标记清除算法

优点：不需要额外的空间

缺点：两次扫描，严重浪费时间，会产生内存碎片

总结

内存效率：复制算法>标记清除算法>标记压缩算法（时间复杂度）

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

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

GC：分代收集算法

年轻代：

存活率低

复制算法

老年代：

区域大：存活率高

标记清除（内存碎片不是很多） + 标记压缩混合实现

《深入理解JVM》

16.JMM：Java Memory Model：Java内存模型

1.JMM的作用：缓存一致性协议，用于定义数据读写的规则（遵守，找到这个规则）。

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

解决共享对象可见性这个问题：volilate

2.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规则来进行分析。