JVM初探究总结

小霸王学习机_001

已于 2022-05-24 14:45:04 修改

阅读量297

点赞数 2

分类专栏： JVM 文章标签： java

于 2022-05-14 22:26:50 首次发布

本文链接：https://blog.csdn.net/weixin_45156514/article/details/124724817

版权

JVM 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

JVM大体位置

在这里插入图片描述

JVM的体系结构

在这里插入图片描述
百分之99的JVM调优都是在堆中调优，Java栈、本地方法栈、程序计数器是不会有垃圾存在的

类加载器

作用：加载Class文件~

在这里插入图片描述

双亲委派机制

JVM中提供了三层的ClassLoader：

Bootstrap classLoader:主要负责加载核心的类库(java.lang.*等)，构造ExtClassLoader和APPClassLoader。
ExtClassLoader：主要负责加载jre/lib/ext目录下的一些扩展的jar。
AppClassLoader：主要负责加载应用程序的主函数类

1.类加载器收到类加载的请求
2.将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类加载器（Bootstrap classLoader）
3.启动加载器检查是否能够加载当前这个类，能加载就结束，使用当前的加载器，否则，抛出异常，通知子加载器进行加载
4.重复步骤3
Class Not Found异常就是这么来的 Java早期的名字：C+±- Java = C++:去掉繁琐的东西，指针，内存管理~
在这里插入图片描述

沙箱安全机制

Java安全模型的核心就是Java沙箱(sandbox) , 什么是沙箱?沙箱是一个限制程序运行的环境。
沙箱机制就是将Java代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。
沙箱主要限制系统资源访问，那系统资源包括什么? CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。
所有的Java程序运行都可以指定沙箱，可以定制安全策略。
在Java中将执行程序分成本地代码和远程代码两种，本地代码默认视为可信任的，而远程代码则被看作是不受信的。对于授信的本地代码,可以访问一切本地资源。而对于非授信的远程代码在早期的Java实现中，安全依赖于沙箱Sandbox)机制。如下图所示JDK1.0安全模型

组成沙箱的基本组件
●字节码校验器(bytecode verifier) :确保Java类文件遵循Java语言规范。这样可以帮助Java程序实现内存保护。但并不是所有的类文件都会经过字节码校验，比如核心类。
●类裝载器(class loader) :其中类装载器在3个方面对Java沙箱起作用

它防止恶意代码去干涉善意的代码;
它守护了被信任的类库边界;
它将代码归入保护域,确定了代码可以进行哪些操作。

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

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

1.从最内层JVM自带类加载器开始加载,外层恶意同名类得不到加载从而无法使用;
2.由于严格通过包来区分了访问域,外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效。
●存取控制器(access controller) :存取控制器可以控制核心API对操作系统的存取权限，而这个控制的策略设定,可以由用户指定。
●安全管理器(security manager) : 是核心API和操作系统之间的主要接口。实现权限控制，比存取控制器优先级高。
●安全软件包(security package) : java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括:  安全提供者  消息摘要  数字签名  加密  鉴别

Native

native :凡是带了native关键字的，说明java的作用范围达不到了，回去调用底层c语言的库!
会进入本地方法栈，调用本地方法本地接口 JNI (Java Native Interface)
JNI作用:拓展Java的使用，融合不同的编程语言为Java所用！最初: C、C++
Java诞生的时候C、C++横行，想要立足，必须要有调用C、C++的程序，于是它在内存区域中专门开辟了一块标记区域: Native Method Stack，登记native方法，在最终执行的时候，去加载本地方法库中的方法通过JNI ，例如：Java程序驱动打印机，管理系统，掌握即可，在企业级应用比较少

 private native void start0(); //调用其他接口:Socket. . WebService~. .http~

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

Native Interface本地接口
本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序, Java在诞生的时候是C/C++横行的时候，想要立足，必须有调用C、C++的程序，于是就在内存中专门开辟了块区域处理标记为native的代码，它的具体做法是在Native Method Stack 中登记native方法,在( Execution Engine )执行引擎执行的时候加载Native Libraies。目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过Java程序驱动打印机或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间通信很发达，比如可以使用Socket通信,也可以使用Web Service等等，不多做介绍!

PC寄存器

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

方法区 Method Area

方法区是被所有线程共享,所有字段和方法字节码，以及一些特殊方法，如构造函数,接口代码也在此定义,简单说，所有定义的方法的信息都保存在该区域,此区域属于共享区间;
静态变量、常量、类信息(构造方法、接口定义)、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关

在这里插入图片描述

栈

栈:先进后出桶:后进先出队列:先进先出( FIFO : First Input First Output )
栈:栈内存,主管程序的运行,生命周期和线程同步; 线程结束，栈内存也就是释放,对于栈来说,不存在垃圾回收问题一旦线程结束，栈就Over!
栈内存中:8大基本类型+对象引用+实例的方法

栈运行原理:栈帧栈满了: StackOverflowError

栈底部子帧指向上一个栈的方法上一个栈的父帧指向栈底部方法
栈底部子帧指向上一个栈的方法上一个栈的父帧指向栈底部方法

在这里插入图片描述

Java对象在内存中实例化的过程：

package WeiYuanSuan;

public class People{
    String name; // 定义一个成员变量 name
    int age; // 成员变量 age
    Double height; // 成员变量 height
    
     public void print(){
        System.out.println("人的姓名："+name);
        System.out.println("人的年龄："+age);
        System.out.println("人的身高："+height);
    }

    public static void main(String[] args) {
        String name; // 定义一个局部变量 name
        int age; // 局部变量 age
        Double height; // 局部变量 height

        People people = new People() ; //实例化对象people
        people.name = "张三" ;       //赋值
        people.age = 18;             //赋值
        people.height = 180.0 ;   //赋值
        people.print();              //调用方法sing
    }
}

在这里插入图片描述

三种JVM

●Sun公司HotSpot Java Hotspot™ 64-Bit Server VM (build 25.181-b13,mixed mode)
●BEA JRockit
●IBM J9VM
我们学习都是: Hotspot

堆

Heap, 一个JVM只有一个堆内存，堆内存的大小是可以调节的。类加载器读取了类文件后，一般会把什么东西放到堆中? 类, 方法，常量,变量~，保存我们所有引用类型的真实对象; 堆内存中还要细分为三个区域: ●新生区(伊甸园区) Young/New ●养老区old ●永久区Perm
在这里插入图片描述

GC垃圾回收,主要是在伊甸园区和养老区~ 假设内存满了,OOM,堆内存不够! java.lang.OutOfMemoryError:Java heap space
永久存储区里存放的都是Java自带的例如lang包中的类如果不存在这些，Java就跑不起来了在JDK8以后，永久存储区改了个名字(元空间)
在这里插入图片描述
新生区
●类:诞生和成长的地方，甚至死亡;
●伊甸园，所有的对象都是在伊甸园区new出来的!
●幸存者区(0,1)

伊甸园满了就触发轻GC，经过轻GC存活下来的就到了幸存者区，幸存者区满之后意味着新生区也满了，则触发重GC，经过重GC之后存活下来的就到了养老区。真理:经过研究，99%的对象都是临时对象!|
在这里插入图片描述
永久区
这个区域常驻内存的。用来存放JDK自身携带的Class对象。Interface元数据，存储的是Java运行时的一些环境~ 这个区域不存在垃圾回收，关闭虚拟机就会释放内存
●jdk1.6之前:永久代,常量池是在方法区;
●jdk1.7:永久代,但是慢慢的退化了，去永久代，常量池在堆中
●jdk1.8之后:无永久代,常量池在元空间
在这里插入图片描述
元空间：逻辑上存在，物理上不存在 (因为存储在本地磁盘内) 所以最后并不算在JVM虚拟机内存中

堆内存调优

package com.linfeng.java.jvm;

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

        /*扩大堆内存
        -Xms1024m -Xmx1024m -XX:+PrintGCDetails
        */


    }
}

在这里插入图片描述

在这里插入图片描述
在这里新生区内存加老年代内存：305664k+699392k=1005056k，1005056/1024=981.5M
，正好等于初始化总内存，而元空间还有4M内存在哪里呢？正好印证了这句话元空间：逻辑上存在，物理上不存在 (因为存储在本地磁盘内) 所以最后并不算在JVM虚拟机内存中在这里插入图片描述

下面具体看一下：

package com.linfeng.java.jvm;

import java.util.Random;

public class Demo02 {


    public static void main(String[] args) {
        String str = "linfeng";
        while (true) {
            str += str +new Random().nextInt(888888888)+new Random().nextInt(999999999);
        }
    }
}

在这里插入图片描述

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

●能够看到代码第几行出错:内存快照分析工具，MAT, Jprofiler ，MAT是eclipse集成使用
●Dubug, 一行行分析代码!

MAT, Jprofiler作用：
●分析Dump内存文件,快速定位内存泄露;
●获得堆中的数据
●获得大的对象~

Jprofile使用

1.在idea中下载jprofile插件
在这里插入图片描述

2.联网下载jprofile客户端
官网下载客户端地址：https://www.ej-technologies.com/download/jprofiler/version_92

激活码：https://blog.csdn.net/chuhui1765/article/details/100670291

3.IDEA运行环境配置
在这里插入图片描述

3.在idea中VM参数中写参数 -Xms1m -Xmx8m -XX: +HeapDumpOnOutOfMemoryError

4.运行程序后在jprofile客户端中打开找到错误告诉哪个位置报错

命令参数详解

-Xms设置初始化内存分配大小 1/64
-Xmx设置最大分配内存，默以1/4
-XX: +PrintGCDetails 打印GC垃圾回收信息
-XX: +HeapDumpOnOutOfMemoryError //oom DUMP

示例：

package com.linfeng.java.jvm;

import java.util.ArrayList;

public class Demo03 {
    byte[] array = new byte[1*1024*1024];

    public static void main(String[] args) {
        ArrayList<Demo03> list = new ArrayList<>();
        int count = 0;
        while (true){
            list.add(new Demo03());
            count=count+1;
        }
    }
}

在这里插入图片描述
下面写入参数： -Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

重新运行后

找到这个文件

打开文件夹之后，往目录上一级找，

双击打开

下面来看哪一行出现问题

GC

在这里插入图片描述
JVM在进行GC时，并不是对这三个区域统一回收。大部分时候，回收都是新生代~
●新生代 ●幸存区(form，to) ●老年区
GC两种类:轻GC (普通的GC)，重GC (全局GC)

GC常见面试题目:
1、JVM的内存模型和分区~详细到每个区放什么?
-JVM 分为堆区和栈区，还有方法区，初始化的对象放在堆里面，引用放在栈里面，class 类信息常量池（static 常量和 static 变量）等放在方法区
new:

方法区：主要是存储类信息，常量池（static 常量和 static 变量），编译后的代码（字节码）等数据
堆：初始化的对象，成员变量（那种非 static 的变量），所有的对象实例和数组都要在堆上分配
栈：栈的结构是栈帧组成的，调用一个方法就压入一帧，帧上面存储局部变量表，操作数栈，方法出口等信息，局部变量表存放的是 8 大基础类型加上一个应用类型，所以还是一个指向地址的指针
本地方法栈：主要为 Native 方法服务
程序计数器：记录当前线程执行的行号

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

Eden区
Eden区位于Java堆的年轻代，是新对象分配内存的地方，由于堆是所有线程共享的，因此在堆上分配内存需要加锁。而Sun JDK为提升效率，会为每个新建的线程在Eden上分配一块独立的空间由该线程独享，这块空间称为TLAB（Thread Local Allocation Buffer）。在TLAB上分配内存不需要加锁，因此JVM在给线程中的对象分配内存时会尽量在TLAB上分配。如果对象过大或TLAB用完，则仍然在堆上进行分配。如果Eden区内存也用完了，则会进行一次Minor GC（young GC）。
Survival from to
Survival区与Eden区相同都在Java堆的年轻代。Survival区有两块，一块称为from区，另一块为to区，这两个区是相对的，在发生一次Minor GC后，from区就会和to区互换。在发生Minor GC时，Eden区和Survivalfrom区会把一些仍然存活的对象复制进Survival to区，并清除内存。Survival to区会把一些存活得足够旧的对象移至年老代。
年老代
年老代里存放的都是存活时间较久的，大小较大的对象，因此年老代使用标记整理算法。当年老代容量满的时候，会触发一次Major GC（full GC），回收年老代和年轻代中不再被使用的对象资源。

3、GC的算法有哪些? 标记清除法，标记整理,复制算法，引用计数器

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

轻GC：此时如果新生的对象无法在 Eden 区创建（Eden 区无法容纳) 就会触发一次Young GC 此时会将 S0 区与Eden 区的对象一起进行可达性分析，找出活跃的对象，将它复制到 S1 区并且将S0区域和 Eden 区的对象给清空，这样那些不可达的对象进行清除，并且将S0 区和 S1区交换。
重GC
1、对于一个大对象，我们会首先在Eden 尝试创建，如果创建不了，就会触发Minor GC
2、随后继续尝试在Eden区存放，发现仍然放不下
3、尝试直接进入老年代，老年代也放不下
4、触发 Major GC 清理老年代的空间
5、放的下成功
6、放不下 OOM

引用计数器

在这里插入图片描述

复制算法

在这里插入图片描述
复制算法大致图

复制算法图解

好处:没有内存的碎片~
坏处:浪费了内存空间~ :多了一半空间永远是空to。假设对象100%存活(极端情况)
复制算法最佳使用场景:对象存活度较低的时候;新生区~

标记清除法

在这里插入图片描述
●优点:不需要额外的空间!
●缺点:两次扫描,严重浪费时间，会产生内存碎片。

标记压缩

再优化：
在这里插入图片描述
**内存效率:**复制算法>标记清除算法>标记压缩算法(时间复杂度)
**内存整齐度:**复制算法=标记压缩算法>标记清除算法
**内存利用率:**标记压缩算法=标记清除算法>复制算法

思考一个问题:难道没有最优算法吗?
答案:没有，没有最好的算法，只有最合适的算法— GC :分代收集算法

年轻代:
●存活率低
●复制算法!
老年代:
●区域大:存活率
●标记清除+标记压缩混合实现

JMM：java Memory Model

作用:缓存一致性协议，用于定义数据读写的规则(遵守,找到这个规则) .
JMM定义了线程工作内存和主内存之间的抽象关系:线程之间的共享变量存储在主内存(Main Memory)中,每个线程都有一个私有的本地内存(Local Memory)
在这里插入图片描述
解决共享对象可见性这个问题: volilate

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