精华内容
下载资源
问答
  • jvm运行原理及类加载器

    热门讨论 2021-04-27 23:05:06
    jvm运行原理及类加载器

    JVM运行原理

    首先从“.java”代码文件,编译成“.class”字节码文件,然后类加载器将“.class”字节码文件中的类给加载带JVM中,最后就是JVM执行写好的代码。执行过程如下图

    在这里插入图片描述

    类加载器

    类加载过程

    加载 -> 验证 -> 准备 -> 解析 -> 初始化 -> 使用 -> 卸载
    在这里插入图片描述

    加载

    一旦JVM进程启动之后,一定会先把类加载到内存中,然后从main()方法的入口代码开始执行

    public class HelloWorld {
        public static void main(String[] args) {
            
        }
    }
    
    • 加载指是将类CLass文件读入到内存中,并创建一个java.lang.Class对象
    • 类的加载器由类加载器完成,类加载器通常由JVM提供,除此之外,可以通过继承ClassLoader基类来创建自己的类加载器
    • 通过使用不同的类加载器,可以从不同来源加载类的二进制数据
      • 从本地文件系统加载class文件
      • 从JAR包加载class文件,JDBC编程时用到的数据库驱动类就放在JAR文件中,JVM可以从JAR文件中直接加载该class文件
      • 通过网络加载class文件
      • 把一个java源文件动态编译,并执行加载

    准备阶段

    验证

    根据Java虚拟机规范,来校验加载进来的“.class”文件中的内容,是否符合指定的规范,如果“.class”文件被人篡改,里面的字节码不符合规范,那么JVM是没法执行这个字节码。所在把“.class”文件加载到内存后,必须先验证一下,检验他必须完全符合JVM规范,才交给JVM来运行。其主要包括四种验证,文件格式验证,元数据验证,字节码验证,符号引用验证

    • 文件格式验证:主要验证字节流是否符合Class文件格式规范,并且能被当前的虚拟机加载处理。例如:主,次版本号是否在当前虚拟机处理的范围之内。常量池中是否有不被支持的常量类型。指向常量的中的索引值是否存在不存在的常量或不符合类型的常量

    • 元数据验证:对字节码描述的信息进行语义的分析,分析是否符合java的语言语法的规范

    • 字节码验证:最重要的验证环节,分析数据流和控制,确定语义是合法的,符合逻辑的。主要的针对元数据验证后对方法体的验证。保证类方法在运行时不会有危害出现

    • 符号引用验证:主要是针对符号引用转换为直接引用的时候,是会延伸到第三解析阶段,主要去确定访问类型等涉及到引用的情况,主要是要保证引用一定会被访问到,不会出现类等无法访问的问题

    准备

    给引用的类分配一定的内存空间,然后给里面的类变量(也就是static修饰的变量)分配内存空间,来一个默认的初始值

    解析

    实际上是把将类的二进制数据中的符号引用替换成直接引用的过程,这个部分的内容比较复杂,设计到JVM的底层

    • 符号引用:符号引用是以一组符号来描述所引用的目标,符号可以是任何的字面形式的字面量,只要不会出现冲突能够定位到就行。布局和内存无关
    • 直接引用:是指向目标的指针,偏移量或者能够直接定位的句柄。该引用是和内存中的布局有关的,并且一定加载进来的

    解析主要包括:

    • 类或接口的解析
    • 字段解析
    • 类方法解析
    • 接口方法解析

    初始化

    ​ 初始化是为类的静态变量赋予正确的初始值,准备阶段和初始化阶段看似有点矛盾,其实是不矛盾的,如果类中有语句:private static int a = 10,它的执行过程是这样的,首先字节码文件被加载到内存后,先进行链接的验证这一步骤,验证通过后准备阶段,给a分配内存,因为变量a是static的,所以此时a等于int类型的默认初始值0,即a=0,然后到解析(后面在说),到初始化这一步骤时,才把a的真正的值10赋给a,此时a=10

    一个非常重要的规则,就是如果初始化一个类的时候,发现他的父类还没初始化,那么必须先初始化他的父类

    加载器

    启动类/根类加载器

    Bootstrap ClassLoader,他主要是负责加载我们在机器上安装的Java目录下的核心类的,是用原生代码来实现的,并不继承自 java.lang.ClassLoader(负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class,由C++实现,不是ClassLoader子类)。由于引导类加载器涉及到虚拟机本地实现细节,开发者无法直接获取到启动类加载器的引用,所以不允许直接通过引用进行操作

    扩展类加载器

    Extension ClassLoader,负责加载JRE的扩展目录,lib/ext或者由java.ext.dirs系统属性指定的目录中的JAR包的类。由Java语言实现,父类加载器为null

    应用程序类加载器

    Application ClassLoader,被称为应用(也称为系统)类加载器,它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性,或者CLASSPATH换将变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器。如果没有特别指定,则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现,父类加载器为ExtClassLoader。

    类加载器加载Class大致要经过如下8个步骤:

    • 检测此Class是否载入过,即在缓冲区中是否有此Class,如果有直接进入第8步,否则进入第2步

    • 如果没有父类加载器,则要么Parent是根类加载器,要么本身就是根类加载器,则跳到第4步,如果父类加载器存在,则进入第3步

    • 请求使用父类加载器去载入目标类,如果载入成功则跳至第8步,否则接着执行第5步

    • 请求使用根类加载器去载入目标类,如果载入成功则跳至第8步,否则跳至第7步

    • 当前类加载器尝试寻找Class文件,如果找到则执行第6步,如果找不到则执行第7步

    • 从文件中载入Class,成功后跳至第8步

    • 抛出ClassNotFountException异常

    • 返回对应的java.lang.Class对象

    自定义类加载器

    除了上面那几种之外,还可以自定义类加载器,去根据你自己的需求加载你的类

    类加载机制

    JVM的类加载机制主要有如下3种:

    • 全盘负责:所谓全盘负责,就是当一个类加载器负责加载某个Class时,该Class所依赖和引用其他Class也将由该类加载器负责载入,除非显示使用另外一个类加载器来载入
    • 双亲委派:所谓的双亲委派,则是先让父类加载器试图加载该Class,只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。通俗的讲,就是某个特定的类加载器在接到加载类的请求时,首先将加载任务委托给父加载器,依次递归,如果父加载器可以完成类加载任务,就成功返回;只有父加载器无法完成此加载任务时,才自己去加载
    • 缓存机制。缓存机制将会保证所有加载过的Class都会被缓存,当程序中需要使用某个Class时,类加载器先从缓存区中搜寻该Class,只有当缓存区中不存在该Class对象时,系统才会读取该类对应的二进制数据,并将其转换成Class对象,存入缓冲区中。这就是为很么修改了Class后,必须重新启动JVM,程序所做的修改才会生效的原因

    双亲委派机制

    在这里插入图片描述

    这就是所谓的**双亲委派模型:**先找父亲去加载,不行的话再由儿子来加载

    • 双亲委派机制,其工作原理的是,如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行,如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器,如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式,即每个儿子都很懒,每次有活就丢给父亲去干,直到父亲说这件事我也干不了时,儿子自己才想办法去完成

    • 双亲委派机制的优势:采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系,通过这种层级关可以避免类的重复加载,当父亲已经加载了该类时,就没有必要子ClassLoader再加载一次。其次是考虑到安全因素,java核心api中定义类型不会被随意替换,假设通过网络传递一个名为java.lang.Integer的类,通过双亲委托模式传递到启动类加载器,而启动类加载器在核心Java API发现这个名字的类,发现该类已被加载,并不会重新加载网络传递的过来的java.lang.Integer,而直接返回已加载过的Integer.class,这样便可以防止核心API库被随意篡改

    展开全文
  • JVM运行原理

    2021-10-21 12:28:39
    JVM运行原理:编写一个.java文件,然后通过javac命令将.java文件转换成字节码文件,字节码文件需要java类库的支持,然后通过字节码解释器和JIT及时编辑器共同执行引擎,然后输出在OS硬件上。 ...

     JVM运行原理:编写一个.java文件,然后通过javac命令将.java文件转换成字节码文件,字节码文件需要java类库的支持,然后通过字节码解释器和JIT及时编辑器共同执行引擎,然后输出在OS硬件上。

    展开全文
  • JVM运行原理及调优

    2021-08-07 13:48:18
    JVM运行在操作系统之上。 2、JVM运行流程 线程私有:jvm虚拟机栈,本地方法栈,程序计数器 线程共享:堆和方法区 编写好java源文件 通过编译器编译为class文件 经过类加载器初始化 进入JVM运行数据区 线程私有:...

    1、什么是JVM

    JVM是Java Virtual Machine(Java虚拟机)的缩写,是一个虚构的计算机,这个计算机用来运行我们的Java程序。
    JVM运行在操作系统之上。
    在这里插入图片描述

    2、JVM运行流程

    线程私有:jvm虚拟机栈,本地方法栈,程序计数器
    线程共享:堆和方法区

    1. 编写好java源文件
    2. 通过编译器编译为class文件
    3. 经过类加载器初始化
    4. 进入JVM运行数据区

    在这里插入图片描述
    线程私有:jvm虚拟机栈,本地方法栈,程序计数器
    线程共享:堆和方法区

    2.1 java栈

    1. 基础数据类型
    2. 方法的形式参数,局部变量,方法调用完后从栈空间回收
    3. 引用对象的地址,引用完后,栈空间地址立即被回收,堆空间等待GC

    2.2 方法区

    1. 字符串常量
    2. 常量
    3. static
    4. 所有的class

    2.3 堆

    1. new出来的对象(实例)
    2. 数组

    2.4 堆栈方法区关系

    在这里插入图片描述

    3、类加载器与双亲委派机制

    Java 虚拟机自带的加载器包括以下几种:

    • 启动类加载器:BootstrapClassLoader 加载rt.jar
    • 平台类加载器(PlatformClassLoader) JDK8:扩展类加载器(ExtensionClassLoader)加载ext下的扩展jar
    • 应用程序类加载器(AppClassLoader)加载自定义的类
    • 用户自定义的加载器:是 java.lang.ClassLoader 的子类,用户可以定制类的加载方式;只不过自定义类加载器其加载的顺序是在所有系统类加载器的最后
    public class Test01 {
        public static void main(String [] args) {
            Test01 test01 = new Test01();
            ClassLoader loader = test01.getClass().getClassLoader();
            System.out.println("自定义的对象类加载器:"+loader);  // AppClassLoader
            System.out.println("自定义的对象类加载器的父加载器:"+loader.getParent()); // ExtClassLoader
            System.out.println("自定义的对象类加载器的祖父加载器:"+loader.getParent().getParent()); // null
        }
    }
    

    双亲委派机制就是在类加载的时候会一直往上找对应的类加载器去加载这个类。
    如果找到了,停止,如果没有找到就抛出异常给下一级类加载器加载。
    在这里插入图片描述
    双亲委派机制的优点是保证了安全性,意思也就是说防止有与Java核心类同名的方法。

    我们自定义的User类,首先会由BootstrapClassLoader加载,然后被ExtensionClassLoader加载,加载不到,最终会被AppClassLoader加载。

    而如果我们自定义了一个String类,按照上面的流程,它最终会被BootstrapClassLoader加载到,然后就不往下了,也就是说我们自定义的String根本加载不到!

    这也就保证了我们的Java核心不会被篡改。

    4、堆分区

    public class Test04 {
    
        public static void main(String[] args) {
    
            // 能够从操作系统挖到得最大内存
            long max = Runtime.getRuntime().maxMemory();
    
            // 当前得总内存
            long total = Runtime.getRuntime().totalMemory();
    
            // 从操作系统挖过来的内存没有用到的部分
            long free = Runtime.getRuntime().freeMemory();
    
            System.out.println("能够从操作系统挖到得最大内存:"+max +"\t"+max / 1024/1024 +"M");
            System.out.println("当前得总内存:"+total+"\t"+total / 1024/1024 +"M");
            System.out.println("空闲内存:"+free+"\t"+free / 1024/1024 +"M");
    
            /*
                默认
                能够从操作系统挖到得最大内存:1648361472	1572M
                当前得总内存:112721920	107M
                空闲内存:110365728	105M
    
                调整后:-Xms1024m -Xmx1024m
                (-Xms设置当前的总内存,-Xmx准要从操作系统挖多少内存)
                能够从操作系统挖到得最大内存:1029177344	981M
                当前得总内存:1029177344	981M
                空闲内存:1018439896	971M
    
                -XX:+PrintGCDetails查看详细堆内存参数
    
                Heap(堆)
                 (新生区)PSYoungGen      total 149504K, used 7711K [0x00000000eab00000, 0x00000000f5180000, 0x0000000100000000)
                    (伊甸园区)eden space 128512K, 6% used [0x00000000eab00000,0x00000000eb287c70,0x00000000f2880000)
                    (幸存1区)from space 20992K, 0% used [0x00000000f3d00000,0x00000000f3d00000,0x00000000f5180000)
                    (幸存2区)to   space 20992K, 0% used [0x00000000f2880000,0x00000000f2880000,0x00000000f3d00000)
                 (养老区)ParOldGen       total 341504K, used 0K [0x00000000c0000000, 0x00000000d4d80000, 0x00000000eab00000)
                  object space 341504K, 0% used [0x00000000c0000000,0x00000000c0000000,0x00000000d4d80000)
                 (元空间)Metaspace       used 3195K, capacity 4496K, committed 4864K, reserved 1056768K
                  class space    used 347K, capacity 388K, committed 512K, reserved 1048576K
    
                在实际工作中,我们可以直接将初始的堆大小与最大堆大小相等,
                这样的好处是可以减少程序运行时垃圾回收次数,从而提高效率
            */
        }
    
    
    
    }
    
    

    5、GC回收算法

    5.1 复制算法

    这个方法适合实例比较少的情况,主要使用在新生区中的幸存区,from/to

    to区总是空的那块,从eden区如果没有被GC回收,那就会到from区,再到to区

    这时候to区有了,from区空了,此时的from区就变成了to区,如果实例在经过了15次回收还没被回收,就进入养老区。

    复制算法快,效率高,但是对应的,那会多使用一份内存,也就是那块to区

    5.2 标记算法

    标记算法是对每一个被引用了的实例做一个标记,如果这个实例没有被引用,就会被回收,但是这样会产生很多的内存碎片,效率又下来了。

    5.3 标记压缩算法

    通过压缩的方式,将我们标记的实例都放在同一块地方,其他没引用的就会被回收,这样虽然不会产生内存碎片,但是压缩会损耗一些时间。

    所以总的来说每个算法都各有优势。尽可能选择合适的算法,对jvm来说才是最好的。

    展开全文
  • JVM运行原理详解

    2021-02-28 19:31:03
    1、JVM 简析:作为一名Java 使用者,掌握 JVM 的体系结构是很有必要的。说起Java ,我们首先想到的是Java 编程语言,然而事实上,Java 是一种技术,它由四方面组成:Java 编程语言、Java 类文件格式、Java 虚拟机 和...

    1、JVM 简析:

    作为一名Java 使用者,掌握 JVM 的体系结构是很有必要的。

    说起Java ,我们首先想到的是Java 编程语言,然而事实上,Java 是一种技术,它由四方面组成:Java 编程语言、Java 类文件格式、Java 虚拟机 和 Java 应用程序接口(Java API)。他们的关系图如下:

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    Java平台

    Java 平台由 Java 虚拟机和 Java 应用程序接口搭建,Java 语言则是进入这个平台的通道,用Java 语言编写并编译程序可以运行在这个平台上。这个平台的结构如下所示:运行期环境代表着Java平台,开发人员编写Java 代码(.java文件),然后将之编译成字节码(.class文件),再然后字节码被装入内存,一旦字节码进入虚拟机,它就会被解释器解释执行,或者被即时代码发生器有选择的转换成机器码执行。

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    Java平台无关性

    JVM 在它的生命周期中有一个明确的任务,那就是运行Java 程序,因此当Java 程序启动的时候,就产生JVM 的一个实例;当程序运行结束的时候,该实例也跟着消失了。在Java 平台的结构中,可以看出,JVM 在核心的位置,是程序与底层操作系统和硬件无关的关键。它的下方是移植接口,移植接口由两部分组成:适配器和Java 操作系统,其中依赖平台的部分称之为适配器;JVM 通过移植接口在具体的平台和操作系统上实现;JVM 的上方是Java 基本类库和扩展类库以及他们的API,利用Java API 编写的应用程序(application)和小程序(Java applet)可以再任何Java 平台上运行而无需考虑底层平台,就是因为有Java 虚拟机(JVM)实现了程序与操作系统的分离,从而实现了Java 的平台无关性。

    下面,我们从JVM 的基本概念和运行过程这两个方面入手,来对它进行深入的研究。

    2、JVM 基本概念

    (1)基本概念:

    JVM 是可运行Java 程序的假想计算机,包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收、堆和一个存储方法域。JVM 是运行在操作系统之上的,它与硬件没有直接的交互。

    (2)运行过程:

    我们都知道Java 源文件,通过编译器,能够产生相应的.class文件,也就是字节码文件,而字节码文件又通过Java 虚拟机的解释器,解释成特定机器上的机器码。也就是如下:

    ① Java 源文件 ——> 编译器 ——> 字节码文件

    ② 字节码文件 ——> JVM ——> 机器码

    每一种平台的解释器是不同的,但是实现的虚拟机是相同的,这也就是Java 为什么能跨平台的原因了,当一个程序开始运行,这时虚拟机就开始实例化了,多个程序启动就会存在多个虚拟机实例。程序退出或者关闭,则虚拟机实例消亡,多个虚拟机实例之间数据不能共享。

    3、JVM 的体系结构

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    JVM 的体系结构

    (1)Class Loader 类加载器

    负责加载.class文件,class文件在文件开头有特定的文件标识,并且ClassLoader 负责class文件的加载。

    类的生命周期:加载 ——> 验证 ——> 准备 ——> 解析 ——> 初始化 ——> 使用 ——> 卸载

    1、加载:

    ① 通过一个类的全限定名,来获取此类的二进制字节码;

    ② 将这个字节码所代表的静态存储结构转化为方法区的运行时数据结构;

    ③ 在Java堆中生成一个代表这个类的Class对象,作为方法区这些数据的访问路口。

    2、验证:文件格式验证、元数据验证、字节码验证等。

    3、准备:准备阶段是正式为静态变量分配内存并设置静态变量初始值(各数据类型的零值)的阶段,这些内存将在方法区中进行分配。但是如果静态变量的字段属性为常量,则会初始化为指定的值,而不是零值。

    4、解析:解析阶段是在虚拟机将符号引用替换为直接引用的过程。直接引用可以是直接指向目标的指针、相对偏移量。

    5、初始化:为类的静态变量赋予指定的初始值。

    6、使用:使用类之前,必须对类进行实例化,如new或者反射。只有实例化了,才能通过对象的引用来访问对象的实例。

    7、卸载:执行垃圾回收。

    在类的加载过程中,静态成员会优先加载;而普通成员则是使用的时候才会去加载。

    加载顺序:

    1. 虚拟机在首次加载 Java 类时,会对静态代码块、静态成员变量、静态方法进行一次初始化(静态间按顺序执行)。

    2. 只有在调用 new 方法时才会创建类的实例。

    3. 类实例创建过程:父子继承关系,先父类再子类。父类的静态->子类的静态->父类的初始化块->父类的构造方法->子类的初始化块->子类的构造方法

    4. 类实例销毁时候:首先销毁子类部分,再销毁父类部分。

    双亲委派机制:

    JVM的类加载是通过ClassLoader及其子类来完成的,类的层次关系和加载顺序可以由下图来描述:

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    ClassLoader 类加载机制

    自上而下尝试加载,最下面的加载器没有加载到的话,则抛出ClassNotFoundException。

    Bootstrap ClassLoader启动类加载器:加载\lib路径下的jar包,即JDK核心jar包;

    Extension ClassLoader扩展类加载器:加载\lib\ext路径下的jar包;

    App ClassLoader应用程序类加载器:加载用户类路径 java -classpath 上所指定的类库,就是你项目配置的 jar 路径以及工程生成的 classes 的位置。双亲委派机制的优势:

    系统安全性:Java类随着加载它的类加载器一起具备了一种带有优先级的层次关系。比如,Java中的Object类,它存放在rt.jar之中,无论哪一个类加载器要加载这个类,最终都是委派给处于模型最顶端的启动类加载器进行加载,因此Object在各种类加载环境中都是同一个类。如果不采用双亲委派模型,那么由各个类加载器自己去加载的话,那么系统中会存在多种不同的Object类。

    (2) Native Interface 本地接口

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

    (3)Execution Engine 执行引擎

    执行包在类装载的方法中的指令。

    (4)Runtime data area 运行数据区

    虚拟机内存,从整个计算机内存中开辟一块内存存储JVM 需要用到的对象、变量等,运行区数据又分为很多小区:方法区,虚拟机栈,本地方法栈,堆,程序计数器。

    4、JVM 数据运行区详解(栈管理运行,堆管理存储)

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    JVM 运行时数据区

    说明:JVM 调优主要就是优化 Heap堆 和 Method Area 方法区,并且这两个区域是线程共享的数据区。

    (1)Native Method Stack 本地方法栈

    Native Method Stack 登记native 方法,在Execution Engine 执行加载native libraries。

    (2)PC Register 程序计数器

    每个线程都有一个程序计数器,就是一个指针,指向方法区中的方法字节码(下一个将要执行的指令代码),由执行引擎读取下一条指令。

    (3)Method Area 方法区

    方法区是被所有线程共享,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然 Java 虚拟机规范把方法区描述为堆的一个逻辑部分,但是它却有一个别名叫做 Non-Heap(非堆),目的是与 Java 堆区分开来。

    对于 HotSpot 虚拟机而言,很多人更愿意把方法区称为"永久带"(Permanent Generation),本质上两者并不等价,仅仅是因为 HotSpot 虚拟机的设计团队选择把 GC 分代收集扩展至方法区,或者说使用永久代来实现方法区而已。

    运行时常量池

    运行时常量池是方法区的一部分,Class 文件中除了有类的版本、字段、方法、接口等描述外,还有一项信息是常量池,用于存放编译期生成的各种字面量和符号引用,这部分内容将在类加载后进入方法区的运行时常量池中存放。

    采用字面值的方式创建一个字符串时(如 String s1 = "abc"),JVM 首先会去字符串池中查找是否存在 "abc" 这个对象,如果不存在,则在字符串池中创建 "abc" 这个对象,然后将池中 "abc" 这个对象的引用地址返回给 "abc" 对象的引用 s1,这样 s1 会指向池中 "abc" 这个字符串对象;如果存在,则不创建任何对象,直接将池中 "abc" 这个对象的地址返回,赋给引用 s1。

    注意:JDK1.8版本中,String 常量池 和 静态变量已经从方法区中的运行时常量池分离到堆中了。

    (4)Stack 栈

    ① 栈是什么

    栈也叫栈内存,主管Java 程序的运行,是在线程创建时创建,它的生命周期跟随线程的生命周期,线程结束栈内存也就释放,对于栈来说,不存在垃圾回收问题,只要线程一结束栈就Over,生命周期和线程一致,是线程私有的。

    基本类型的变量和对象的引用变量都是在栈内存中分配的,但是对象的实例还是保存在堆中的。

    ② 栈存储什么?

    栈帧中主要保存3类数据:

    局部变量(Local Variables):输入参数和输出参数以及方法类的变量;

    栈操作(Operand Stack):记录出栈、入栈的操作;

    栈帧数据(Frame Data):包括类文件、方法等等。

    ③ 栈运行原理

    栈中的数据都是以栈帧(Stack Frame)的格式存在的,栈帧是一个内存区块。当一个方法被A 调用时就产生了一个栈帧F1,并被压入到栈中,A 方法又调用了B方法,于是产生栈帧F2 也被压入栈,B方法又调用了C 方法,于是产生栈帧F3 也被压入栈,依次执行完毕后,先弹出F3 栈帧,再弹出F2 栈帧,再弹出F1 栈帧。遵循“先进后出”原则。

    当出现递归方法,参数个数过多、递归过深、递归没有出口时,就有可能报 StackOverflow 异常。

    (5)Heap 堆(ParNew + CMS 组合为例)

    堆这块区域是JVM 中最大的,实例对象(成员变量,方法)都是存在这个区域,这块区域是GC 主要的回收区,一个 JVM 实例只存在一个堆内存,堆内存大小是可以调节的。类加载器读取了类文件后,需要把类、方法放到堆内存中,以方便执行器执行,堆内存分为三部分:

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    Heap 堆内存

    ① 新生代(ParNew 垃圾收集器为例)

    新生代是类的诞生、成长、消亡的区域,一个类在这里产生、应用,最后被垃圾回收器收集,结束生命。新生区又分为两部分:伊甸区(Eden space)和幸存区(Survivor pace),空间分配是 8:1:1,绝大多数的类都是在伊甸区被 new 出来的。幸存区有两个:0区(Survivor 0 space)和 1区(Survivor 1 space)。两个Survivor 区空间一样大,当Eden 区满了,则会触发普通GC,若 Eden 区中的对象经过垃圾回收没有被回收掉,会将Eden 区中的幸存对象移动到幸存区(0或1)。若该幸存区也满了,则继续触发普通 GC,然后将 eden 区和 survivor0 区存活对象复制到另一个survivor1区,然后清空eden和这个survivor0区,此时survivor0区是空的,这样在一段时间内,总会有一个空的survivor区。经过多次GC周期后,仍然存活下来的对象会被转移到年老代内存空间 。通常这是在年轻代有资格提升到年老代前通过设定年龄阈值来完成的。需要注意,Survivor的两个区是对称的,没先后关系。

    显然,Survivor 区只是增加了对象在年轻代中逗留的时间,增加了被垃圾回收的可能性。若养老区也满了,那么这时候将产生Full GC,进行新生代+养老区的内存清理,FullGC 的过程当中,整个JVM是暂停的(所有的应用都被暂停掉)。若Full GC 之后发现依然无法进行对象的保存,就会产生 OOM 异常“OutOfMemoryError”。

    新生代特点:每次垃圾回收时都有大量的对象需要被回收。垃圾回收器在新生代采用的收集算法是Copying(复制)方法:它将可用内存按容量划分为大小相等的两块,每次只使用其中的一块。当这一块面对内存用完了,就将还存活的对象复制到另外一块,然后再把已使用的内存空间一次清理掉。由于新生代有每次垃圾回收时都有大量的对象需要被回收的特点,所以采用Copying算法,复制的存活对象较少,性能比较好。但是Copying算法还是有缺陷的,那就是内存的使用率只有一半。

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    Copying如果出现 java.lang.OutOfMemoryError: Java heap space 异常,说明Java 虚拟机的堆内存不够。可能产生的原因如下:

    1、Java 虚拟机的堆内存设置不够,可以通过-Xms、-Xmx来调整;

    2、代码中创建了大量大对象,并且长时间不能被垃圾回收器收集;

    3、内存加载的数据量太大:一次性从数据库取太多数据;

    4、集合类中有对对象的引用,使用后未清空,GC不能进行回收;

    5、代码中存在循环产生过多的重复对象。

    ② 老年区(CMS 垃圾收集器为例)

    年轻代中经过垃圾回收没有回收掉的对象将被Copy到年老代。

    老年代的特点: 每次垃圾回收时只有少量的对象需要被回收。垃圾回收器在老年代采用的收集算法是 Mark-Sweep 算法(标记-清除算法):为了解决 Copying 算法的缺陷,充分利用内存空间,提出了 Mark-Sweep 算法。它先将需要回收的对象进行标记,然后清理掉需要回收的对象内存。

    标记-清除算法的主要缺点是,由于是直接清理掉需要回收的对象内存,所以会产生空间碎片。这样当分配新的对象而没有足够的连续内存空间时,就会使用 Full GC 来对整个堆空间进行压缩,从而影响性能。CMS 垃圾收集器有个优化的点是,当出现上述情况时,不直接使用 Full GC 来处理,而会采用标记-整理算法,来对未标记的存活对象进行移动,从而清理掉端界以外的内存。如下图:

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    Mark-Compact

    ③ 永久代

    只有 HotSpot 虚拟机才有永久代的概念,永久代存放类的常量、静态变量等信息,是方法区的实现,可以直接理解为方法区,所以实际上,永久代不属于堆,而是方法区。对永久代的回收主要回收两部分内容:废弃常量和无用的类。如果出现java.lang.OutOfMemoryError: PermGen space,说明是Java 虚拟机对永久带Perm内存设置不够。原因有二:

    1、程序启动需要加载大量的第三方jar包。例如:在一个Tomcat 下部署了太多的应用。

    2、大量动态反射生成的类不断被加载,最终导致Perm 区被占满。

    注意:JDK1.8 之后,不存在永久代,即没有 java.lang.OutOfMemoryError: PermGen space 这种错误。取而代之的是 Meta space(元空间)。之前存储在永久带的字符串常量,静态变量移到了堆中去了,元空间不存储在虚拟机中,而是存储在本地内存中。元空间存储的是 class 文件在 jvm 里的运行时数据结构,如 method,constantPool(运行时常量池)。

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    JDK 1.8之前堆内存结构图

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    JDK 1.8堆内存结构图

    JDK8  取消永久代的考量:

    永久代是 HotSpot 虚拟机特有的,是一个较小的内存空间,所以很容易出现内存不足的情况,导致频繁 Full GC,这是不合理的。故 JDK 8,依照 JRockit 虚拟机的设计,使用元空间替代了永久代,并且将其存放在本地内存中,从而避免了永久代的频繁 Full GC 现象。

    CMS垃圾收集器(Major GC)的触发条件有以下几个:

    1、如果没有设置-XX:+UseCMSInitiatingOccupancyOnly,虚拟机会根据收集的数据决定是否触发(建议带上这个参数)。

    2、老年代使用率达到阈值 CMSInitiatingOccupancyFraction,默认 92%,前提是配置了第一个参数。

    3、永久代的使用率达到阈值 CMSInitiatingPermOccupancyFraction,默认92%,前提是开启 CMSClassUnloadingEnabled并且配置了第一个参数。

    4、新生代的晋升担保失败。

    4、垃圾回收机制

    垃圾回收:当一个对象没有引用指向它时,这个对象就成为无用的内存(垃圾),就必须进行回收,以便于后续其他对象的内存分配。

    判断对象是否存活的方法——可达性分析:程序把所有的引用关系看做一张图,如果一个节点与GC Roots之间没有引用链存在,则该节点视为垃圾回收的对象。可作为GC Roots对象的包括如下几种:

    1、虚拟机栈(栈帧中的本地变量表)中引用的对象;

    2、方法区中的静态变量引用的对象;

    3、方法区中常量引用的对象;

    4、本地方法栈中JNI(Java Native Interface)引用的对象。

    5、内存调优简介

    在说内存调优之前,我们先了解下内存泄漏和内存溢出。

    内存泄漏:是指程序申请内存后,无法释放已申请的内存空间,一次内存泄漏似乎不会影响很大的影响,但是内存泄漏堆积后的后果就是内存溢出。

    内存溢出:指程序申请内存时,没有足够的内存供申请者使用。

    内存溢出的几种原因:

    1.内存中加载的数据量过于庞大,如一次从数据库取出过多数据;

    2.集合类中有对对象的引用,使用完后未清空,使得JVM不能回收;

    3.代码中存在死循环或循环产生过多重复的对象实体;

    4.使用的第三方软件中的BUG;

    5.启动参数内存值设定的过小(-Xms、-Xmx)。

    调优参数:

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    内存调优参数

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    JDK 1.8内存容量查询

    说明:在Run Config中的 vm options 中输入“-XX:+PrintGCDtails”,可以看到堆内存运行情况:

    9b0b7409f292?tdsourcetag=s_pctim_aiomsg

    JDK1.8 内存运行情况(示例)

    (1) 堆大小设置

    典型设置:

    1、java -Xmx3550m -Xms3550m -Xmn2g -Xss128k

    -Xmx3550m:设置JVM 最大可用内存为3550M。

    -Xms3550m:设置JVM 初始内存为3550m。此值可以设置与-Xmx 相同,以避免每次垃圾回收完成后JVM 重新分配内存。

    -Xmn2g:设置新生代大小为2G。整个JVM内存大小 = 新生代大小 + 老年代大小  + 元空间。Sun 官方推荐配置为整个堆内存的3/8。

    -Xss256K:每个线程默认会开启1M的堆栈,用于存放栈帧、调用参数、局部变量等,对大多数应用而言这个默认值太了,一般256K就足用。理论上,在内存不变的情况下,减少每个线程的堆栈,可以产生更多的线程,但这实际上还受限于操作系统。

    2、java -Xmx3550m -Xms3550m -Xss128k -XX:NewRatio=4 -XX:SurvivorRatio=4  -XX:MaxTenuringThreshold=3

    -XX:NewRatio = 4:设置新生代(包括Eden和两个Survivor 区)与老年代(出去元空间)的比值。设置为4,则新生代与老年代所占比值为1:4,新生代占整个堆内存的1/5。

    -XX:SurvivorRatio = 4:设置新生代Eden 区与Survivor 区的大小比值。设置为4,则两个Survivor 区与一个Eden 区的比例为2:4,一个Survivor 区占整个年轻代的1/6。

    -XX:MaxTenuringThreshold=3:设置垃圾最大年龄为3,即对象在Survivor 区存在的年龄为3(复制一次年龄+1)。如果设置为0,则年轻代对象不经过Survivor 区,直接进入老年代。对于老年代比较多的应用,可以提高效率。如果将此设置为一个较大的值,则年轻代对象会在Survivor 区进行多次复制,这样可以增加对象在年轻代存活的时间,增加在年轻代被回收的概率。此参数只有在串行GC时才有效。

    (2)回收器选择

    JVM 给了三种选择:串行收集器(单线程)、并行收集器、并发标记清除收集器(CMS),但是串行收集器只适用于小数据量的情况。默认情况下,JDK5.0以前都是使用串行收集器,如果想使用其他收集器需要在启动时加入相应的参数。JDK5.0以后,JVM会根据当前系统配置进行判断。

    并行收集器是用多线程进行垃圾回收,回收期间会暂停应用程序的执行(stop the world)。而 CMS,也是多线程回收,虽然年轻代回收期间也会 stop the world,但在老年代 CMS 绝大多数情况是并发的,即 jvm 垃圾回收线程和应用程序的线程可以同时进行。老年代的某些阶段也会暂停应用程序,比如初始化标记和重新标记阶段。所以,CMS 适用于交互性高的一些程序,比如 Web 程序,而并行收集器适用于吞吐量高的一些场景。

    CMS 回收器的缺点

    1、空间碎片

    因为年老代的并发收集器使用标记、清除算法,所以不会对堆进行压缩。当收集器回收时,他会把相邻的空间进行合并,这样可以分配给较大的对象。但是,当堆空间较小时,运行一段时间以后,就会出现“碎片”,如果并发收集器找不到足够的空间,那么并发收集器将会停止,然后使用传统的串行 GC 方式进行回收,触发一次 full gc,导致一个漫长的暂停。

    2、执行GC时间较长

    老年代收集器必须扫描整个老年代空间,比如标记、清除、以及压缩。这就意味着 GC 执行工作的时间随着 java 堆空间的变化而线性的增加或者减少。

    新一代垃圾收集器:Garbage First(G1)

    G1 垃圾收集器是 JDK8 引入的新一代垃圾收集器,G1 将堆拆分成一系列分区。每个分区的大小是 2 的幂次方,在 1M—32M之间,即 1M、2M、4M、8M、16M、32M。JVM 划分大约2048个分区,所以每个分区的大小取决于 java 堆的分配大小。

    在 G1 里,年轻代就是一系列的内存分区,这意味着不用再要求年轻代是一个连续的内存块。类似的,老年代也是一系列的分区组成。G1的垃圾收集周期主要分为 3 种类型:年轻代收集周期、多级并发标记周期和混合收集周期。还有一种单线程的暂停 full gc,它是 GC 在垃圾收集遇到转移失败的情况下所采取的安全保护机制,比如目标空间耗尽。

    年轻代周期:

    年轻代由 2 部分组成,一块是 G1 指定的 eden 分区,另一块是 survivor 分区。当 JVM 从 eden 分区中分配失败,也就是说 eden 分区已经被完全占满,这时会触发一次年轻代收集。年轻代收集首先会把所有存活对象从 eden 分区转移到 survivor 分区中。也就是我们经常说的“拷贝到 survivor”。从此时开始,任意一次年轻代收集都将把存活对象从整个年轻代(不论是 eden 分区还是 survivor 分区)晋升到新的 survivor 分区中。年轻代收集偶尔也会将一些存活对象晋升到老年代分区,这些对象已经到了预先设定的晋升阀值(默认为15,存放在对象头中)。

    多级并发标记周期:

    随着越来越多的对象被晋升到老年代,或者巨型对象被分配到巨型分区中,老年代的占用比例也越来越多。当老年代的占用比例(与整个堆相比)超过了阀值(默认为 45%),就会触发并发标记周期。

    一个 G1 并发周期包含了几个阶段的活动:初始阶段、并发根分区扫描、并发标记、重新标记以及清除。

    初始阶段的目的是收集所有的 GC Roots,它是对象图的起点。为了从应用线程中收集根引用,必须先暂停应用线程,所以初始标记阶段是 stop the world 方式的。

    标记操作的同时还必须扫描和跟踪 survivor 分区里所有对象的引用(可达性分析),这也是并发根分区扫描所要做的事情。这个阶段,所有 java 线程都允许执行,所以不会发生应用暂停。

    大部分标记工作是在并发标记阶段完成的。多个线程协同标示存活对象图。所有 java 线程都允许执行,所以不会发生应用暂停。

    完成并发标记后就需要一个 stop the world 方式的阶段来完成最终的标记工作,这个阶段被称为“重新标记阶段”。因为上面的并发标记是允许 java 线程执行的,所以有可能会漏掉标记新的存活对象,需要一个 stop the world 的重新标记。

    并发标记周期的最后阶段是清除阶段,在这个阶段,找出那些没有任何存活对象的分区将被回收,回收完后被添加到可用分区的队列里。

    混合收集周期:

    完成并发标记周期之后,G1 就能识别出最适合被回收的老年代分区集合,于是就会触发混合收集。

    混合收集:混合 GC 就是在一次垃圾收集事件中,所有的年轻代分区以及一部分老年代分区将会被回收。

    混合收集和年轻代收集是类似的,同时用拷贝的方式对存活的对象进行压缩。

    巨型对象:

    巨型对象就是指那些尺寸非常大的对象,他们至少占用一个分区的50%甚至更多的空间。这样一个对象不会使用通常用到的快速分配方式,它会在老年代的巨型分区(一个或多个相邻的堆分区)里直接分配。

    展开全文
  • 第1篇:JVM运行原理

    2021-07-26 22:17:57
    文章目录前言一、类的生命周期二、类加载原理1、类加载的过程2、代码示例三、双亲委派原理1、原理图2、双亲委派的优点四、Tomcat类加载机制总结 前言 学习JVM,首先需要了解类的生命周期?以及类加载原理?并且需要...
  • Java语言写的源程序通过Java编译器,编译成与平台无关的...一、JVM原理1、JVM简介:JVM是java的核心和基础,在java编译器和os平台之间的虚拟处理器。它是一种利用软件方法实现的抽象的计算机基于下层的操作系统和...
  • jvm运行原理及垃圾回收

    千次阅读 2021-05-24 14:56:01
    类加载阶段就是由类加载器负责根据一个类的全限定名来读取此类的二进制字节流到JVM内部,并存储在运行时内存区的方法区,然后将其转换为一个与目标类型对应的java.lang.Class对象实例,简单理解就是查找class文件并...
  • JAVA和JVM运行原理

    2021-03-09 06:32:17
    JVM是java的核心和基础,在java编译器和os平台之间的虚拟处理器。它是一种利用软件方法实现的抽象的计算机基于下层的操作系统和硬件平台,可以在上面执行java的字节码程序。编译器负责把Java程序转成Class文件,方便...
  • jvm运行原理流程图

    2021-07-23 15:54:00
  • HelloWorld我们都写过,他是怎么在我们系统上运行的呢,那就是我们jvm的作用了。看图说话:Helloword.java通过jdk的javac命令将.java文件编译成.class文件。然后,就可以在jvm运行了。 java具有跨平台性,那么跨...
  • 原标题:大神教你JVM运行原理及Stack和Heap的实现过程Java语言写的源程序通过Java编译器,编译成与平台无关的‘字节码程序’(.class文件,也就是0,1二进制程序),然后在OS之上的Java解释器中解释执行,而JVM是java...
  • 我们已经把完整的JVM运行原理、GC原理以及GC优化的原理,还有线上发生GC问题的各种优化案例分析完了,所以到这里务必停一停脚步,整理一下学习过的知识脉络 。 JVM和GC的运行原理 对于JVM的学习,首先务必要搞清楚...
  • 概述因为线上系统遇到CPU100%的问题,这种问题在流量较大时比较常见,因为JDK自身有很多JVM调试工具,如jps、jstack、jmap、jhat、jstat等使用工具,在实际工作中使用这些工具进行调试是十分必要的,一般通过上面...
  • JVM运行原理解析

    2021-10-21 15:40:17
    JVM(Java Virtual Machine)java虚拟机,java程序就是运行jvm里面 javac命令:把.java文件编译为.class文件(字节码文件) java命令:类的加载器加载字节码文件(需要java类库的支持),然后通过字节码解释器和jit及时编辑...
  • java虚拟机JVM运行原理

    2021-03-16 02:35:50
    [Java语言写的源程序通过Java编译器,编译成与平台无关的‘字节码程序’(.class文件,也就是0,1二进制程序),然后在OS之上的Java解释器中解释执行,而JVM是java的核心和基JVM[Java的运行原理 在Java中引入了虚拟机...
  • JAVA和JVM运行原理揭秘

    2021-03-10 08:35:53
    这里和大家简单分享一下JAVA和JVM运行原理,Java语言写的源程序通过Java编译器,编译成与平台无关的‘字节码程序’(.class文件,也就是0,1二进制程序),然后在OS之上的Java解释器中解释执行,而JVM是java的核心和...
  • 什么是JVMJVM是Java Virtual Machine的缩写,简称Java虚拟机,它是一种用于计算设备的规范,它...JVM运行在操作系统之上的,它与硬件没有直接的交互。Java程序运行过程每一位Java工程师都知道Java源文件是通过编...
  • 1.jvm内存区域划分 以jdk1.8为例,执行我们的一些对象方法,执行代码的时候肯定会有很多线程,tomcat里就有很多自己的工作线程,去执行我们写的代码,每个工作线程都会有自己的数据结构,栈空间(也就是说每个线程...
  • 前言 在找资料的过程中,发现大多数讲jvm的文章都比较庞杂,对于只想在短时间内了解jvm的组成部分以及工作流程的人不是很友好,所以将...Java代码在JVM中被类加载器加载为字节码后,被运行时数据区加载到内存中(即被
  • 1.JAM的运行原理JVM JVM是Java Virtual Machine(Java虚拟机)的缩写,是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机主要由字节码指令集、寄存器、栈、垃圾回收堆...
  • 一、什么是JVMJVM(Java Virtual Machine,Java虚拟机) 虚拟机是一种抽象化的计算机,通过在实际的计算机上仿真模拟各种计算机功能来实现的...简单来说JVM是用来解析和运行Java程序的。 Java语言的一个非常重...
  • 1.JVM运行原理 首先要对字节码文件进行类的加载,进行类的加载时需要java类库的支持,然后通过字节码解释器和JIT即时编辑器分别执行引擎,最后将结果输出到硬件上. 2.float类型和long类型哪个取值范围更大 float...
  • 面试必问:常见JVM面试题一、详解JVM内存模型二、JVM中一次完整的GC流程是怎样的三、GC垃圾回收的算法有哪些四、简单说说你了解的类加载器五、双亲委派机制是什么,怎么打破六、说说你JVM调优的几种主要的JVM参数 ...
  • JVM原理

    千次阅读 2021-06-15 17:19:17
    JVM是Java Virtual Machine(Java虚拟机)的缩写,JVM是一种用于计算设备的规范,它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 Java语言的一个非常重要的特点就是与平台的...
  • JVM 运行机制及其原理

    2021-03-09 23:31:55
    JVM 运行机制及其原理发布时间:2018-05-22 22:15,浏览次数:1074, 标签:JVM最近出去面试,总被问到JavaJVM相关的东西,什么JVM的内存模型、JVM的内存分配、内存回收、内存回收算法…搞得我一头雾水,早些年还看过...
  • JVM 的知识点太散,不系统,今天带大家详细的了解一下jvm运行原理。 正文 1 什么是JVMJVM是Java Virtual Machine(Java虚拟机)的缩写,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。由一套字节码...
  • 揭秘Java虚拟机 JVM设计原理与实现 内容简介《揭秘Java虚拟机:JVM设计原理与实现》从源码角度解读HotSpot的内部实现机制,本版本主要包含三大部分——JVM数据结构设计与实现、执行引擎机制及内存分配模型。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 173,652
精华内容 69,460
关键字:

jvm运行原理

友情链接: yolov3-master-protorch.zip