JVM(一):内存结构


JVM(一):内存结构

一、JVM概述

定义

Java Virtual Machine,JAVA程序的运行环境(JAVA二进制字节码的运行环境)

好处

  • 一次编写,到处运行
  • 自动内存管理,垃圾回收机制
  • 数组下标越界检查

JVM JRE JDK的比较

img

二、内存结构

整体结构

img

程序计数器PC

  1. 定义:Program Counter Register 程序计数器(寄存器)
  2. 作用:==记录JVM中要执行的下一条指令的地址==
  3. 特点:
    • 线程私有
      • CPU会为每个线程分配时间片,当当前线程的时间片使用完以后,CPU就会去执行另一个线程中的代码
      • 程序计数器是每个线程私有的,当另一个线程的时间片用完,又返回来执行当前线程的代码时,通过程序计数器可以知道应该执行哪一句指令
    • 不会存在内存溢出

虚拟机栈

  1. 定义:

    • 每个线程运行所需要的内存空间称为虚拟机栈
    • 每个栈由多个栈帧组成,对应着每次调用方法时所占用的内存;
    • 每个线程只能有一个活动栈帧,对应着当前正在执行的方法,会处于虚拟机栈的栈顶
  2. 调整栈空间大小:

    -Xss空间大小
    -Xss8M
  3. 实例:

    image-20210828165515023
  4. 常见问题辨析:

    • 垃圾回收是否涉及栈内存?

      • 不需要,因为虚拟机栈中是由一个个栈帧组成的,在方法执行完毕后,对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
    • 栈内存的分配越大越好吗?

      • 不是。因为物理内存是一定的,栈空间越大,会导致线程数越少。栈空间越大,也并不会让程序更快,只是有更大的栈空间,能让你做更多次的递归调用。
    • 方法内的局部变量是否是线程安全的?

      • 如果方法内局部变量没有逃离方法的作用范围,则是线程安全的;
      • 如果如果局部变量引用了对象,并逃离了方法的作用范围,则需要考虑线程安全问题。

      示例:

      image-20210828170729020image-20210828170618242

  5. 栈内存溢出Java.lang.stackOverflowError

    • 原因:
      • 虚拟机栈中,栈帧过多(无限递归,或互相调用、无限循环)
      • 每个栈帧所占用过大
  6. 线程运行诊断

    以CUP占用过高为例:

    • Linux环境下运行某些程序的时候,可能导致CPU的占用过高,这时需要定位占用CPU过高的线程
      • top命令:查看是哪个进程占用CPU过高
      • ps H -eo pid, tid(线程id), %cpu | grep 刚才通过top查到的进程号 :通过ps命令进一步查看是哪个线程占用CPU过高
      • jstack 进程id :通过查看进程中的线程的nid,刚才通过ps命令看到的tid来对比定位问题代码,注意jstack查找出的线程id是16进制的,需要转换。

本地方法栈

native 本地方法

本地方法栈,给本地方法的运行提供一个空间。jvm类并不是所有的方法都是java代码编写的,有些底层的方法就是通过c/c++实现的。而java可以调用这些底层方法来完成一些功能。在java调用这些底层方法时,就是运行在本地方法栈中。

  1. 定义:通过new关键字创建的对象都会被放在堆内存

  2. 特点:

    • 所有线程共享,堆内存中的对象都需要考虑线程安全问题
    • 有垃圾回收机制
  3. 调整堆空间大小

    -Xmx空间大小
    -Xmx4G
  4. 堆内存溢出:java.lang.OutofMemoryError :java heap space.

  5. 堆内存诊断

    1. jps工具
      • 查看当前系统中有哪些java进程
    2. jmap工具
      • 查看某一时刻堆内存占用情况
      • jhsdb jmap --heap --pid 进程id
    3. jconsole工具
      • 图形界面的,多功能的监测工具,可以连续监测
    4. 堆内存调整指令参数
      • -Xmx容量大小

方法区

方法区是一种规范,永久代元空间都只是它的实现。

  1. 结构

    img
  2. 内存溢出

    • JDK1.8前,会出现永久代(在方法区中)溢出;
    • JDK1.8侯,会出现元空间(在本地内存中)溢出。
    • 调整元空间大小:-XX:MaxMetaspaceSize=8m
  3. 常量池和运行时常量池

    • 常量池:就是一张表,虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
    • 运行时常量池:常量池是*.class文件中的,当该类被加载以后,它的常量池信息就会放入运行时常量池,并把里面的符号地址变为真实地址
  4. 通过反编译来查看类的信息

    • 进入java目录下,用javac编译java文件,如:javac User.java,生成二进制字节码:User.class文件;
    • 使用javap反汇编工具查看字节码文件,如:javap -v User.class,之后就可以看到字节码文件的详细内容了。
  5. 查看字节码文件示例:

    • 类的基本信息

      image-20220706195445216
    • 常量池

      image-20220706195532325
    • 虚拟机中执行编译的方法(**#号的内容需要在常量池中查找**,根据#及数字,可查到使用的内容)

      image-20220706195705470
  6. 串池StringTable:用来放字符串对象且里面的元素不重复

    • 特征:

      • 常量池中的字符串仅是符号(类加载时加入串池),只有在被用到时才会转化为对象(懒加载);
      • 利用串池的机制,来避免重复创建字符串对象;
      • 字符串变量拼接的原理是StringBuilder;
      • 字符串常量拼接的原理是编译器优化;
      • 可以使用intern方法,主动将串池中还没有的字符串对象放入串池中;
      • 注意:无论是串池还是堆里面的字符串,都是对象。
    • 串池使用示例:

      • 对于以下代码:

        public class StringTableStudy {
        	public static void main(String[] args) {
        		String a = "a"; 
        		String b = "b";
        		String ab = "ab";
        	}
        }
        
        // 常量池中的信息,都会被加载到运行时常量池中,
        // 这时 a b ab 都是常量池中的符号,还没有变为 java 字符串对象
        // ldc #2 会把 a 符号变为 "a" 字符串对象
        // ldc #3 会把 b 符号变为 "b" 字符串对象
        // ldc #4 会把 ab 符号变为 "ab" 字符串对象
        // 最终StringTable [“a”, “b”, “ab”]
        
        //字节码文件内容为
        0: ldc           #2                  // String a
        2: astore_1
        3: ldc           #3                  // String b
        5: astore_2
        6: ldc           #4                  // String ab
        8: astore_3
        9: return

        字符串对象的创建都是懒惰的,只有当运行到那一行字符串且在串池中不存在的时候(如 ldc #2)时,该字符串才会被创建并放入串池中。

      • 对于字符串拼接代码:

        public class StringTableStudy {
        	public static void main(String[] args) {
        		String a = "a";
        		String b = "b";
        		String ab = "ab";
        		//拼接字符串对象来创建新的字符串
        		String ab2 = a+b; 
                 //使用拼接字符串的方法创建字符串
        		String ab3 = "a" + "b";
                
                //结果为false,因为ab是存在于串池之中,ab2是由StringBuffer的toString方法所返回的一个对象,
                //存在于堆内存之中,不是同一个对象
        		System.out.println(ab == ab2); //fasle
                
                //结果为true,因为ab存在于串池之中,ab3直接引用串池中的 ab,是同一个对象
        		System.out.println(ab == ab3); //true
        	}
        }
        
        
        //字节码文件
         	  Code:
              stack=2, locals=6, args_size=1
                 0: ldc           #2                  // String a
                 2: astore_1
                 3: ldc           #3                  // String b
                 5: astore_2
                 6: ldc           #4                  // String ab
                 8: astore_3
                 9: new           #5                  // class java/lang/StringBuilder
                12: dup
                13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
                16: aload_1
                // 使用 StringBuilder 来实现字符串拼接
                17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
                20: aload_2
                21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
                24: invokevirtual #8            // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
                27: astore        4
                //ab3初始化时直接从串池中获取字符串
                29: ldc           #4                  // String ab
                31: astore        5
                33: return

        由此可见:

        • 通过拼接的方式来创建字符串的过程是:StringBuilder().append(“a”).append(“b”).toString()最后的toString方法的返回值是一个新的字符串,但字符串的和拼接的字符串一致,但是两个不同的字符串,一个存在于串池之中,一个存在于堆内存之中
        • 使用拼接字符串常量的方法来创建新的字符串时,因为内容是常量,javac在编译期会进行优化,结果已在编译期确定为ab,而创建ab的时候已经在串池中放入了“ab”,所以ab3直接从串池中获取值,所以进行的操作和 ab = “ab” 一致;
        • 使用拼接字符串变量的方法来创建新的字符串时,因为内容是变量,只能在运行期确定它的值,所以需要使用StringBuilder来创建
    • intern方法:调用字符串对象的intern方法,会将该字符串对象尝试放入到串池中

      • JDK1.8中:如果串池中没有该字符串对象,则放入成功;如果有该字符串对象,则放入失败,无论放入是否成功,都会返回串池中的字符串对象,此时如果调用intern方法成功,堆内存与串池中的字符串对象是同一个对象;如果失败,则不是同一个对象。
      • JDK1.6中:如果串池中没有该字符串对象,会将该字符串对象复制一份,再放入到串池中;如果有该字符串对象,则放入失败,无论放入是否成功,都会返回串池中的字符串对象,此时无论调用intern方法成功与否,串池中的字符串对象和堆内存中的字符串对象都不是同一个对象
  7. String Table位置

    • 在1.6之前。StringTable在方法区永久代中,但是放在这之中,虚拟机只会在full GC时才会对StringTable进行垃圾回收。但是其实StringTable的操作是非常频繁的,如果没有即使进行垃圾回收,容易造成永久代空间不足。

    • 在1.8后,StringTable放在了堆中,使其垃圾回收的效率更高。

  8. StringTable垃圾回收

    StringTable在内存紧张时,会清理一些未引用的字符串常量。

  9. StringTable调优

    • 添加桶的个数:StringTable的数据结构实现是哈希表,调优即对哈希表的桶的个数的调整,桶的个数越多时,哈希表查找更快。使用:-XX:StringTableSize=xxxx调整桶的个数。
    • 使用intern方法:可以通过intern方法减少重复入池

直接内存(DirectBuffer)

  1. 特征:

    • 属于操作系统,常见于NIO操作时,用于数据缓冲区
    • 分配回收成本较高,但读写性能高
    • 不受JVM内存回收管理
  2. 直接内存是操作系统和Java代码都可以访问的一块区域,无需将代码从系统内存复制到Java堆内存,从而提高了效率,如下图两种文件读取方式的流程:

    正常流程:

    img

    使用直接内存:

    img
  3. 申请与释放原理

    直接内存的申请使用ByteBuffer申请,回收不是通过JVM的垃圾回收来释放的,而是通过unsafe.freeMemory来手动释放

    相关代码如下:

    //通过ByteBuffer申请1M的直接内存
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);
    
    //allocateDirect的实现
    public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
    }

    DirectByteBuffer类(在此类中用unsafe.allocateMemory申请内存):

    DirectByteBuffer(int cap) {   // package-private
       
        super(-1, 0, cap, cap);
        boolean pa = VM.isDirectMemoryPageAligned();
        int ps = Bits.pageSize();
        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
        Bits.reserveMemory(size, cap);
    
        long base = 0;
        try {
            //申请内存
            base = unsafe.allocateMemory(size); 
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        //通过虚引用,来实现直接内存的释放,this为虚引用的实际对象
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); 
        att = null;
    }

    这里调用了一个Cleaner的create方法,且后台线程还会对虚引用的对象监测,如果虚引用的实际对象(这里是DirectByteBuffer)被回收以后,就会调用Cleaner的clean方法,通过unsafe.freeMemory,来清除直接内存中占用的内存。

    public void clean() {
        if (remove(this)) {
            try {
                //调用run方法
                this.thunk.run(); 
            } catch (final Throwable var2) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        if (System.err != null) {
                            (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
                        }
    
                        System.exit(1);
                        return null;
                    }
                });
            }
            
    //对应对象的run方法
    public void run() {
        if (address == 0) {
            // Paranoia
            return;
        }
        //释放直接内存中占用的内存
        unsafe.freeMemory(address); 
        address = 0;
        Bits.unreserveMemory(size, capacity);
    }      
  4. 直接内存的回收机制总结

    • 使用了Unsafe类来完成直接内存的分配回收,回收需要主动调用freeMemory方法;
    • ByteBuffer的实现内部使用了Cleaner(虚引用)来检测ByteBuffer。一旦ByteBuffer被垃圾回收,那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存。

文章作者: 一袖南烟顾
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 一袖南烟顾 !
评论
  目录