初识JVM

最新推荐文章于 2022-06-08 14:20:28 发布

乔治大将军

最新推荐文章于 2022-06-08 14:20:28 发布

阅读量170

点赞数

文章标签： java jvm

本文链接：https://blog.csdn.net/asdshanjie/article/details/106749079

版权

题外

本文主要摘自：
1.周志明老师的《深入理解Java虚拟机：JVM高级特性与最佳实践（第3版）》（有需要的可以评论一下哈）
2.参考博客：参考博客
站在巨人的肩膀！将知识点稍微总结一下，方便自己复习

JVM的位置

运行在操作系统之上

JVM

类加载器

作用：加载class文件;一共有三个
AppClassLoader(系统类加载器)->ExtClassLoader(标准扩展类加载器)->BootstrapClassLoader(启动类加载器)
Bootstrap ClassLoader(启动类加载器):负责将%JAVA_HOME%/lib目录中或-Xbootclasspath中参数指定的路径中的，并且是虚拟机识别的（按名称）类库加载到JVM中
Extension ClassLoader（扩展类加载器): 负责加载%JAVA_HOME%/lib/ext中的所有类库
Application ClassLoader（应用程序加载器):负责ClassPath中的类库

public class Car {
    public static void main(String[] args) {
        Car car = new Car();
        Class<? extends Car> aClass = car.getClass();
        //AppClassLoader 
        System.out.println(aClass.getClassLoader());
        //ExtClassLoader 
        System.out.println(aClass.getClassLoader().getParent());
        //null bootstrap
        System.out.println(aClass.getClassLoader().getParent().getParent());
    }
}

jvm如何认定两个对象同属于一个类型

1.都是用同名的类完成实例化的。
2.两个实例各自对应的同名的类的加载器必须是同一个。比如两个相同名字的类，一个是用系统加载器加载的，一个扩展类加载器加载的，两个类生成的对象将被jvm认定为不同类型的对象。

双亲委派

作用：

1、防止重复加载同一个.class。通过委托去向上面问一问，加载过了，就不用再加载一遍。保证数据安全。
2、保证核心.class不能被篡改。通过委托方式，不会去篡改核心.class，即使篡改也不会去加载，即使加载也不会是同一个.class对象了。不同的加载器加载同一个.class也不是同一个Class对象。这样保证了Class执行安全。

package java.lang;

/**
 * 与Java中的string 同包同名
 */
public class String {

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

    /*
     * 1.类加载器收到类加载的请求
     * 2.将这个请求向上委托给父类加载器去完成，一直先上委托，直到启动类加载器
     * 3.启动加载器检查是否能够加载到这个类，能加载就结束，使用当前的加载器，否则，抛出异常，通知子加载器进行加载
     * 4.重复步骤3
     */
    public static void main(String[] args) {
        String s = new String();
        Class<? extends String> aClass = s.getClass();
        System.out.println(aClass.getClassLoader());
        s.toString();
    }
}
错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

能不能自己写个类叫java.lang.System？

通常不可以，但可以采取另类方法达到这个需求。

解释：为了不让我们写System类，类加载采用委托机制，这样可以保证爸爸们优先，爸爸们能找到的类，儿子就没有机会加载。而System类是Bootstrap加载器加载的，就算自己重写，也总是使用Java系统提供的System，自己写的System类根本没有机会得到加载。
但是，我们可以自己定义一个类加载器来达到这个目的，为了避免双亲委托机制，这个类加载器也必须是特殊的。由于系统自带的三个类加载器都加载特定目录下的类，如果我们自己的类加载器加载一个特殊的目录，那么系统的加载器就无法加载，也就是最终还是由我们自己的加载器加载。

沙箱安全机制

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

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

native

凡是带了native关键字的，说明Java的范围达不到，会去调用底层的c语言的库；

会进入本地方法栈，本地方法栈用来标记native方法，然后调用本地方法接口：JNI

JNI：扩展Java的使用，融合不同的编程语言

程序计数器(私有)

也叫PC寄存器，每个线程都有一个程序计数器，是线程私有的，它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

Java虚拟机的多线程是通过线程轮流切换、分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）都只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程
之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。

如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；

如果正在执行的是native方法，这个计数器值则为空。 undefined

此内存区域是唯一一个在java虚拟规范中没有规定任何OutOfMemoryError情况的区域

本地方法栈(私有)

和java虚拟机栈的作用类似。区别是该区域为JVM提供使用Native方法的服务。

本地方法栈（Native Method Stacks）与虚拟机栈所发挥的作用是非常相似的，其区别只是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的本地（Native）方法服务

方法区(共享)

方法区是 Java 虚拟机规范中的定义，是一种规范，而永久代是一种实现，一个是标准一个是实现

静态变量(static)，常量(final)，类信息，运行时的常量池存在方法区中，但是实例变量存在堆中；

1.7以前：方法区；运行时常量池逻辑包含字符串常量池存放在方法区, 此时hotspot虚拟机对方法区的实现为永久代；

1.7：字符串常量池被从方法区拿到了堆中；这里没有提到运行时常量池,也就是说字符串常量池被单独拿到堆,运行时常量池剩下的东西还在方法区, 也就是hotspot中的永久代 。

1.8：元空间；属于***直接内存***方法区无法满足内存分配需求时，抛出OOM

Java中的常量池，实际上分为两种形态：静态常量池和运行时常量池。

运行常量池

是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。

1.类型信息：类型标志(该类是类类型还是接口类型); 类的访问描述符(public)

2.类型的常量池: 存放该类型所用到的常量的有序集合，包括直接常量（如字符串、整数、浮点数的常量）和对其他类型、字段、方法的符号引用;

3.字段信息:字段修饰符(public)、字段的类型、字段名称

4.方法信息

…

静态常量池

即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，只是一个class的描述信息而已，还没有具备被执行的能力

Java虚拟机栈(私有)

先进后出：FILO；8大基本数据类型、对象引用、方法出口、局部变量

主要负责程序的运行、生命周期、线程同步；线程结束，栈就释放，不存在垃圾回收，

每个方法从调用直到执行完毕的过程，对应一个栈帧在虚拟机栈的入栈与出栈过程

与程序计数器一样， Java虚拟机栈（Java Virtual Machine Stack）也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的线程内存模型：每个方法被执行的时候， Java虚拟机都会同步创建一个栈帧[1]（Stack Frame）用于存储局部变量表、操作数栈、动态连接、方法出口等信息。每一个方法被调用直至执行完毕的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

局部变量表存放了编译期可知的各种Java虚拟机基本数据类型（boolean、 byte、 char、 short、 int、float、 long、 double）、对象引用（reference类型，它并不等同于对象本身，可能是一个指向对象起始
地址的引用指针，也可能是指向一个代表对象的句柄或者其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。

此区域会产生两种异常：
1）若线程请求的栈深度大于JVM允许的深度（-Xss设置栈容量），抛出StackOverFlowError异常（单线程）
2）虚拟机在进行栈的动态扩展时，若无法申请到足够内存，抛出OOM（OutOfMemoryError）异常（多线程）

堆(共享)

所有线程共享的一块区域，垃圾回收器管理的主要区域；是虚拟机所管理的内存中最大的一块，几乎所有的对象实例以及数组都应当在堆上分配

目前主要垃圾回收算法都是分代收集算法，所以java堆中还可以细分为：新生代和老年代，再细致一点的还有eden区，from survivor、to survivor，默认情况下是8：1：1的比例。

根据java虚拟机规范的规定，java堆可以处于物理上不连续的内存空间中，只要逻辑上是连续的即可，就像我们的磁盘一样。

直接内存

直接内存是除 Java 虚拟机之外的内存，但也可能被 Java 使用。直接内存的大小不受 Java 虚拟机控制，但既然是内存，当内存不足时就会抛出 OutOfMemoryError 异常。

直接内存与堆内存比较

直接内存申请空间耗费更高的性能
直接内存读取 IO 的性能要优于普通的堆内存。
直接内存作用链：本地 IO -> 直接内存 -> 本地 IO
堆内存作用链：本地 IO -> 直接内存 -> 非直接内存 -> 直接内存 -> 本地 IO

三种JVM

sun公司：hotspot

bea公司：jrockit

IBM公司：J9VM

-Xms 设置初始化内存分配大小 1/64

-Xmx 设置最大分配内存 1/4

-XX:+PrintGCDetails 打印GC垃圾回收信息

-XX:+HeapDumpOnOutOfMemoryError 发生内存溢出时生成dump文件

判断对象是否死亡

1.引用计数法

Java中并没有使用这种，因为单纯的引用计数就很难解决对象之间相互循环引用的问题。

在对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加一；当引用失效时，计数器值就减一；任何时刻计数器为零的对象就是不可能再被使用的。

public class ReferenceCountingGC {
    public Object instance = null;
    private static final int _1MB = 1024 * 1024;
    /**
    * 这个成员属性的唯一意义就是占点内存， 以便能在GC日志中看清楚是否有回收过
    */
    private byte[] bigSize = new byte[2 * _1MB];
    public static void testGC() {
    ReferenceCountingGC objA = new ReferenceCountingGC();
    ReferenceCountingGC objB = new ReferenceCountingGC();
    objA.instance = objB;
    objB.instance = objA;
    objA = null;
    objB = null;
    // 假设在这行发生GC， objA和objB是否能被回收？
    System.gc();
    }
}

2.可达性分析算法

**通过一系列称为“GC Roots”的根对象作为起始节点集，从这些节点开始，根据引用关系向下搜索，搜索过程所走过的路径称为“引用链”（Reference Chain），如果某个对象到GC Roots间没有任何引用链相连；则证明此对象是不可能再被使用的。 **

即使在可达性分析算法中不可达的对象，也并非是“非死不可”，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历两次标记过程。

1.如果对象在进行可达性分析后发现没有与GC Roots相连接的引用链，那它将会被第一次标记

2.第一次标记后接着会进行一次筛选，筛选的条件是此对象是否有必要执行finalize()方法，在finalize()方法中没有重新与引用链建立关联关系的，将被进行第二次标记

第二次标记成功的对象，如果在finalize()方法中重新与引用链建立了关联关系，那么将会逃离本次回收，继续存活

方法区判断是否需要回收

方法区主要回收的内容有：废弃常量和无用的类；

废弃常量：可通过引用的可达性来判断；

无用的类：

1.该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例；

2.加载该类的ClassLoader已经被回收；

3.该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

GC：垃圾回收算法

复制算法

最佳使用场景：对象的存活度较低时

优点：没有内存碎片坏处：浪费内存空间

将内存分为两块大小一样的区域，每次是使用其中的一块。当这块内存块用完了，就将这块内存中还存活的对象复制到另一块内存中，然后清空这块内存。这种算法在对象存活率较低的场景下效率很高，比如说新生代，**只对整块内存区域的一半进行垃圾回收，在垃圾回收的过程也不会出现内存碎片的情况，不需要移动对象，只需要移动指针即可；**运行效率高，但每次只能使用一半，用空间换时间！

标记清除算法

首先标记出所有需要回收的对象，在标记完成后，统一回收掉所有被标记的对象，也可以反过来，标记存活的对象，统一回收所有未被标记的对象。

在存活对象比较多的情况下极为高效，但由于标记-清除算法直接回收不存活的对象，因此会造成内存碎片。

优点：不需要额外的空间

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

标记整理

**防止内存碎片的产生，**再次扫描，向一段移动存活的对象，多了移动的成本；

移动存活对象，尤其是在老年代这种每次回收都有大量对象存活区域，移动存活对象并更新所有引用这些对象的地方将会是一种极为负重的操作，而且这种对象移动操作必须全程暂停用户应用程序才能进行

其中的标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向内存空间一端移动，然后直接清理掉边界以外的内存

分代收集算法

根据对象存活的生命周期将内存划分为若干个不同的区域；老年代的特点是每次垃圾收集时只有少量对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的对象需要被回收。

年轻代回收算法

1.所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象；

2.新生代内存按照8:1:1的比例分为一个eden区和两个survivor(survivor0,survivor1)区。大部分对象在Eden区中生成。回收时先将eden区存活对象复制到一个survivor0区，然后清空eden区，当这个survivor0区也存放满了时，则将eden区和survivor0区存活对象复制到另一个survivor1区，然后清空eden和这个survivor0区，此时survivor0区是空的，然后将survivor0区和survivor1区交换，即保持survivor1区为空，如此往复

3.当survivor1区不足以存放 eden和survivor0的存活对象时，就将存活对象直接存放到老年代。若是老年代也满了就会触发一次Full GC，也就是新生代、老年代都进行回收。

4.新生代发生的GC也叫做Minor GC，MinorGC发生频率比较高(不一定等Eden区满了才触发)。

老年代回收算法

1.在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象

2.当老年代内存满时触发Major GC即Full GC，Full GC发生频率比较低，老年代对象存活时间比较长，存活率标记高。

总结

内存效率：复制算法>标记清除算法>标记压缩算法

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

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

JMM

1.Java Memory Modle:Java内存模型
更多细节大家百度一下哦

常见的垃圾收集器

Serial收集器（复制算法)
新生代单线程收集器，标记和清理都是单线程，优点是简单高效。是client级别默认的GC方式，可以通过-XX:+UseSerialGC来强制指定。
Serial Old收集器(标记-整理算法)
老年代单线程收集器，Serial收集器的老年代版本。
ParNew收集器(停止-复制算法)　
新生代收集器，可以认为是Serial收集器的多线程版本,在多核CPU环境下有着比Serial更好的表现。
Parallel Scavenge收集器(停止-复制算法)
并行收集器，追求高吞吐量，高效利用CPU。吞吐量一般为99%，吞吐量= 用户线程时间/(用户线程时间+GC线程时间)。适合后台应用等对交互相应要求不高的场景。是server级别默认采用的GC方式，可用-XX:+UseParallelGC来强制指定，用-XX:ParallelGCThreads=4来指定线程数。
Parallel Old收集器(停止-复制算法)
Parallel Scavenge收集器的老年代版本，并行收集器，吞吐量优先。
CMS(Concurrent Mark Sweep)收集器（标记-清理算法）
高并发、低停顿，追求最短GC回收停顿时间，cpu占用比较高，响应时间快，停顿时间短，多核cpu 追求高响应时间的选择。

GC是什么时候触发的

Scavenge GC(轻gc)

当新对象生成，并且在Eden申请空间失败时，就会触发Scavenge GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。这种方式的GC是对年轻代的Eden区进行，不会影响到年老代。因为大部分对象都是从Eden区开始的，同时Eden区不会分配的很大，所以Eden区的GC会频繁进行。因而，一般在这里需要使用速度快、效率高的算法，使Eden去能尽快空闲出来

Full GC(重gc)

对整个堆进行整理，包括Young、Tenured和Perm。Full GC因为需要对整个堆进行回收，所以比Scavenge GC要慢，因此应该尽可能减少Full GC的次数.

a) 年老代（Tenured）被写满；

b) 持久代（Perm）被写满；

c) System.gc()被显示调用；

d) 上一次GC之后Heap的各域分配策略动态变化；

乔治大将军

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
初识JVM

题外本文主要摘自：1.周志明老师的《深入理解Java虚拟机：JVM高级特性与最佳实践（第3版）》（有需要的可以评论一下哈）2.参考博客：参考博客站在巨人的肩膀！将知识点稍微总结一下，方便自己复习JVM的位置运行在操作系统之上类加载器作用：加载class文件;一共有三个AppClassLoader(系统类加载器)->ExtClassLoader(标准扩展类加载器)->BootstrapClassLoader(启动类加载器)Bootstrap ClassLoader(启动类加
复制链接

扫一扫