【JVM】内存结构

最新推荐文章于 2024-06-22 22:32:15 发布
最新推荐文章于 2024-06-22 22:32:15 发布
阅读量243 收藏 1
点赞数
分类专栏： # JVM相关 文章标签： jvm java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43401592/article/details/127806643
版权

一、程序计数器

在这里插入图片描述

1.1 定义

Program Counter Register 程序计数器（寄存器）：物理上是通过寄存器实现的。寄存器是CPU组件中读取数据最快的一个单元，又因为读取指令地址这个动作是非常频繁的，所以JVM把寄存器当作程序计数器

  • 作用：是记住下一条jvm指令的执行地址
  • 特点
    • 是线程私有的
    • 不会存在内存溢出

1.2 作用

在这里插入图片描述

二、虚拟机栈 -Xss

在这里插入图片描述

2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

  • 虚拟机栈 ：每个线程运行时所需要的内存空间

    • 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

  • 栈帧：每个方法运行时需要的内存

    • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

    在这里插入图片描述

    在这里插入图片描述

2.2 问题辨析

  1. 垃圾回收是否涉及栈内存？

    不需要。因为栈帧内存在每次方法结束后会被弹出栈，即被自动回收掉

  2. 栈内存分配越大越好吗？

    不是。栈内存越大，只能运行更多次的递归方法调用，而不会提高运行效率。反而导致允许的线程数越少，因为物理内存是固定的。

  3. 方法内的局部变量是否线程安全？

    • 不一定

    • 情况一：如果方法内局部变量没有逃离方法的作用访问，它是线程安全的

    • 情况二：如果局部变量引用了对象（方法参数）、或逃离方法的作用范围（作为返回值），需要考虑线程安全

2.3 栈内存溢出案例

  • 栈帧过多导致栈内存溢出：

    • 递归调用没有正确的结束条件

      public class StackOverFlow {
    private static int count=0;
    public static void main(String[] args) {
        try {
            test();
        } catch (Throwable e) {
            e.printStackTrace(); //java.lang.StackOverflowError
            System.out.println(count); //23010  ——> -Xss256k ——> 3639
        }
    }
    public static void test(){
        count++;
        test();
    }
}

    • 递归Josn转换循环依赖：@JsonIgnore

  • 栈帧过大导致栈内存溢出

2.4 线程运行诊断案例

  • 案例1： cpu 占用过高

    1. 定位进程：top

    2. 定位线程：ps H -eo pid,tid,%cpu | grep 进程id

    3. 定位线程代码：jstack 进程id

      根据线程id （换算为16进制）找到有问题的线程，进一步定位到问题代码的源码行号

  • 案例2：产生死锁，程序运行很长时间没有结果。nohup java cn.itcast.jvm.t1.Demo1_3 &

    1. 查看问题：jstack 进程id
    2. 找到问题：结尾的死锁信息
    3. 定位代码

三、本地方法栈

  • 本地方法栈：为本地方法调用提供的内存空间
  • 本地方法：不是由java代码编写的方法。
    • 由C或C++编写，与操作系统更底层的API打交道
    • java代码通过本地方法间接调用底层功能。

在这里插入图片描述

四、堆 -Xmx

在这里插入图片描述

4.1 定义

Heap 堆

  • 通过 new 关键字创建的对象都会使用堆内存
  • 特点：
    • 它是线程共享的，堆中对象都需要考虑线程安全的问题
    • 有垃圾回收机制

4.2 堆内存溢出案例

  1. 不断产生对象，且这些新对象仍然有对象在使用
  2. 且使用的对象未被回收
public class OutOfMemoryTest {
    public static void main(String[] args) {
        try {
            List<String> list =new ArrayList<>();
            String str="hello";
            int count=0;
            while (true){
                str+=str;   //java.lang.OutOfMemoryError: Java heap space
                list.add(str);
                count++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}

4.3 堆内存诊断案例

  • jps 工具：查看当前系统中有哪些 java 进程
  • jmap 工具：查看进程某一时刻的堆内存占用情况
  • jconsole 工具：图形化的多功能的实时监测工具（堆内存、线程、CPU）
  • jvisualvm 工具：与 jconsole 相似。特点是可以转储堆信息

案例1：创建对象前—>创建对象后—>回收对象后

public class JconsoleTest {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("创建对象前");
        Thread.sleep(20000);
        byte[] array=new byte[1024*1024*10];
        System.out.println("创建对象后");
        Thread.sleep(10000);
        array=null;
        System.gc();
        System.out.println("垃圾回收后");
        Thread.sleep(30000);
    }
}

#创建对象前：可用 27.9m
PS F:\software\IDEA\JavaProjects\JvmTest> jps
12832 RemoteMavenServer36
13264 Launcher
19044 Jps
15960
13564 JconsoleTest
PS F:\software\IDEA\JavaProjects\JvmTest> jmap -heap 13564
...
Eden Space:
   capacity = 34078720 (32.5MB)
   used     = 4771328 (4.55029296875MB)
   free     = 29307392 (27.94970703125MB)
   14.000901442307692% used
#创建对象后：可用 17.9m
PS F:\software\IDEA\JavaProjects\JvmTest> jmap -heap 13564
...
Eden Space:
   capacity = 34078720 (32.5MB)
   used     = 15257104 (14.550308227539062MB)
   free     = 18821616 (17.949691772460938MB)
   44.77017916165865% used
#垃圾回收后：可用 31.8m
PS F:\software\IDEA\JavaProjects\JvmTest> jmap -heap 13564
...
Eden Space:
   capacity = 34078720 (32.5MB)
   used     = 681592 (0.6500167846679688MB)
   free     = 33397128 (31.84998321533203MB)
   2.0000516451322117% used

PS F:\software\IDEA\JavaProjects\JvmTest> jconsole

在这里插入图片描述

案例2：垃圾回收后，内存占用仍然很高

public class JvitualvmTest {
    public static void main(String[] args) throws InterruptedException {
        List<Studnet> list=new ArrayList();
        for (int i = 0; i < 200; i++) {
            list.add(new Studnet());
        }
        Thread.sleep(1000000000000L);
    }
}
class Studnet{
    private byte[] big=new byte[1024*1024];
}

PS F:\software\IDEA\JavaProjects\JvmTest> jconsole

在这里插入图片描述

PS F:\software\IDEA\JavaProjects\JvmTest> jvisualvm

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

五、方法区 -XX:Max…

在这里插入图片描述

5.1 定义

在这里插入图片描述

  1. 线程共享
  2. 存储类的结构：运行时常量池、字段、方法数据、方法和构造函数的代码（包括在类、实例初始化、接口初始化中使用的特殊方法）
  3. 在虚拟机启动时创建
  4. 在逻辑上是堆的一部分，但是没有强制方法区的位置。不同虚拟机厂商的实现不同。
    • Hostpot在 jdk8 前：实现为永久代，这时的永久代便是作为堆内存的一部分
    • Hostpot在 jdk8 时：实现为元空间，这时的元空间使用的是操作系统的内存
  5. 方法区申请内存不足时会报错

5.2 组成

方法区的位置

  • jdk6、jdk7：堆内存（永久代）
  • jdk8：操作系统内存（元空间）

字符串常量池的位置：

  • jdk 6：方法区（永久代）
  • jdk 7、jdk8： 堆

在这里插入图片描述

在这里插入图片描述

5.3 方法区内存溢出案例

场景

  • spring：代理技术广泛应用 CGlib(ClassWriter) 动态生成类的字节码
  • mybatis：应用 CGlib(ClassWriter) 动态生成Map接口实现类

1.8 以前：导致永久代内存溢出

  • 永久代内存溢出：Exception in thread “main” java.lang.OutOfMemoryError: PermGen space
  • 永久代内存大小设置：-XX:MaxPermSize=4m
public class OutOfMemoryTest extends ClassLoader{
    public static void main(String[] args) {
        int j=0;
        try {
            OutOfMemoryTest classLoader=new OutOfMemoryTest();
            for (int i = 0; i < 100000; i++,j++) {
                //作用：生成类且获得类的二进制字节码
                ClassWriter cw=new ClassWriter(0);
                //版本号，public，类名，包名，父类，接口
                cw.visit(Opcodes.V1_6,Opcodes.ACC_PUBLIC,"Class"+i,null,"java/lang/Object",null);
                //获得类的字节数组
                byte[] code=cw.toByteArray();
                //将该类加载到方法区
                classLoader.defineClass("Class"+i,code,0,code.length);
            }
        } finally{
            System.out.println(j);
        }
    }
}

19317
Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClassCond(ClassLoader.java:631)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:615)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:465)
	at org.example.java.methodArea.OutOfMemoryTest.main(OutOfMemoryTest.java from InputFileObject:24)

1.8 之后：导致元空间内存溢出

  • 元空间内存溢出：Error occurred during initialization of VM MaxMetaspaceSize is too small.
  • 元空间内存大小设置：-XX:MaxMetaspaceSize=8m
public class OutOfMemoryTest extends ClassLoader{
    public static void main(String[] args) {
        int j=0;
        try {
            OutOfMemoryTest classLoader=new OutOfMemoryTest();
            for (int i = 0; i < 100000; i++,j++) {
                //作用：生成类且获得类的二进制字节码
                ClassWriter cw=new ClassWriter(0);
                //版本号，public，类名，包名，父类，接口
                cw.visit(Opcodes.V1_8,Opcodes.ACC_PUBLIC,"Class"+i,null,"java/lang/Object",null);
                //获得类的字节数组
                byte[] code=cw.toByteArray();
                //将该类加载到方法区
                classLoader.defineClass("Class"+i,code,0,code.length);
            }
        } catch (Throwable t){
            t.printStackTrace();
        } finally{
            System.out.println(j);
        }
    }
}

Error occurred during initialization of VM
MaxMetaspaceSize is too small.

5.4 运行时常量池

  • 常量池：
    • 就是一张表
    • 虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量 等信息
  • 运行时常量池：
    • 常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量 池，并把里面的符号地址变为真实地址

反编译字节码文件

/**
 * 二进制字节码：类基本信息、常量池、类方法定义、虚拟机指令
 */
public class HelloWord {
    public static void main(String[] args) {
        System.out.println("Hello word!");
    }
}

PS F:\software\IDEA\JavaProjects\JvmTest\target\classes\org\example\java\methodArea\changleiPool> javap -v HelloWord
警告: 二进制文件HelloWord包含org.example.java.methodArea.changleiPool.HelloWord
    
//----------------------类基本信息
Classfile /F:/software/IDEA/JavaProjects/JvmTest/target/classes/org/example/java/methodArea/changleiPool/HelloWord.cla
ss
  Last modified 2022-11-7; size 612 bytes
  MD5 checksum 8ac0f4a48d54619bddaec8c500042064
  Compiled from "HelloWord.java"
public class org.example.java.methodArea.changleiPool.HelloWord
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
//----------------------常量池
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // Hello word!
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // org/example/java/methodArea/changleiPool/HelloWord
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lorg/example/java/methodArea/changleiPool/HelloWord;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWord.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               Hello word!
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               org/example/java/methodArea/changleiPool/HelloWord
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
//----------------------类方法定义
{
  public org.example.java.methodArea.changleiPool.HelloWord();//构造方法
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lorg/example/java/methodArea/changleiPool/HelloWord;

  public static void main(java.lang.String[]);//main方法
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String Hello word!
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWord.java"

六、字符串常量池

6.1 特性

  • 常量池中的字符串仅是符号，第一次用到时才变为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理
    • StringBuilder（1.8）：s1+s2
    • 编译期优化 ：“a”+“b”
  • 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池
    • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串 池中的对象返回
    • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份， 放入串池， 会把串池中的对象返回

6.2 特性面试题

1）字符串拼接

public class InterviewQuestions {
    public static void main(String[] args) {
        //1.常量池中的信息，都会被加载到运行时常量池中
        //2.这时的a b ab 都是运行时常量池中的符号，还没有变为 java 字符串对象

        String s1="a";
        String s2="b";
        String s3="ab";
        //3.在运行时常量池表中查询出 a符号、b符号、ab符号，然后在字符串常量池中查找对象，找不到再创建对象：StringTable[]{"a","b","ab"}
        String s4=s1+s2;
        //4.在局部变量表中加载到 "a"和"b" ，再创建对象：new String("ab")
        String s5="a"+"b";
        //5.在编译期间优化，结果已经在编译期确定为 ab符号，然后在字符串常量池中查找对象，找不到再创建对象：StringTable[]{"a","b","ab"}
        System.out.println("s3==s4:"+(s3==s4));//false
        System.out.println("s3==s5:"+(s3==s5));//true
        System.out.println("s4==s5:"+(s4==s5));//false
    }
}

在这里插入图片描述

2）intern()

将堆内存中的字符串对象添加到字符串常量池中

  • 字符串常量池中已存在
String s3 = "ab";
String s4 = new String("ab");
String s6 = s4.intern();

System.out.println(s3 == s6);//true：返回字符串常量池中的对象（即s3的引用）
  • 字符串常量池中不存在
String x2 = new String("c") + new String("d");
x2.intern();
String x1 = "cd";

System.out.println(x1 == x2);//jdk1.8：true。将堆内存中的对象添加到字符串常量池并返回
System.out.println(x1 == x2);//jdk1.6：false。重新创建对象添加到字符串常量池并返回新对象

6.3 位置求证案例

jdk1.6：放在方法区（永久代）

  • 放在方法区时只有当 fullGC 时才会触发垃圾回收
  • 导致 StringTable 回收效率不高。但是 StringTable 使用频繁，如果回收效率不高将占用大量内存，很容易导致永久代内存不足

在这里插入图片描述

在这里插入图片描述

jdk1.8

  • 只需要 Minor GC 就会触发 StringTable 的垃圾回收，大大减轻字符串对内存的占用

在这里插入图片描述

在这里插入图片描述

6.4 垃圾回收案例

  • 字符串常量池参与垃圾回收

未添加前：1700+ 个

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public static void main(String[] args) {
    int i=0;
    try {
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("添加到字符串常量池个数："+i);
    }
}

#垃圾回收信息：无
#打印信息：
添加到字符串常量池个数：0
#字符串常量池信息：未添加前存在1757个字符串
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :      1757 =     42168 bytes, avg  24.000
Number of literals      :      1757 =    157720 bytes, avg  89.767
Total footprint         :           =    679992 bytes

添加10000个：应该有 11700+ 个，但只保留 2800+ 个

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public static void main(String[] args) {
    int i=0;
    try {
        for (int j = 0; j < 10000; j++) {
            String.valueOf(j).intern();
            i++;
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("添加到字符串常量池个数："+i);
    }
}

#垃圾回收信息：
[GC (Allocation Failure) [PSYoungGen: 2048K->488K(2560K)] 2048K->688K(9728K), 0.0010454 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
#打印信息：
添加到字符串常量池个数：10000
#字符串常量池信息：应该有 11700+ 个，但只保留 2800+ 个
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :      2867 =     68808 bytes, avg  24.000
Number of literals      :      2867 =    211320 bytes, avg  73.708
Total footprint         :           =    760232 bytes

6.5 性能调优案例

6.5.1 调整桶个数

/**
 * -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
 */
public static void main(String[] args) {
    Long start=System.nanoTime();
    for (int i = 0; i < 5000000; i++) {
        String.valueOf(i).intern();
    }
    System.out.println("cost："+(System.nanoTime()-start)/1000000+" ms");
}

不调整

  • 桶数量为：60013
  • 耗时：4 s
#耗时
cost：4285 ms
#字符串常量池信息：桶数量为60013
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :   1422564 =  34141536 bytes, avg  24.000
Number of literals      :   1422564 =  79723080 bytes, avg  56.042
Total footprint         :           = 114344720 bytes

调小

  • 桶数量为：1009
  • 耗时：2分钟
#耗时
cost：124604 ms
#字符串常量池信息：桶数量为1009
StringTable statistics:
Number of buckets       :      1009 =      8072 bytes, avg   8.000
Number of entries       :    249555 =   5989320 bytes, avg  24.000
Number of literals      :    249555 =  14034576 bytes, avg  56.238
Total footprint         :           =  20031968 bytes

调大

  • 桶数量为：200000
  • 耗时：2 s
#耗时
cost：2252 ms
#字符串常量池信息：桶数量为200000
StringTable statistics:
Number of buckets       :    200000 =   1600000 bytes, avg   8.000
Number of entries       :   1422584 =  34142016 bytes, avg  24.000
Number of literals      :   1422584 =  79724200 bytes, avg  56.042
Total footprint         :           = 115466216 bytes

6.5.2 考虑入池

不入池

/**
 * -XX:StringTableSize=200000
 * 不入池
 */
public static void main(String[] args) throws IOException {
    List<String> list=new ArrayList<>();
    System.in.read();
    for (int i = 0; i < 10; i++) {
        Long start=System.nanoTime();
        for (int j = 0; j < 500000; j++) {
            list.add(String.valueOf(j));
        }
        System.out.println("cost："+(System.nanoTime()-start)/1000000+" ms");
    }
    System.in.read();
}

在这里插入图片描述

在这里插入图片描述

入池

/**
 * -XX:StringTableSize=200000
 * 入池
 */
public static void main(String[] args) throws IOException {
    List<String> list=new ArrayList<>();
    System.in.read();
    for (int i = 0; i < 10; i++) {
        Long start=System.nanoTime();
        for (int j = 0; j < 500000; j++) {
            list.add(String.valueOf(j).intern());
        }
        System.out.println("cost："+(System.nanoTime()-start)/1000000+" ms");
    }
    System.in.read();
}

在这里插入图片描述

在这里插入图片描述

七、直接内存

在这里插入图片描述

7.1 定义

Direct Memory

  • 常见于 NIO 操作时，用于数据缓冲区

  • 分配回收成本较高，但读写性能高

  • 不受 JVM 内存回收管理

    //内存溢出：java.lang.OutOfMemoryError: Direct buffer memory
public static void main(String[] args) {
    List<ByteBuffer> list=new ArrayList<>();
    int i=0;
    try {
        while(true){
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * 100);
            list.add(buffer);
            i++;
        }
    } finally {
        System.out.println(i); //17
    }
}

7.2 分配

  • 使用了 **Unsafe 对象 **完成直接内存的分配回收
//分配，返回地址
Long base=unsafe.allocateMemory(1024*1024*1024);
unsafe.setMemory(base, 1024*1024*1024, (byte) 0);

在这里插入图片描述

7.3 回收原理

  • 注意与建议：不依赖gc的情况下，可以使用 unsafe 手动管理直接内存

  • ByteBuffer 的实现类内部，使用了 **Cleaner （虚引用）**来监测 ByteBuffer 对象，一旦 ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调 用 freeMemory 来释放直接内存

    //释放内存
unsafe.freeMemory(base);

随着gc的调用而回收？

在这里插入图片描述

释放原理

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}
	//调用 直接缓存 的构造方法
    DirectByteBuffer(int cap) {
        //...
        try {
            //1.分配内存
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        //2.设置内存
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        //3.释放内存：当Cleaner关联的 this对象 被回收时，触发 clean()
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }
		//3.1 触发回调对象的run方法
		public void clean() {
    	    if (remove(this)) {
    	        try {
                    //3.1 调用
    	            this.thunk.run();
    	        } catch (final Throwable var2) {}
    	    }
    	}
			//3.2 Cleaner中的 new Deallocator 回调任务
        	public void run() {
        	    //...
                //释放直接内存
        	    unsafe.freeMemory(address);
        	    address = 0;
        	    Bits.unreserveMemory(size, capacity);
        	}
愿你满腹经纶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JVM内存模型和结构
Liarboy
08-26 3031
在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；方法区的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收“成绩”比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是回收确实是有必要的。...
JVM内存结构
jike11231的博客
08-19 1490
JVM内存结构布局
JVM专题六：JVM的内存模型
最新发布
Jeremy程序员
06-22 2万+
前面我们通过等内容了解到了如何从我们编写的一个.Java 文件最终加载到JVM里的，今天我们就来剖析一下这个Java的‘中介平台’JVM里面到底长成啥样。
JVM之内存结构详解
热门推荐
程序新视界
10-18 2万+
对于开发人员来说，如果不了解Java的JVM，那真的是很难写得一手好代码，很难查得一手好bug。同时，JVM也是面试环节的中重灾区。今天开始，《JVM详解》系列开启，带大家深入了解JVM相关知识。 我们不能为了面试而面试，但是学习会这些核心知识你必定会成为面试与工作中“最亮的一颗星”。本系列首发于微信公众号“程序新视界”。下面，开启我们的第一篇文章《JVM之内存结构详解》。 学习也是要讲究方式方法...
JVM的内存结构详解「重点篇」
ldwtxwh的专栏
12-02 1058
另外一种退出方式是，在方法执行过程中遇到了异常，并且这个异常没有在方法体内得到处理，无论是Java虚拟机内部产生的异常，还是代码中使用athrow字节码指令产生的异常，只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，这种退出方式称为异常完成出口(Abrupt Method Invocation Completion)。当一个方法刚刚执行的时候，这个方法的操作数栈是空的，在方法执行的过程中，会有各种字节码指向操作数栈中写入和提取值，也就是入栈与出栈操作。6、虚拟机栈是一个后入先出的栈。
JVM 内存结构
永无止境
10-20 281
运行时数据区 下图是 JVM 整体架构，中间部分就是 Java 虚拟机定义的各种运行时数据区域。 线程私有：程序计数器、虚拟机栈、本地方法栈 线程共享：堆、方法区、堆外内存（永久代或元空间、代码缓存） 程序计数器 程序计数器是一块较小的内存空间，可以看作是当前线程所执行的字节码的行号指示器。字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完。 另外，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序
JVM内存结构划分实例解析
08-25
JVM内存结构划分实例解析 JVM 内存结构划分实例解析是 Java 虚拟机（JVM）中的一种内存管理机制，它将内存划分为不同的区域，每个区域都有其特点和作用。下面是 JVM 内存结构划分实例解析的详细介绍。 程序计数器 ...
JVM内存结构相关知识解析
08-25
"JVM内存结构相关知识解析" JVM 内存结构是指 Java 虚拟机定义了若干种程序运行期间会使用的运行时数据区，其中有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁，另一些则与线程一一对应，随着线程的开始而...
笔记 — JVM内存结构
12-21
理解JVM内存结构对于优化Java应用的性能至关重要。 1. **方法区**： - 方法区是JVM内存中的一个重要区域，它存储了已经被加载的类信息，包括常量、静态变量以及即时编译器（JIT）编译后的代码。所有线程共享此区域...
JVM内存结构笔记.rar
03-21
总之，深入理解JVM内存结构及其管理机制，有助于我们编写更高效、更稳定的Java程序，并能有效地处理内存相关问题。这份"JVM内存结构笔记"将详细阐述这些内容，是学习和研究JVM内存管理的重要参考资料。
java基础知识总结之JVM内存管理（一）
weixin_39202006的博客
08-01 239
我们首先了解下什么是JVM。 JVM（Java Virtual Machine），简而言之就是java程序的运行环境（java二进制字节码的运行环境）。以下表格比较了JVM、JRE和JDK之间的关系： JVM Java Virtual Machine JRE JVM+基础类库 JDK JVM+基础类库+编译工具 开发javase程序 JDK+IDE工
JVM的内存结构
天青色 等烟雨的博客
11-10 448
因为Java虚拟机是多线程的，多线程是通过线程流切换、分配处理器执行时间的方式来完成的，在任何一个确定的时间，一个处理器都只会执行一条线程种的指令，因此，为了线程切换后能回到正确的执行位置，每条线程都需要有一个独立的程序计数器，各线程之间计数器互不影响，独立储存，也就是所谓的。Java在执行Java程序时，会把他所管理的内存划分位若干个不同的数据区域，这些区域都有各自的用途、创建和销毁的时间，有的区域会随着虚拟机进程的启动而一直存在，有些区域则是依赖用户线程的启动和结束而建立和销毁的。
启动tomcat，报“error occurred during initaliztion of VM Incompatible minimum and maximum heap sizes spe”
Eric_YS的博客
07-23 8216
1、前言 This's a so fantastic morning! 如此神奇（guǐ yì）的一上午！刚解决完启动eclipse的问题，紧接着tomcat也无法启动！最重要的是，上周环境没有问题！闲话不说了，此前也遇到过内存溢出的问题，所以首先考虑的是tomcat的运行环境，jdk也需要配置VM参数。 2、问题描述： 启动tomcat，报“error occurred during i...
JVM初识-JVM内存结构
thefristking的博客
05-19 2313
初识JVM，主要介绍JVM的内存结构:堆、栈、方法区、程序计数器等，还有常量池等介绍，以及一些经典例题，后续还有进阶
JVM内存结构阐述
m0_60264772的博客
12-15 3397
内存结构 程序计数器 作用，是记住下一条jvm指令的执行地址 是线程私有的 在线程上下文切换的过程中需要记录到下一条要执行的指令的地址，等到线程再次被调度到执行的时候，还是根据该线程的程序计数器，来找到下一条要执行的指令的地址 每个线程都有自己独有的程序计数器 唯一一个内存不会溢出的 随着线程创建而创建，随着线程销毁而销毁 栈 栈可以说是虚拟机栈中的局部变量表 局部变量表中存放了编译期可知的各种基本数据类型，对象引用（不等于对象本身，可能是一
JVM之内存结构图文详解
heihei2017的博客
11-04 197
JVM内存结构 java虚拟机在执行程序的过程中会将内存划分为不同的数据区域，看一下下图。 第一，JVM分为五个区域：虚拟机栈、本地方法栈、方法区、堆、程序计数器。PS：大家不要排斥英语，此处用英文记忆反而更容易理解。 第二，JVM五个区中虚拟机栈、本地方法栈、程序计数器为线程私有，方法区和堆为线程共享区。图中已经用颜色区分，绿色表示“通行”，橘黄色表示停一停（需等待）。 第三，...
Java虚拟机--内存结构
weixin_39124328的博客
07-30 2962
1.JVM是什么? 　　JVM:Java Virtual Mechinal(Java虚拟机).它是一个虚构的计算机,是通过在实际的计算机上模拟各种功能来实现的。JVM的主要工作是解释自己的指令集（字节码，如java源码编译成class文件在虚拟机上运行）并映射到本地的CPU指令集或OS的系统调用。Java语言跨平台的本质就是不同的操作系统使用不同的JVM映射规则，使其与操作系统无关，从而实现跨平...
JVM 内存模型和 JVM 内存结构的区别？
06-02
JVM 内存模型和 JVM 内存结构是两个概念。 JVM 内存结构定义了 Java 虚拟机在运行时内存的组织方式。它将内存划分为不同的区域，包括堆、栈、方法区、程序计数器、本地方法栈等。每个区域都有不同的作用，用于存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

愿你满腹经纶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值