JVM学习02-虚拟机的基本结构

已于 2022-03-30 15:07:29 修改
阅读量410 收藏 1
点赞数 1
分类专栏： java # jvm 文章标签： jvm java java虚拟机
于 2021-05-11 10:56:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wejack/article/details/116645383
版权
java 同时被 2 个专栏收录
43 篇文章 0 订阅
订阅专栏
jvm
11 篇文章 0 订阅
订阅专栏

JVM学习02-虚拟机的基本结构

1.虚拟机的基本结构

虚拟机的结构可以参考 java虚拟机规范 进行理解

  • 类加载子系统

加载类信息（class）到方法区

  • 方法区

存放类信息、运行时常量池信息（字符串和数字常量）

  • java堆

虚拟机启动时建立的内存工作区域，存放几乎所有java对象实例，所有线程共享。

  • 直接内存（NIO）

java堆外的直接向系统申请的内存，可以由java的NIO库进行操作。速度优于java堆，适用于频繁读写，不受Xmx最大内存限制，受操作系统最大内存限制

  • 垃圾回收系统

可以对方法区、java堆和直接内在进行回收。重点回收java堆。

  • java栈

每个java虚拟机线程都有一个私有的java栈，在线程被创建的时候创建。java栈中保存着栈帧信息，还保存着局部变量、方法参数，与java方法的调用 、返回密切相关。

  • 本地方法栈

java虚拟机的重要扩展，本地方法（通常C编写 ）

  • Program Counter 程序计数器/PC寄存器

程序计数器也是线程私有空间。

  • 执行引擎

核心组件，执行虚拟机字节码。

2.堆空间结构

堆空间分为新生代和老年代

  • 新生代：新生对象或年龄不大的对象

    • eden区

      对象首先分配在eden区，新生代回收后，如果对象还存活，则会进入 s0或者s1区

    • s0区（from区)和s1区（to区），大小相等的两块，可以互换角色的内存空间

      每经一次新生代回收，存活的对象的年龄会加1，达到一定条件后会被认为是老年对象进入老年区。

      （问题，判定老年对象的条件是什么）

  • 老年代

堆、方法区、栈的关系

3.函数调用与java栈

线程的执行的基本行为是函数调用，每次函数调用的数据都是通过java栈传递。java栈的主要内容是栈帧，每次函数调用都会有栈帧压入java栈，函数调用结束栈帧被弹出java栈。

函数返回时，栈帧从java栈中弹出。java方法有两种返回函数的方式，一种是return，一种是抛出异常。一个栈帧中至少要包含局部变量表、操作数栈和栈帧数据区几个部分。

由于每次函数调用都会生成对应的栈帧，所以会占用栈空间，因此，如果栈空间不足，那函数调用无法继续进行下去，当请求的栈尝试大于最大可用栈深度时，系统就会抛出StackOverFlowError栈溢出错误。可以使用参数 -Xss来指定线程的最大栈空间，这个参数决定了函数的最大的调用深度。函数嵌套调用的层次，取决于栈空间的大小，栈越大，函数就可以嵌套越多次。

  • 局部变量表

    保存函数的参数及局部变量。

    ps：相同的栈容量下，局部变量少的函数，可以支持更深的函数调用，如果函数的参数和局部变量较多，会使局部变量表膨胀，导致函数嵌套次数变少。

    栈帧中的局部量变量中的槽位是可以重用的，局部变量过了作用域，后续新申请的局部变量可能会复用过作用域的局部变量的槽位，用以节约资源。

    以下代码来测试局部变量与垃圾回收关系

    /**
 *
 * 测试变量的GC结果
 * 执行时增加jvm参数  -XX:+PrintGC
 * @author domino
 * @date 2021/5/17
 */
public class TestLocalVariable {

    /**
     * 有引用指向变量不会被回收
     */
    public void localVarGc1() {
        byte[] a = new byte[6 * 1024 * 1024];
        System.gc();
    }

    /**
     * 无引用指向变量被回收
     */
    public void localVarGc2() {
        byte[] a = new byte[6 * 1024 * 1024];
        a = null;
        System.gc();
    }

    /**
     * 虽然变量超过作用域，但是变量仍存在于局部变量表中，并且也指向数组，所以不会被立即回收
     */
    public void localVarGc3() {
        {
            byte[] a = new byte[6 * 1024 * 1024];
        }
        System.gc();
    }

    /**
     * a变量超过了作用域，a变量失效，新建变量c，使用了a变量的字，a变量被销毁，垃圾回收可以正常回收数组
     */
    public void localVarGc4() {
        {
            byte[] a = new byte[6 * 1024 * 1024];
        }
        int c = 10;
        System.gc();
    }

    /**
     * 调用 localVarGc1 方法以后，localVarGc1的栈帧被销毁，栈帧中的局部变量被销毁，所以可以正常垃圾回收
     */
    public void localVarGc5() {
        localVarGc1();
        System.gc();
    }

    public static void main(String[] args) {
        TestLocalVariable t1 = new TestLocalVariable();
//        t1.localVarGc1();
//        t1.localVarGc2();
//        t1.localVarGc3();
//        t1.localVarGc4();
        t1.localVarGc5();
    }
}

    方法1到方法5的运行结果如下，可以结合方法注释来看结果原因。

    ----------------------
[GC (System.gc())  10080K->6824K(251392K), 0.0048977 secs]
[Full GC (System.gc())  6824K->6599K(251392K), 0.0056204 secs]
----------------------
[GC (System.gc())  16676K->6831K(251392K), 0.0008493 secs]
[Full GC (System.gc())  6831K->411K(251392K), 0.0045246 secs]
----------------------
[GC (System.gc())  10487K->6619K(251392K), 0.0010462 secs]
[Full GC (System.gc())  6619K->6555K(251392K), 0.0041690 secs]
----------------------
[GC (System.gc())  14010K->6555K(251392K), 0.0003860 secs]
[Full GC (System.gc())  6555K->411K(251392K), 0.0036868 secs]
----------------------
[GC (System.gc())  9177K->6651K(251392K), 0.0011968 secs]
[Full GC (System.gc())  6651K->6555K(251392K), 0.0050845 secs]
[GC (System.gc())  6555K->6555K(251392K), 0.0005586 secs]
[Full GC (System.gc())  6555K->411K(251392K), 0.0042518 secs]

    使用工具jclasslib可以查看函数的中变量的作用域、槽位的索引、变量名、数据类型等等，这个文档写着比较麻烦，后面补充

  • 操作数栈

    用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。

  • 帧数据区

    栈帧用来支持常量池解析、正常方法返回和异常处理等的数据

    • 帧数据区中保存着常量池的指针，方便程序访问常量池。（疑问：常量池在什么区？）
    • 异常处理表是帧数据区中重要部分，在处理异常时，虚拟机必须有一个异常处理表方便发生异常时找到处理的代码。

  • 栈上分配

    java虚拟机优化技术，将线程私有对象分配到栈上，不分配到堆，函数调用后自行销毁，不需要垃圾回收提高性能。

    栈上分配的技术基础是逃逸分析，判断对象的作用域是否能逃出函数体。如果不能，可能被分配到栈上而不在堆上。

    测试代码:

    /**
 * 本类测试栈上分配，逃逸分析，局部变量范围未超出函数体可能会被分配到栈而不是堆
 *
 * 执行方法要加以下jvm参数
 * -server -Xmx10m -Xms5m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-UseTLAB -XX:+EliminateAllocations
 * 说明：
 * -server server模式下才会启用逃逸分析
 * -Xmx10m 指定堆空间最大内存为10M
 * -XX:+DoEscapeAnalysis 启用逃逸分析
 * -XX:+PrintGC 打印GC日志
 * -XX:-UseTLAB 关闭TLAB Thread Local Allocation Buffer 线程本地分配缓存
 * -XX:+EliminateAllocations 开启标量替换（默认是打开的），允许将对象打散分配到栈上，如对象拥有id和name
 *      这两人个变量将被视为两个独立的局部变量进行分配
 * 执行结果
 * [GC (Allocation Failure)  1023K->565K(5632K), 0.0012699 secs]
 * [GC (Allocation Failure)  1589K->613K(6656K), 0.0015624 secs]
 * 9
 *  GC (Allocation Failure) ： 发生了一次垃圾回收，若前面有Full则表明是Full GC，没有Full的修饰表明这是一次Minor GC
 *  。注意它不表示只GC新生代，括号里的内容是gc发生的原因，这里的Allocation Failure的原因是年轻代中没有足够区域能够存放需要分配的数据而失败，。
 *  参考：https://blog.csdn.net/topdeveloperr/article/details/88874957
 *
 *
 * @author dmn
 * @date 2021/5/19
 */
public class OnStackTest {
    
    public static class User {
        public int id = 0;
        public String name = "";
    }

    public static void alloc() {
        User user = new User();
        user.id = 5;
        user.name = "dmn";
    }

    public static void main(String[] args) throws InterruptedException {
        long a = System.currentTimeMillis();
        for (int i = 0; i < 200000000; i++) {
            alloc();
        }
        long b = System.currentTimeMillis();
        System.out.println(b - a);
    }
}

    以上代码执行结果如下，我们可以看到，执行完了，中间只出现过3次GC

    [GC (Allocation Failure)  1023K->519K(5632K), 0.0006984 secs]
[GC (Allocation Failure)  1543K->567K(5632K), 0.0011059 secs]
[GC (Allocation Failure)  1591K->583K(5632K), 0.0010251 secs]
8

    而作为对比，我们如果将上述代码中的main方法改为如下：

        public static void main(String[] args) throws InterruptedException {  
        List<User> userList = new ArrayList<User>();
        for (int i = 0; i < 200000000; i++) {
            User user = new User();
            user.id = 5;
            user.name = "dmn";
            userList.add(user);
            System.out.println(i);
        }
    }

    执行的结果为如下，加了输出以后，可以看到，当集合加入了第240096个user对象以后，就发生了OutOfMemoryError了，说明内存最多放下240096个对象，不是内存够用。

    [GC (Allocation Failure)  1023K->558K(5632K), 0.0007154 secs]
[GC (Allocation Failure)  1580K->937K(5632K), 0.0015253 secs]
[GC (Allocation Failure)  1961K->1667K(5632K), 0.0011996 secs]
[GC (Allocation Failure)  2691K->2705K(6656K), 0.0015517 secs]
[GC (Allocation Failure)  4753K->4378K(6656K), 0.0023053 secs]
[Full GC (Ergonomics)  4378K->3657K(9728K), 0.0302245 secs]
[GC (Allocation Failure)  4790K->4833K(8704K), 0.0056917 secs]
[GC (Allocation Failure)  5857K->5907K(9216K), 0.0018717 secs]
[GC (Allocation Failure)  6931K->6971K(9216K), 0.0022074 secs]
[Full GC (Ergonomics)  6971K->6211K(9216K), 0.0428260 secs]
[GC (Allocation Failure)  6981K->7139K(9216K), 0.0035979 secs]
[Full GC (Ergonomics)  7139K->6981K(9216K), 0.0411045 secs]
[GC (Allocation Failure)  6981K->6981K(9216K), 0.0008322 secs]
[Full GC (Allocation Failure)  6981K->6963K(9216K), 0.0573462 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Arrays.java:3210)
	at java.util.Arrays.copyOf(Arrays.java:3181)
	at java.util.ArrayList.grow(ArrayList.java:265)
	at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:239)
	at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:231)
	at java.util.ArrayList.add(ArrayList.java:462)
	at cn.shutdown.demo.OnStackTest.main(OnStackTest.java:57)

Process finished with exit code 1

    但是很奇怪的是我去掉了-XX:+DoEscapeAnalysis和-XX:+EliminateAllocations两个jvm参数以后，执行的结果也还是一样，在配置较低的Linux服务器上面执行也是一样，没有像书中介绍的出现大量的GC日志。

    去掉参数使用idea执行结果
[GC (Allocation Failure)  1023K->533K(5632K), 0.0008148 secs]
[GC (Allocation Failure)  1557K->597K(5632K), 0.0015174 secs]
[GC (Allocation Failure)  1621K->597K(5632K), 0.0021861 secs]
9

    在centos中执行去掉参数的结果
[root@hdss7-188 temp]# java -server -Xmx10m -Xms10m -XX:+PrintGC -XX:-UseTLAB  OnStackTest
[GC (Allocation Failure)  2751K->255K(9920K), 0.0006507 secs]
[GC (Allocation Failure)  3007K->255K(9920K), 0.0003628 secs]
[GC (Allocation Failure)  3007K->255K(9920K), 0.0001592 secs]
16

4.方法区

方法区是所有线程共享的内存区域，用于保存系统的类信息，类的字段、方法、常量池等。方法区大小决定系统可以保存多少个类。如果类太多可能导致方法区溢出而抛出内在溢出错误。

jdk1.6、jdk1.7中，方法区理解为永久区Perm。使用-XX:PermSize和-XX:MaxPermSize指定，默认-XX:MaxPermSize为64MB。如果使用了动态代理 ，可能会在运行时生成 大量的类，那就需要设置一个合理的永久区大小。

测试方法区代码：

import java.util.HashMap;

/**
 * 测试方法区/永久区，
 * 用1.7的jdk运行加以下参数
 * -XX:PermSize=5m -XX:+PrintGCDetails -XX:MaxPermSize=5m
 * 1.8的jdk运行加以下参数
 * -XX:MaxMetaspaceSize=10m -XX:+PrintGCDetails
 *
 * @author domino
 * @date 2021/5/20
 */
public class PermTest {

    public static void main(String[] args) {
        int i = 0;
        try {
            Map<String, Object> map = new HashMap<>();
            map.put("id", Integer.class);
            map.put("name", String.class);
           //书上的数量是100000，但很快就正常运行完了，所以我把数量提升到了2000000000
            for (i = 0; i < 2000000000; i++) {
                CglibBean bean = new CglibBean("cn.shutdown.demo.Permtest" + i, map);
            }
        } catch (Throwable e) {
            System.out.println("total create count" + i);
        } finally {
            System.out.println("total create count" + i);
        }
    }
}


import net.sf.cglib.beans.BeanGenerator;
import net.sf.cglib.beans.BeanMap;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class CglibBean {

    @SuppressWarnings("unchecked")
    public CglibBean(Map propertyMap) {
        Object object = generateBean(propertyMap);
        BeanMap beanMap = BeanMap.create(object);
    }

    @SuppressWarnings("unchecked")
    private Object generateBean(Map propertyMap) {
        BeanGenerator generator = new BeanGenerator();
        Set keySet = propertyMap.keySet();
        for (Iterator i = keySet.iterator(); i.hasNext(); ) {
            String key = (String) i.next();
            generator.addProperty(key, (Class) propertyMap.get(key));
        }
        return generator.create();
    }
}

因为我的本机的jdk是1.8版本，已经移除了永久区，所以使用-XX:MaxMetaspaceSize=10m -XX:+PrintGCDetails 的参数去运行，但是100000的数量很快就执行完了，执行的结果如下。

[GC (Allocation Failure) [PSYoungGen: 65536K->1042K(76288K)] 65536K->1050K(251392K), 0.0025167 secs] [Times: user=0.01 sys=0.01, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 66578K->656K(76288K)] 66586K->672K(251392K), 0.0028107 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
total create count100000
Heap
 PSYoungGen      total 76288K, used 30148K [0x00000007aa900000, 0x00000007b3e00000, 0x00000007ffe00000)
  eden space 65536K, 45% used [0x00000007aa900000,0x00000007ac5cd130,0x00000007ae900000)
  from space 10752K, 6% used [0x00000007af380000,0x00000007af424010,0x00000007afe00000)
  to   space 10752K, 0% used [0x00000007ae900000,0x00000007ae900000,0x00000007af380000)
 ParOldGen       total 175104K, used 16K [0x00000006ffe00000, 0x000000070a900000, 0x00000007aa900000)
  object space 175104K, 0% used [0x00000006ffe00000,0x00000006ffe04000,0x000000070a900000)
 Metaspace       used 3822K, capacity 5028K, committed 5120K, reserved 1056768K
  class space    used 418K, capacity 458K, committed 512K, reserved 1048576K

Process finished with exit code 0

这不行啊，没整出来活啊，我得要他溢出啊，他没溢啊，然后我就将循环的数量提升到了2000000000（多少个零自己数去）。然后用Run With VisualVM来运行，在监控的图里面去看元数据区里面的内存占用效果。结果跑了好长的时间，分配 的10M元数据区的内存也还是没溢出(这里书上要求是设置5M的，但估计是因为我的系统和jdk都是64位的，所以IDE提示5M内存太小，然后我试着的结果是最小10M)。

然后就想试试1.7是什么效果，因为电脑只装了1.8，所以就去官网去下载jdk1.7，结果，好家伙，jdk1.7不提供下载了，官网的大概意思是，jdk1.7只提供给付了支持费的用户下载，还要提单子，于是找了别的下载，安装到电脑上面。jdk1.7百度盘下载链接

Idea上面配置了jdk1.7以后，将demo项目的编译jdk配置为1.7，PermTest类的jre也指定1.7进行运行。

然后再运行项PermTest代码

public class PermTest {

    public static void main(String[] args) {
        int i = 0;
        try {
            for (i = 0; i < 10000000; i++) {
                CglibBean bean = new CglibBean("cn.shutdown.demo.Permtest" + i, new HashMap());
            }
        } catch (Throwable e) {
            System.out.println("total create count" + i);
        } finally {
            System.out.println("total create count" + i);
        }
    }
}

好家伙，按 -XX:PermSize=5m -XX:+PrintGCDetails -XX:MaxPermSize=5m这个参数去执行竟然正常的执行完了。也没有出现永久区溢出的情况。也许是现在的电脑比起作者写书的时候的电脑的性能强悍的太多了？

[GC [PSYoungGen: 66048K->1003K(76800K)] 66048K->1011K(251392K), 0.0021120 secs] [Times: user=0.02 sys=0.00, real=0.00 secs] 
[GC [PSYoungGen: 67051K->576K(76800K)] 67059K->592K(251392K), 0.0020370 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC [PSYoungGen: 66624K->624K(76800K)] 66640K->640K(251392K), 0.0008780 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC [PSYoungGen: 66672K->640K(142848K)] 66688K->656K(317440K), 0.0014140 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[GC [PSYoungGen: 132736K->640K(142848K)] 132752K->656K(317440K), 0.0042810 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[GC [PSYoungGen: 132736K->528K(265216K)] 132752K->552K(439808K), 0.0020670 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC [PSYoungGen: 196752K->320K(265216K)] 196776K->816K(439808K), 0.0026410 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 320K->0K(265216K)] [ParOldGen: 496K->489K(95232K)] 816K->489K(360448K) [PSPermGen: 4095K->4094K(4096K)], 0.0140030 secs] [Times: user=0.03 sys=0.01, real=0.02 secs] 
....略过一部分日志....
Heap
 PSYoungGen      total 563200K, used 5749K [0x00000007aaa80000, 0x00000007cd780000, 0x0000000800000000)
  eden space 562176K, 1% used [0x00000007aaa80000,0x00000007ab01d460,0x00000007ccf80000)
  from space 1024K, 0% used [0x00000007ccf80000,0x00000007ccf80000,0x00000007cd080000)
  to   space 1024K, 0% used [0x00000007cd680000,0x00000007cd680000,0x00000007cd780000)
 ParOldGen       total 1104896K, used 427K [0x0000000700000000, 0x0000000743700000, 0x00000007aaa80000)
  object space 1104896K, 0% used [0x0000000700000000,0x000000070006ae98,0x0000000743700000)
 PSPermGen       total 4096K, used 4094K [0x00000006ffc00000, 0x0000000700000000, 0x0000000700000000)
  object space 4096K, 99% used [0x00000006ffc00000,0x00000006fffffa90,0x0000000700000000)

Process finished with exit code 0

然后我再调小参数，使用-XX:PermSize=3m -XX:+PrintGCDetails -XX:MaxPermSize=1m，然后内存终于溢出了，报出了PermGen space ，这也就是方法区(永久区)溢出了。整活完毕。

[GC [PSYoungGen: 2642K->384K(76800K)] 2642K->384K(251392K), 0.0015940 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 384K->0K(76800K)] [ParOldGen: 0K->182K(122368K)] 384K->182K(199168K) [PSPermGen: 2047K->2046K(2048K)], 0.0079460 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
[GC [PSYoungGen: 1321K->32K(94208K)] 1503K->214K(216576K), 0.0008100 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 32K->0K(94208K)] [ParOldGen: 182K->182K(232448K)] 214K->182K(326656K) [PSPermGen: 2047K->2047K(2048K)], 0.0051070 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
[GC [PSYoungGen: 0K->0K(120832K)] 182K->182K(353280K), 0.0012080 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 0K->0K(120832K)] [ParOldGen: 182K->172K(351744K)] 182K->172K(472576K) [PSPermGen: 2047K->2047K(2048K)], 0.0058910 secs] [Times: user=0.02 sys=0.00, real=0.00 secs] 
[GC [PSYoungGen: 2201K->32K(132608K)] 2374K->204K(484352K), 0.0004310 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [PSYoungGen: 32K->0K(132608K)] [ParOldGen: 172K->172K(537600K)] 204K->172K(670208K) 
....省略部分日志....
Error occurred during initialization of VM
java.lang.OutOfMemoryError: PermGen space
	at sun.misc.Launcher.<init>(Launcher.java:71)
	at sun.misc.Launcher.<clinit>(Launcher.java:57)
	at java.lang.ClassLoader.initSystemClassLoader(ClassLoader.java:1489)
	at java.lang.ClassLoader.getSystemClassLoader(ClassLoader.java:1474)
不与天斗8866
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM虚拟机从入门到实战视频教程.zip
07-12
010-JVM整体架构学习路线(1) 010-JVM整体架构学习路线 011-第二章-class文件结构课程简介 012-class文件的理解 013-class文件的格式 014-大小端模式(1) 014-大小端模式 015-class文件的数据结构 016-class文件基本...
Java虚拟机的基本结构
guye
04-18 1736
本章主要介绍了Java虚拟机的基本结构，其中，对Java堆、Java栈和方法区做了较为完整的说明。同时，也对如何设置Jva虚拟机参数做了简要说明。
JVM（Java 虚拟机）各个组成详细总结
BaiKnow的博客
02-08 2035
JVM（Java 虚拟机） 1.简介 1.1 概述 JVM 是运行操作系统之上，没有和硬件有直接交互，但有可以通过接口调用来与底层操作系统交互。 Java 能够实现一次编译，全平台运行，就是通过 JVM 来实现。通过 JVM 可以让相同的数据类型在不同的系统上运行得到统一的结果。 1.2 组成 程序计数器：线程私有的，是一块很小的内存空间，作为当前线程的行号器，用于记录当前虚拟机正在执行的线程指令地址 虚拟机栈：线程私有的，每个方法执行的时候都会创建一个栈帧，用于存储局部变量表、操作数、动态链接和方法
jvm 虚拟机的组成部分
段远山
04-17 397
1、类加载子系统 ：负责从文件系统或者网络中加载 Class 信息，加载的信息存放在一块称之为方法区的内存空间 2、方法区：存放类信息，常量信息，常量池信息，包括字符串字面量和数字常量等 3、Java 堆：在 java 虚拟机启动的时候建立 java 堆，他是 java 程序最主要的内存工作区域，几乎所有的对象实例都存放在 java 堆中，堆空间是所有线程共享的 4、直接内存：java 的...
jvm整体架构图文详解
bhegi_seg的博客
04-19 3159
今天学习了jvm三大组成部分（jvm类加载器，jvm内存结构，jvm执行引擎）的内存结构，现在把学习笔记总结记录一下，当作复习吧。 1.jvm的概念 JVM(虚拟机)：指以软件的方式模拟具有完整硬件系统功能、运行在一个完全隔离环境中的完整计算机系统 ，是物理机的软件实现。 jvm和VMware，Virtual Box等虚拟机一样，都是运行在操作系统之上的计算机系统。 首先我们来看看jvm的整体架构的划分： 大家在留意内存结构的时候是不是发现，本地方法栈，程序计算器和java栈颜色一样的，而方法区和堆却不
虚拟机的三个级别
kangshuangzhu的博客
09-11 1877
虚拟机有三个级别，分别从硬件层到应用层 硬件虚拟机：一般也被称为抽象机，是在硬件层面抽象出一个主机，可以安装各类型的操作系统，等于虚拟出一套硬件系统。典型代表：VMware，virtualbox 操作系统虚拟机：在操作系统层面重新构写其他操作系统的api，实现操作系统之间的兼容。典型代表：wine 代码运行环境虚拟机：提供一个程序运行时的环境，如java，python，l...
jvm-rs:JVM-RS-Rust上的演示内存安全JVM
05-15
基本思想是仅实现核心JVM，并使用rt.jar （来自OpenJDK）作为其类库。 我的开发环境 Ubuntu 18.04 Java 1.8.0_172 锈1.27.0 获取并构建jvm-rs 确保您的Java版本是1.8.0_172并且已设置JAVA_HOME env git clone ...
大数据工程师学习计划.pdf
12-24
⼤数据⼯程师学习计划 申明：本⽂旨在为普通程序员（Java程序员最佳）提供⼀个⼊门级别的⼤数据技术学习路径，不适⽤于⼤数据⼯程师的进阶学习，也不适⽤ 于零编程基础的同学。 前⾔ ⼀、背景介绍 本⼈⽬前是⼀名⼤...
Learning:我的学习
04-18
Java 虚拟机的学习； JVM 与 Java 概述； JVM 架构模型与生命周期； 类加载子系统； 运行时数据区； 栈 堆 方法区 设计模式； 单例模式 观察者模式 装饰者模式 工厂相关模式（简单工厂，工厂方法，抽象工厂） 生成器...
Java零基础 - Java的可移植性.md
最新发布
08-11
本文介绍了Java的可移植性特点，包括字节码、Java虚拟机（JVM）和跨平台开发。同时，提供了相应的Java示例代码。 内容概要 本文档涵盖以下内容： 字节码的概念和作用 Java虚拟机（JVM）的作用和重要性 跨平台开发...
jvm中方法区和常量池详解_JVM组成结构以及各部分的功能详解
weixin_39927683的博客
12-03 171
前言MySQL文章接近尾声，之后我们还会陆续发一些文章，比如MVCC等等文章，接下来的阶段，我们准备进入JVM、redis等知识点的学习，这个是中高级程序员面试必问知识点，跟着老哥的文章，学好JVM，高薪走起！！！jre、jdk、jvm之间的关系JDK是Java程序员常用的开发包、目的就是用来编译和调试Java程序的。JRE是指Java运行环境，也就是我们的写好的程序必须在JRE才能够运行。JVM...
JVM虚拟机（整体架构、类文件结构）我来了~~~
BASK2311的博客
11-22 330
​ Java诞生在一群懒惰、急躁而傲慢的程序天才之中。​ 1990年12月，Sun的工程师Patrick Naughton被当时糟糕的Sun C++工具折磨的快疯了。他大声抱怨，并威胁要离开Sun转投当时在Steve Jobs领导之下的NeXT公司。领导层为了留住他，给他一个机会，启动了一个叫做Stealth（秘密行动）的项目。​ 随着James Gosling等人的加入，这个项目更名为Green。其目标是使用C++为嵌入式设备开发一种新的基础平台技术，James Gosling本人负责开发一个编辑器。
java面试题jvm_经典面试题|讲一讲JVM的组成
weixin_28709715的博客
02-21 161
经典面试题|讲一讲JVM的组成发布时间：2019-04-10 09:01,浏览次数：1456, 标签：JVMJVM(Java 虚拟机)算是面试必问的问题的了，而但凡问 JVM 一定会问的第一个问题就是：讲一讲 JVM 的组成？那本文就注重讲一下 JVM 的组成。首先来说 JVM 的组成分为，整体组成部分和运行时数据区组成部分，一般开发者关注的和面试官问的都是后者，但本文会详细讲解以上两个组成部分。...
jvm学习(一) java虚拟机组成简介
zhanqq2012的专栏
11-25 689
1.java虚拟机的组成如下图所示 栈：存放基本数据类型(如果是对象就存放对象的指针地址) 以及它自己特有的结构详情参考下面的栈帧模型 堆：存放对象的具体内容 方法区：常量 + 静态变量(包括静态对象，跟栈类似，存放的是对象的指针地址) + 类信息 2.代码 public class Math{ public static void main(String[] args){ Math math = new Math(); i...
JVM虚拟机组成
weixin_43926604的博客
07-23 237
1、Class Loader类加载器        Class Loader类加载器是用来加载Class的。它负责将 Class 的字节码形式转换成内存形式的 Class 对象。字节码可以来自于磁盘文件 .class，也可以是 jar 包里的class，也可以来自远程服务器提供的字节流，字节码的本质就是一个字节数组[]byte...
JVM虚拟机学习--JVM构成
stalin_的博客
09-29 252
JVM虚拟机在运行Java程序时，会把它所管理的内存分成不同的数据区域。这些区域各自有其用途。 这些区域分别是： 程序计数器：一块极小的内存空间，是当前线程所执行的字节码的行号指示器。字节码解释器通过修改程序计数器的值来选取下一条需要执行的字节码指令。需要注意的是，每个线程都有一个程序计数器，它们互不影响，独立存储。 Java虚拟机栈：也是线程私有的，主要存放了局部变量表（基本数据类型，对象...
JVM（一）- 组成部分及详解
qq_34874784的博客
08-07 1362
JVM全称Java Virtual Machine ，Java虚拟机，也就是在计算机上虚拟一个计算机，且运行于内存中。计算机的基本构成：运算器、控制器、存储器、输入和输出设备,JVM也有同样成套的元素。为了达到“一次编译，随处运行”，JVM根据不同的CPU,翻译成不同的机器语言，因此java的命令集随处都可以运行...
JVM一：虚拟机的基本结构
qq_38787653的博客
11-09 158
1）类加载子系统负责从文件系统或者网络中加载Class信息，加载的类信息存放于一块称为方法区的内存空间。除了类的信息外，方法区中可能还会存放运行时常量池信息，包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射）。 2）java堆在虚拟机启动的时候建立，它是java程序最主要的内存工作区域。几乎所有的java对象实例都存放在java堆中。堆空间是所有线程共享...
虚拟机的基本结构
w3045872817的博客
12-07 4737
基本组成：jvm的由堆，java栈，本地栈，pc程序计数器，方法区（java8叫元数据区），直接内存，类加载子系统，垃圾回收系统，执行引擎，如图作用： 类加载子系统：从文件系统或网络中加Class的信息方法区：存储从类加载子系统加载Class的信息，还会存放运行时常量的信息，包括字符串和数据常量java堆：在虚拟机创建时建立，它是java程序主要的内存工作区域，几乎所有对象都存放到这里，堆空间是所有
java虚拟机精讲 pdf
07-26
读者能够学习到JVM执行Java代码的具体流程，了解JVM是如何加载并执行Java类的。 其次，该书重点介绍了JVM的内存管理机制。它详细解释了Java内存模型、堆、栈、方法区等内存结构，以及垃圾回收机制。读者可以了解到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值