java的JVM的初步探究

最新推荐文章于 2022-07-12 20:49:59 发布

Timous

最新推荐文章于 2022-07-12 20:49:59 发布

阅读量202

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_43911526/article/details/108876314

版权

java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

JVM探究

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

1.JVM的位置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z7KBVwva-1604803278682)(C:%5CUsers%5CAdministrator%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20200928222317385.png)]

2.JVM的体系结构

在这里插入图片描述

很多的第三方插件都是在执行引擎那一块加上的，其他的基本动不了

3.类加载器

作用：

加载class文件 new Student(); 引用放在javaStack，但是具体的实例是放在堆里面的

在这里插入图片描述

1.虚拟机自带的加载器

2.启动类（根）加载器

3.扩展类加载器

4.应用程序加载器

5.双亲委派机制

4.双亲委派机制

在这里插入图片描述

沙箱安全机制

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

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

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

在这里插入图片描述

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

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

在这里插入图片描述

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

在这里插入图片描述

组成沙箱的基本组件：

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

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

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

从内层JVM自带的类加载器开始加载，外层恶意同名类得不到加载进而无法使用；
由于严格的通过包来区分访问域，，外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效

存取控制：存取控制器可以控制核心API对操作系统的存取权限，而这个控制策略的设定可以由用户控制
安全管理器：是核心API和操作系统之间的主要接口，实现权限控制，比存取控制器优先级别高
安全软件包： java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括：
- 安全提供者
- 消息摘要
- 数字签名 keytools https 生成一个安全证书 https通过java实现
- 加密
- 鉴别

6.Native

package Native;

public class Demo {
    public static void main(String[] args) {
        new Thread(()->{
        } , "my thread name").start();
        //凡是带了native关键字的，说明了java的作用范围打不到了，会去调用底层的c语言的库
        //会进入本地方法栈 ， 调用本地方法接口   java  native interface
        //JNI的作用就是为了扩展java的使用融合不同的编程语言为java所用   最初就是为了融合c和c++
        // java诞生的时候  c 和 c ++  横行，必须要用调用c和c++的程序
        // 在内存中专门开辟了一块标记区域： native method stack  登记native方法
        //在最终执行的时候，加载本地方法库中的方法  通过jni
        //private native void start0();  就是一个单纯的class
        //java程序驱动打印机，  java去管理系统  robot 写外挂 在企业级应用中较为少见
        //调用其他接口：  Socket webService  http
        //  写其他的东西  通过socket来进行调用
    }
}

在这里插入图片描述

7.pc寄存器

程序技术器： programe counter register

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

8.方法区

Method Area 方法区

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

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

package Native;

public class Demo01 {
    private int a;
    private String name;
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        demo01.a=1;
        demo01.name="113";
    }
}

在这里插入图片描述

9.栈

一种数据结构，一般和队列做比较程序 = 数据结构 + 算法程序 = 框架 + 业务逻辑淘汰 SSM SSH SpringBoot SpringCloud

栈：新进后出后进先出类似于一个桶.

队列：先进先出（FIFO）

在这里插入图片描述

为什么main先执行后结束

把mai方法丢进栈里面，然后依次进入往上压入的方法，一旦main方法结束，就相当于是整个程序结束了，栈溢出就是一些方法相互调用，然后如果特别多的话就会溢出

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

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

栈运行原理：栈帧

在这里插入图片描述

程序正在执行的方法，一定是在栈的顶部，直到栈的东西都弹出来

栈+堆+方法区的一些关系：
在这里插入图片描述

对象实例化的过程

10.三种JVM

sun公司 HotSpot

在这里插入图片描述

BEA公司的 JRockit
IBM的j9vm JIT编译器

我们学习的都是hotspot的

11.堆（重点）

Heap，一个JVM只有一个堆内存，堆内存的大小是可以调节的。类加载器读取了文件之后，一般把啥东西放入堆中？类方法常量变量，保存我们所有引用类型的真实对象

堆内存中还要分为三个内存：

新生区
养老区
永久区

在这里插入图片描述

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

假设内存满了，就是oom，堆内存不够 java.lang.OutOfMemoryError: Java heap space

在8之后，永久存储区改了个名字，叫元空间

12.新生区老年区

新生区

类：诞生和成长的地方，甚至是死亡
伊甸园区：所有的对象都时在伊甸园区中创建的
幸存者（0,1）

在这里插入图片描述

真理：经过研究，99%的对象都是临时对象，进入养老区的并不是很多

13.永久区

这个区域是常驻内存的，用来存放jdk自身携带的class对象。interface元数据，存储的是java运行时的一些环境或者是类信息，这个区域不存在垃圾回收，在关闭虚拟机的时候回释放这个区域的内存

一个启动类，加载了大量的第三方jar包一个tomcat部署了太多的应用或者是大量动态生成的反射类，如果这些类进行不断的加载，就可能放不下，知道内存满，就会出现OOM

jdk1.6之前：永久代常量池是在方法区
jdk1.7 ：永久代但是慢慢退化了去永久代这个时候常量池是在堆中
jdk1.8之后：无永久代，变成了元空间常量池在元空间

现在的模型：

在这里插入图片描述

14.堆内存调优

在这里插入图片描述

maxMemory:981.5
totalMemory:981.5
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 3243K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 351K, capacity 388K, committed 512K, reserved 1048576K

Process finished with exit code 0

#  Metaspace 元空间  构思里面存在，但是在物理区域的时候没有这个
#  PSYoungGen  +  ParOldGen = 1005056k  =  981.5   =  totalMemory
# -Xms1024m -Xmx1024m -XX:+PrintGCDetails
# 把堆内存的空间调打，如果还不行，可能是代码有问题（专业工具）

[GC (Allocation Failure) [PSYoungGen: 1536K->504K(2048K)] 1536K->687K(7680K), 0.0026000 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 1980K->503K(2048K)] 2164K->867K(7680K), 0.0014383 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1762K->408K(2048K)] 2126K->1219K(7680K), 0.0012731 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1779K->424K(2048K)] 2591K->2130K(7680K), 0.0012355 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Ergonomics) [PSYoungGen: 1341K->0K(2048K)] [ParOldGen: 5287K->1527K(5632K)] 6629K->1527K(7680K), [Metaspace: 3231K->3231K(1056768K)], 0.0052460 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 951K->0K(2048K)] 4268K->3317K(7680K), 0.0006889 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] 3317K->3317K(7680K), 0.0003715 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] [ParOldGen: 3317K->3316K(5632K)] 3317K->3316K(7680K), [Metaspace: 3231K->3231K(1056768K)], 0.0057998 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] 3316K->3316K(7680K), 0.0002574 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] [ParOldGen: 3316K->3296K(5632K)] 3316K->3296K(7680K), [Metaspace: 3231K->3231K(1056768K)], 0.0070062 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
Heap
 PSYoungGen      total 2048K, used 42K [0x00000000ffd80000, 0x0000000100000000, 0x0000000100000000)
  eden space 1536K, 2% used [0x00000000ffd80000,0x00000000ffd8abc8,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 5632K, used 3296K [0x00000000ff800000, 0x00000000ffd80000, 0x00000000ffd80000)
  object space 5632K, 58% used [0x00000000ff800000,0x00000000ffb38338,0x00000000ffd80000)
 Metaspace       used 3263K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 353K, capacity 388K, committed 512K, reserved 1048576K
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Arrays.java:3332)
	at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
	at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:674)
	at java.lang.StringBuilder.append(StringBuilder.java:208)
	at Native.Demo01.main(Demo01.java:12)

Process finished with exit code 1

# 当GC清理不了的时候才会进行报错 ， 是oom的错误

在一个线程中突然出现了一个oom故障，该如何排除，研究为什么出错？

能够看到代码的第几行出错？：内存快照分析工具 MAT（eclipse），Jprofile（IDEA的）
Debug一行一行分析代码

MAT（eclipse），Jprofile（IDEA的）作用：

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

在这里插入图片描述

# -Xmx1m  最小的内存  1/64
# -Xmx8m  最大的内存  1/4
# -XX:+HeapDumpOnOutOfMemoeyError  打印OOM的信息  
# -XX:+PrintGCDetails  打印GC来及回收信息
-Xmx1m -Xmx8m -XX:+HeapDumpOnOutOfMemoeyError
#  要找其他的错误，只需要把后面的改了就行了

这种方式不知道第几行出问题了

在这里插入图片描述

15.GC垃圾回收

在这里插入图片描述

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

新生代
幸存区（form to ）
老年区

GC两种类型：

轻GC 普通的GC 只针对新生代，偶尔去轻幸存区
重GC 全局的GC 老年区

在这里插入图片描述
JVM的内存模行和分区：详细到每个区放什么

堆里面的分区有哪些： eden from to old 说说他们的特点

GC的算法有哪些： 1. 标记清除法 2. 标记整理（标记压缩） 3. 复制算法 4. 引用计数法

普通GC和重GC分别在什么时候发生

引用计数法：

在这里插入图片描述

复制算法：

在这里插入图片描述

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

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

标记清除算法：

在这里插入图片描述

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

标记压缩：

是对于标记清除的再优化

在这里插入图片描述

总结：

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

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

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

思考：难道没有最优的算法吗？没有最优的算法来进行调优，只有最合适的 GC：分代收集算法

年轻代：

存活率低
复制算法

老年代：

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

一天学JVM，不现实，要深究，必须花时间学习，多看面试题

16.JMM java memory model

什么是JMM

【JMM】（Java Memory Model的缩写）允许编译器和缓存以数据在处理器特定的缓存（或寄存器）和主存之间移动的次序拥有重要的特权，除非程序员使用了volatile或synchronized明确请求了某些可见性的保证。
他是干啥的

官方博客对应的视频

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

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

解决共享对象可见性这个问题，我们可以使用java volatile关键字或者是加锁

他如何学习

JMM是一个抽象的概念

volatile

lock（锁定）：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。

unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。

load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。

use（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。

assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。

store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用。

write（写入）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。