JVM学习之运行时数据区

news2024/7/4 5:57:46

运行时数据区

概述

在这里插入图片描述

内存

内存是非常重要的系统资源，是硬盘和CPU的中间桥梁，承载着操作系统和应用程序的实时运行。JVM内存布局规定了Java在运行过程中内存申请，分配，管理的策略，保证了JVM高效稳定运行。不同的JVM对于内存的划分方式和管理机制存在着部分差异。

运行时数据区-详细图

在这里插入图片描述

方法区和堆区是随着JVM启动而创建，随着JVM关闭而回收，生命周期与JVM一致，一个Java进程内只有一个堆区，一个方法区，线程之间是共享使用这些区域的（Metaspace和CodeCache也是线程共享的）。本地方法栈，程序计数器和虚拟机栈都是线程私有的，每个线程都有自己的一份。一般来讲95%的垃圾回收都发生在堆区，5%的垃圾回收发生在方法区。JDK8以后的Metaspace使用直接内存，直接内存一般比较大，但不代表不会发生垃圾回收。

线程

线程是一个程序里的运行单元。JVM允许一个应用里面有多个线程并行执行。

在HotSpot JVM中，每个线程都与操作系统的本地线程映射。当一个Java线程准备好执行以后，此时一个操作系统本地线程也会创建。Java线程终止后，操作系统本地线程也会回收。

操作系统负责把所有的线程调度到某个可用的CPU上，一旦本地线程初始化成功它就会调用Java线程中的Run方法。Run()方法如果有抛出未捕获的异常，JVM的线程就终止了，操作系统此时会判断是否应该结束JVM进程。当此线程是最后一个非守护线程时，JVM就被停止了。

Hot Spot JVM运行的后台线程
  • 虚拟机线程：这种线程的操作需要JVM到达安全点才会出现，这些操作必须在不同的线程中发生的原因是他们都需要JVM到达安全点，这样堆才不会变化。这种线程的执行类包括“stop-the-world”的垃圾收集，线程栈收集，线程挂起以及偏向锁撤销。
  • 周期任务线程：这种线程是时间周期事件的体现（比如中断）。它们一般用于周期性操作的调度执行。
  • GC线程：这种线程对在JVM不同种类的垃圾收集提供支持。
  • 编译线程：这种线程在运行时会将字节码编译成本地代码。
  • 信号调度线程：这种线程接收信号并发送给JVM，在它内部通过调用适当的方法进行处理。

程序计数器（PC寄存器）

介绍

JVM的PC寄存器是对物理PC寄存器的抽象模拟，是软件层面的概念，主要存储指令相关的现场信息。CPU只有把数据加载到寄存器才能使用。PC寄存器是用来存储指向下一条指令的地址，也可以理解为即将要执行指令的代码。由执行引擎读取下一条指令。

在这里插入图片描述

  • 它是一块很小的内存空间，小到可以忽略不计，也是运行速度最快的存储区域。
  • 在JVM规范中，每个线程都有自己的程序计数器，是线程私有的，生命周期与线程一致。
  • 任何时间，一个线程只有一个方法在执行，也就是所谓的当前方法。程序计数器会存储当前线程正在执行的Java方法的JVM指令地址，如果在执行native方法，是未指定值（undefined）
  • 它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要这个计数器来完成。
  • 字节码解释器工作时，就是通过改变这个计数器的值来选取下一条需要执行的字节码指令
  • 是唯一一个在Java虚拟机规范中没有OOM的区域
寄存器的使用
public static void main(String[] args) {
  int a = 1;
  int b = 2;
  int c = a + b;
}

编译成字节码为：

0 iconst_1
1 istore_1
2 iconst_2
3 istore_2
4 iload_1
5 iload_2
6 iadd
7 istore_3
8 return

前面的那一串数字就是指令行号，就是PC寄存器中存储的数值。

在这里插入图片描述

两个常见问题

  1. 为什么使用PC寄存器记录地址？（PC寄存器有什么作用）

    因为CPU是不断的切换线程执行的，切换回来后CPU要知道接下来从哪一条指令继续执行。JVM使用PC寄存器来明确接下来应该执行什么指令。

  2. PC寄存器为什么设置为线程私有

    CPU能调度的最小单元是线程，为了能够准确的记录各个线程正在执行的指令，最好的办法就是每个线程都分配一个PC寄存器。

CPU时间片

CPU时间片即CPU分配给各个线程的执行时间，每个线程执行时被分配一个时间段，称为CPU时间片。

从宏观上看：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。

从微观上看：由于只有一个CPU，一次只能处理一个应用程序要求的一部分，如何处理比较公平？引入时间片，每个程序轮流执行。

虚拟机栈

概述

栈是运行时的单位，堆事存储时的单位。

Java虚拟机栈

每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧，对应着一次次的方法调用，是线程私有的。生命周期与线程一致。它保存方法的局部变量（8中基本变量类型，引用类型的地址），部分结果，并参与方法的调用和返回。

优点
  • 栈是一种快速有效的存储分配方式，访问速度仅次于程序计数器
  • JVM对栈的操作有2个：
    • 每个方法被调用，伴随着入栈（压栈）
    • 执行结束后出栈
  • 对于栈来说不存在垃圾回收问题

Java虚拟机规范规定了虚拟机栈可以是固定不变的，也可以是动态的。虚拟机栈大小设置参数 -Xss。

栈的存储单位
  • 每个线程都有自己的栈，栈中的数据都是以栈帧的格式存储的
  • 在当前线程正在运行的每个方法各自对应一个栈帧
  • 栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息
栈运行原理
  • JVM对栈只有两个操作：入栈和出栈，遵循先进后出的原则
  • 在一条活动线程中，一个时间点上，只有一个活动的栈帧。即只有当前正在执行方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧。与当前栈帧相对应的方法就是当前方法，定义这个方法的类就是当前类
  • 执行引擎运行的所有字节码指令只针对当前栈帧进行操作
  • 如果该方法中调用了其它方法，对应新的栈帧会被创建出来，放在栈的顶端，成为新的当前栈帧。
  • 不同线程中所包含的栈帧不允许存在相互引用，即不可能在一个栈帧中引用另一个线程的栈帧
  • 如果当前方法调用了其它方法，方法返回之际，当前栈帧会传回执行结果给前一个栈帧，接着虚拟机会丢弃当前栈帧，使前一个栈帧成为新的当前栈帧
  • Java有两种返回函数的方法，一种是正常函数返回，使用returen指令，另一种是抛出异常。不管哪种方式，都会导致栈帧弹出。
栈帧内部结构
  • 局部变量表
  • 操作数栈（表达式栈）
  • 动态链接（指向运行时常量池的方法引用）
  • 方法返回地址（正常退出或异常退出的定义）

在这里插入图片描述

局部变量表
  • 局部变量表也被称为局部变量数据或本地变量表
  • 定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包含基本数据类型，对象引用以及returenAddress类型
  • 由于局部变量表是建立在线程栈上，是线程私有数据，因此不存在数据安全问题
  • 局部变量表所需容量的大小是在编译期确定的，并保存在方法的Code属性maximum local variables数据项中。在方法运行期间是不会改变局部变量表大小的。
  • 方法调用的次数由栈的大小决定，一般来说，栈越大，方法嵌套的次数就越多。局部变量表中变量多，会导致栈帧增大，在一定的栈空间下，嵌套的次数变少。
  • 局部变量表中的变量只在当前调用方法中生效，方法返回或异常退出，栈帧被销毁，局部变量也随之被销毁

随便写一些代码如下:

 public static void main(String[] args) {
        int a = 1;
        String str = "我是main函数";
        test1(678);
    }

    public static void test1(int a){
        int b = 2;
        int c = a + b;
        Date now = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(simpleDateFormat.format(now));
        short paramShort = 126;
        byte paramByte = 1;
        int re =test2(paramShort,1500,123456789L,false,paramByte,2.34f,
                1.174938493,'x',"我是test1，我调用test2");
        System.out.println(re);
    }

    public static int test2(short paramShor,int paramInt,long paramLong,boolean paramBoolean,
                            byte paramByte,float paramFloat,double paramDouble,char paramChar,
                            String paramStr){
        short localShot = 0;
        int localInt = 1;
        long localLong = 2147483647L;
        boolean localBoolean = true;
        byte localByte = 8;
        float localFloat = 1.23f;
        double localDouble = 3.14;
        char localChar = 'A';
        Integer integer = Integer.valueOf("1000");
        return localInt;
    }

使用javap -v反编译后如下（省略了部分不关注的信息）：

//... 省略类信息 常量池 其他方法信息等
  public static int test2(short, int, long, boolean, byte, float, double, char, java.lang.String);
    descriptor: (SIJZBFDCLjava/lang/String;)I
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=22, args_size=9
         0: iconst_0
         1: istore        11
         3: iconst_1
         4: istore        12
         6: ldc2_w        #20                 // long 2147483647l
         9: lstore        13
        11: iconst_1
        12: istore        15
        14: bipush        8
        16: istore        16
        18: ldc           #22                 // float 1.23f
        20: fstore        17
        22: ldc2_w        #23                 // double 3.14d
        25: dstore        18
        27: bipush        65
        29: istore        20
        31: ldc           #25                 // String 1000
        33: invokestatic  #26                 // Method java/lang/Integer.valueOf:(Ljava/lang/String;)Ljava/lang/Integer;
        36: astore        21
        38: iload         12
        40: ireturn
      LineNumberTable:
        line 29: 0
        line 30: 3
        line 31: 6
        line 32: 11
        line 33: 14
        line 34: 18
        line 35: 22
        line 36: 27
        line 37: 31
        line 38: 38
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      41     0 paramShort   S
            0      41     1 paramInt   I
            0      41     2 paramLong   J
            0      41     4 paramBoolean   Z
            0      41     5 paramByte   B
            0      41     6 paramFloat   F
            0      41     7 paramDouble   D
            0      41     9 paramChar   C
            0      41    10 paramStr   Ljava/lang/String;
            3      38    11 localShort   S
            6      35    12 localInt   I
           11      30    13 localLong   J
           14      27    15 localBoolean   Z
           18      23    16 localByte   B
           22      19    17 localFloat   F
           27      14    18 localDouble   D
           31      10    20 localChar   C
           38       3    21 integer   Ljava/lang/Integer;
    //...省略代码
}
SourceFile: "Main.java"

我们那典型的test2这个方法来分析，可以看到Code下面的locals=22说明局部变量有22个，args_size=9代表参数有9个。接下来LocalVariableTable就是局部变量表。Start和Length规定了当前变量作用域，Start为指令开始位置，Length代表从Start开始在Length内可以用，Slot可以理解为下标

Start  Length  Slot  Name   Signature
  0      41     0 paramShort   S //参数paramShort 类型为short
  0      41     1 paramInt   I
  0      41     2 paramLong   J
  0      41     4 paramBoolean   Z
  0      41     5 paramByte   B
  0      41     6 paramFloat   F
  0      41     7 paramDouble   D
  0      41     9 paramChar   C
  0      41    10 paramStr   Ljava/lang/String; //参数paramStr 类型为java/lang/String 最前面的L代表是引用类型
3      38    11 localShort   S
  6      35    12 localInt   I
  11      30    13 localLong   J
  14      27    15 localBoolean   Z
  18      23    16 localByte   B
  22      19    17 localFloat   F
  27      14    18 localDouble   D
  31      10    20 localChar   C
  38       3    21 integer   Ljava/lang/Integer; //局部变量integer 类型为java/lang/Integer 是引用类型

另外，LineNumberTable这个记录了字节码行号和代码行号的对应关系，line后面是指令行号，:后面是代码行号。

关于Slot的理解
  • 参数总是从index 0开始，长度-1结束
  • 局部变量表的基本单位就是slot（槽）
  • 局部变量表存放编译期就已知的8种数据类型，引用类型（reference）和retureAddress类型
  • 局部变量表中，32位以内（含32位）的类型，64位的类型占2个slot
    • byte，short，char在存储前被转换为int，boolean也被转换成int，0代表false，非0代表true
    • long和doubule占两个slot
    • reference类型和retureAddress类型都按32位算，也占用一个slot
  • JVM为局部变量表中每个slot分配一个访问索引，通过这个索引即可成功访问到局部变量表中对应的变量值
  • 当一个实例方法被调用的时候，它的方法参数和方法内部定义的局部变量表将会按照顺序被复制到局部变量中每一个slot中
  • 如果访问局部变量表中一个64bit的局部变量值，只需要访问第一个索引即可
  • 如果当前帧是由构造方法或实例方法创建的，那么该对象引用(this)将会存放在index为0的slot处，其余参数按照参数表顺序继续排列
  • static方法不能引用this是因为this根本不存在本地变量中
public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.testInnerNoReturnValue();
        int re = main.testInnerHasReturnValue(2);
        System.out.println("testInnerHasReturnValue返回值：" + re);
        testStatic(1L,"test");
    }

    public void testInnerNoReturnValue(){
        System.out.println("我是实例方法-无返回值");
    }
    public int testInnerHasReturnValue(int paramInt){
        System.out.println("我是实例方法-无返回值 参数：" + paramInt);
        return 1;
    }

    public static void testStatic(long paramLong,String str){
        System.out.println("我是静态方法");
    }
}

使用javap -v反编译一下：

//...省略类信息和main方法信息
public void testInnerNoReturnValue();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #16                 // String 我是实例方法-无返回值
         5: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 16: 0
        line 17: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Lcom/example/demo/Main;

  public int testInnerHasReturnValue(int);
    descriptor: (I)I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=2
         0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: new           #7                  // class java/lang/StringBuilder
         6: dup
         7: invokespecial #8                  // Method java/lang/StringBuilder."<init>":()V
        10: ldc           #17                 // String 我是实例方法-无返回值 参数：
        12: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        15: iload_1
        16: invokevirtual #11                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
        19: invokevirtual #12                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        22: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        25: iconst_1
        26: ireturn
      LineNumberTable:
        line 19: 0
        line 20: 25
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      27     0  this   Lcom/example/demo/Main;
            0      27     1 paramInt   I
    MethodParameters:
      Name                           Flags
      paramInt

  public static void testStatic(long, java.lang.String);
    descriptor: (JLjava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=2
         0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #18                 // String 我是静态方法
         5: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 24: 0
        line 25: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0 paramLong   J
            0       9     2   str   Ljava/lang/String;
    MethodParameters:
      Name                           Flags
      paramLong
      str

可以看到实例方法testInnerNoReturnValue和testInnerHasReturnValue本地变量表中第一个就是this，而静态方法testStatic就不是，在testStatic中可以看到long占了两个slot，若想访问，直接取index 为0的slot即可，无需关心index为1的slot

slot重复利用

栈帧中的局部变量是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明的局部变量就很有可能复用过期局部变量的槽位，从而达到节省资源的目的。

public class Main {
    public static int COUNT = 1;
    public static void main(String[] args) {
        Main main = new Main();
        main.testSlot();
    }
    public int testSlot(){
        int a = 1;
        int c = 0;
         if(COUNT > 0){
             //无任何特殊逻辑，只是用来框定变量b的作用域
             int b = 1;
             c = a + b;
         }
         int d = c + COUNT;
         return d;
    }
}

使用javap -v反编译一下：

//...省略类信息和main方法信息
public int testSlot();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
       //...省略指令信息
       //...省略指令行号与代码行号对应信息
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           12       4     3     b   I
            0      24     0  this   Lcom/example/demo/Main;
            2      22     1     a   I
            4      20     2     c   I
           22       2     3     d   I
//...省略其他信息

可以看到变量b的槽位号和变量d的是一样的，变量d在变量b的作用域之外，便可复用slot

静态变量与局部变量的对比
  • 参数表分配完毕后，再根据方法体内定义的变量的顺序和作用域分配
  • 类变量表有两次初始化机会，第一次在准备阶段，执行系统初始化，类变量赋零值。第二次在初始化阶段，执行程序员对其赋值。
  • 和类变量初始化不同，局部变量表不存在系统初始化过程，这意味着一旦定义了局部变量，则必须人为初始化，否则无法使用。
public void test(){
  int i;
  System.out.println(i);
}

这会导致编译错误，提示未初始化变量i,所以局部变量没有赋值不能使用。

操作数栈

在方法执行过程中，根据字节码指令，往栈中写入数据或者提取数据，即入栈和出栈。Java虚拟机的解释引擎就是基于栈的引擎。

在这里插入图片描述

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

如果被调用的方法带有返回值的话，其返回值会被压入当前栈帧的操作数栈中，并更新程序计数器。

操作数栈的数据类型要和字节码指令规定的数据类型严格一致。int32位占4个字节，long占8个字节。

JVM中的栈和局部变量表用的都是数组实现栈。

++i和i++问题
public void add(){
  int a = 1;
  a++;
  int b = 1;
  ++b;
}
//编译出的字节码如下 看起来++i和i++没啥区别
0 iconst_1
1 istore_1
2 iinc 1 by 1
5 iconst_1
6 istore_2
7 iinc 2 by 1
10 return

// 看下赋值
public void add(){
  int a = 1;
  int c = a++;
  int b = 1;
  int d = ++b;
}
//编辑字节码为 看下来也没啥区别
0 iconst_1
1 istore_1
2 iload_1
3 iinc 1 by 1
6 istore_2
7 iconst_1
8 istore_3
9 iinc 3 by 1
12 iload_3
13 istore 4
15 return
栈顶缓存技术

基于栈架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这也意味着将需要更多的指令分派（instruction dispatch）次数和内存读/写次数。由于操作数是存储在内存中的，因此频繁的执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们踢出了栈顶缓存（ToS，Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的效率。

动态链接

每一个栈帧内部都包含一个执行运行时常量池中该栈帧所属方法的引用，包含这个引用的目的就是为了支持当前方法的代码能实现动态链接（Dynamic Linking）。比如 invokedynamic指令

在Java源文件被编译到字节码文件时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池中，比如：描述一个方法调用了另外的方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

public static void main(String[] args) {

  System.out.println(add(1,2));
}

public static int add(int a,int b){
  return a + b;
}
//上面代码main方法编译后指令为
 0 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
 3 iconst_1
 4 iconst_2
 5 invokestatic #3 <com/example/demo/Main.add : (II)I>
 8 invokevirtual #4 <java/io/PrintStream.println : (I)V>
11 return
//第5行字节码中的 #3 就是引用，后面注释中的com/example/demo/Main.add就是符号链接

常量池如下

在这里插入图片描述

方法的调用

在JVM中，将符号引用转化为调用方法的直接引用于方法的绑定机制相关。

  • 静态链接：

    当一个字节码文件被装在进JVM内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。绑定类型为早期绑定，即编译期绑定，后面不再变化。上面的字节码中 #2 #3 #4都是静态链接。子类调用父类中的方法或类调用当前类中的方法，编译期可确定方法，表现为静态链接，早期绑定。

  • 动态链接

    如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行过程中将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，因此也就被称之为动态链接。绑定类型为晚期绑定，即运行时绑定。多态中参数是父类，调用时传入子类都是动态链接，只有在被调用时才知道方法具体所属类是哪个。

虚方法：多态中的概念，一般指父类中可被子类重写（覆盖）的方法，Java中除了构造方法，私有方法，final修饰的方法，其它的都可以认为是虚方法。

相关联的字节指令：

普通指令：

  1. invokestatic:调用静态方法，解析阶段确定唯一方法版本
  2. invokespecial: 调用<init>方法、私有及父类方法，解析阶段确定唯一方法版本
  3. invokevirtual: 调用所有虚方法，如果父类中的final方法在子类中调用，用此指令，如果添加了super.，就会使用invokespecial
  4. invokeinterface:调用接口方法

动态调用指令：

  1. invokedynamic: 动态解析出需要调用的方法，然后执行

普通指令固化在虚拟机内部，方法的调用执行人为不可干预，而invokedynamic指令支持由用户确定方法版本。其中invokestatic执行令和invokespecial指令调用的方法为非虚方法，其余的（除final修饰的）称为虚方法。

Java为了实现动态类型语言支持添加了invokedynamic指令，在JDK7添加，最初没有什么代码能编译出这个指令，主要靠ASM这类工具使用此指令，JDK8添加了lambda表达式，会编译成此指令。

动态类型语言和静态类型语言：对类型进行检查是在编译期还是运行期，在编译期就是静态类型语言，在运行期就是动态类型，Java是静态类型。

方法返回地址

栈帧当中的一个内存结构，存储该方法的PC寄存器的值（PC寄存器日常存储程序的下一条指令地址）。

一个方法的结束有两种：

  1. 正常返回
  2. 抛出异常

不管是哪种，都会返回调用处。正常退出，PC寄存器存储方法的下一条指令地址，异常退出根据异常表确定，此时栈帧中不存储任何信息。

如果发生了异常，在异常表中未找到，走异常出口，找到了走异常表处理逻辑。

返回指令包含ireturen（当返回类型是boolean，byte，char，short和int类型使用），lreturn（long），freturn（float）,dreturn（double）以及areturn（引用类型），void时使用return

一些附加信息

无特定标准，具体情况依据虚拟机实现，一般会有调试虚拟机的信息。

本地方法栈

本地方法

一个NativeMethod就是一个Java调用非Java代码的接口。该方法的实现由非Java语言实现。在定义一个Native 方法时，只定义签名，不提供方法体，类似一个接口。本地方法的作用是融合不同的编程语言为Java所用，最初用来融C/C++程序。

为什么要使用Native方法

  1. 与Java外环境交互
  2. 与操作系统交互
  3. 经典的Hotspot虚拟机使用的是C实现，为了调用虚拟机中实现的一些高性能的程序

native关键字和abstract不可同时使用。

本地方法栈

本地方法栈线程私有，可以固定也可以动态扩容。固定时超出或者动态扩容时整体内容不够时，会抛出StackOverFlowException。

并不是所有虚拟机都支持本地方法。JVM规范没有明确规定本地方法栈的要求。

堆空间

概述

一个JVM只有一个堆内存，堆也是Java内存管理的核心区域。

Java堆区在JVM启动时即被创建，其空间大小也会随之确定。

堆是JVM管理的最大的一块内存空间。

堆的大小是可以调整的。

《JVM虚拟机规范》规定，堆在物理上可以不连续，但在逻辑上必须是连续的。

所有线程共享Java堆，在这里还可以划分线程私有的缓冲区（Thread Local Allocation Buffer，TLAB）

《JVM虚拟机规范》规定所有的对象实例以及数组应当分配在堆上，实际上来说：几乎所有的对象实例以及数组应当分配在堆上。

数组和对象可能永远不会存储在栈上，因为栈帧保存引用，这个引用指向对象或者数组在堆中的位置。例外情况就是逃逸分析和标量替换。

在方法结束后，堆中的对象不会马上被移除。仅仅在垃圾收集的时候才会被移除。

堆是GC执行垃圾回收的重点区域。

public class Main {

    public static void main(String[] args) {
        Main main1 = new Main();
        Main main2 = new Main();

        String[] stringArrays = new String[5];
        
    }
}
//字节码为

 0 new #2 <com/example/demo/Main> //这里new了一个类
 3 dup
 4 invokespecial #3 <com/example/demo/Main.<init> : ()V>
 7 astore_1
 8 new #2 <com/example/demo/Main> //这里new了另一个类
11 dup
12 invokespecial #3 <com/example/demo/Main.<init> : ()V>
15 astore_2
16 iconst_5
17 anewarray #4 <java/lang/String> //这里是new了一个数组
20 astore_3
21 return

第0行，第8行，第17行的操作都在堆上进行。

现代垃圾收集器大部分基于分代收集理论设计，细分为

  • Java7 及之前堆内存逻辑上分为三部分：新生区+养老区+永久区
  • Young Generation Space 新生区 Young/New 这个区又被划分为Eden区和Survivor区

20231217未完待续。。。。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1317771.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

HTTP 302错误：临时重定向

HTTP 302错误：临时重定向

在Web开发中&#xff0c;HTTP状态码是用于表示Web服务器响应的各种状态。其中&#xff0c;HTTP 302错误表示临时重定向&#xff0c;这意味着请求的资源已被临时移动到其他位置&#xff0c;并且服务器已经提供了新的URL&#xff0c;以便客户端可以重新发送请求。 了解HTTP 302错…
阅读更多...
[计网01] 物理层 详细解析笔记,特性

[计网01] 物理层 详细解析笔记,特性

计算机网络的物理层是网络协议栈中的第一层&#xff0c;负责传输原始的比特流&#xff08;bitstream&#xff09;通过物理媒介进行通信。物理层主要关注传输介质、信号的编码和调制、数据传输速率以及数据传输的物理连接等方面。 相关特性 机械特性&#xff08;Mechanical Ch…
阅读更多...
网络安全—学习溯源和日志分析

网络安全—学习溯源和日志分析

日志分析的步骤&#xff1a; 判断是否为攻击行为 不是&#xff1a;不用处理 是&#xff1a;判断攻击是否成功或者失败 攻击失败&#xff1a;判断IP地址是否为恶意地址&#xff0c;可以让防火墙过滤IP地址 攻击成功&#xff1a;做应急处置和溯源分析 应急处置&#xff1a;网络下…
阅读更多...
[楚慧杯 2023] web

[楚慧杯 2023] web

文章目录 eaaevalupload_shell eaaeval 打开题目&#xff0c;源码给了用户密码 登陆后啥也没有&#xff0c;扫一下发现源码泄露www.zip <?php class Flag{public $a;public $b;public function __construct(){$this->a admin;$this->b admin;}public function _…
阅读更多...
Python计算圆的面积，几何学技法大解析！

Python计算圆的面积，几何学技法大解析！

更多Python学习内容&#xff1a;ipengtao.com 大家好&#xff0c;我是彭涛&#xff0c;今天为大家分享 Python计算圆的面积&#xff0c;几何学技法大解析&#xff0c;全文3800字&#xff0c;阅读大约15分钟。 在本文中&#xff0c;将深入探讨如何使用 Python 计算圆的面积&…
阅读更多...
用23种设计模式打造一个cocos creator的游戏框架----(十八)责任链模式

用23种设计模式打造一个cocos creator的游戏框架----(十八)责任链模式

1、模式标准 模式名称&#xff1a;责任链模式 模式分类&#xff1a;行为型 模式意图&#xff1a;使多个对象都有机会处理请求&#xff0c;从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链&#xff0c;并沿着这条链传递该请求&#xff0c;直到有一个对象处…
阅读更多...
『OPEN3D』1.5.1 动手实现点云暴力最近邻

『OPEN3D』1.5.1 动手实现点云暴力最近邻

本专栏地址： https://blog.csdn.net/qq_41366026/category_12186023.html?spm=1001.2014.3001.5482https://blog.csdn.net/qq_41366026/category_12186023.html?spm=1001.2014.3001.5482 1、暴力最近邻法 暴力最近邻法 (Brute-force Nearest Neighbour Search，BF 搜索) 是…
阅读更多...
【数据结构】哈希表算法总结

【数据结构】哈希表算法总结

知识概览&#xff08;哈希表&#xff09; 哈希表可以将一些值域较大的数映射到较小的空间内&#xff0c;通常用x mod 质数的方式进行映射。为什么用质数呢&#xff1f;这样的质数还要离2的整数幂尽量远。这可以从数学上证明&#xff0c;这样冲突最小。取余还是会出现冲突情况。…
阅读更多...
ElasticSearch学习篇8_Lucene之数据存储（Stored Field、DocValue、BKD Tree）

ElasticSearch学习篇8_Lucene之数据存储（Stored Field、DocValue、BKD Tree）

前言 Lucene全文检索主要分为索引、搜索两个过程&#xff0c;对于索引过程就是将文档磁盘存储然后按照指定格式构建索引文件&#xff0c;其中涉及数据存储一些压缩、数据结构设计还是很巧妙的&#xff0c;下面主要记录学习过程中的StoredField、DocValue以及磁盘BKD Tree的一些…
阅读更多...
【数据挖掘 | 相关性分析】Jaccard相似系数详解、关于集合的相关性（详细案例、附完详细代码实现和实操、学习资源）

【数据挖掘 | 相关性分析】Jaccard相似系数详解、关于集合的相关性（详细案例、附完详细代码实现和实操、学习资源）

&#x1f935;‍♂️ 个人主页: AI_magician &#x1f4e1;主页地址&#xff1a; 作者简介&#xff1a;CSDN内容合伙人&#xff0c;全栈领域优质创作者。 &#x1f468;‍&#x1f4bb;景愿&#xff1a;旨在于能和更多的热爱计算机的伙伴一起成长&#xff01;&#xff01;&…
阅读更多...
《opencv实用探索·二十》点追踪技术

《opencv实用探索·二十》点追踪技术

前言&#xff1a; 在学习点追踪技术前需要先了解下光流发追踪目标&#xff0c;可以看上一章内容&#xff1a;光流法检测运动目标 如果以光流的方式追踪目标&#xff0c;基本上我们可以通过goodFeaturesToTrack函数计算一系列特征点&#xff0c;然后通过Lucas-Kanade算法进行一…
阅读更多...
Java智慧工地源码，智慧工地管理平台的技术架构和工作原理

Java智慧工地源码，智慧工地管理平台的技术架构和工作原理

智慧工地管理平台是将互联网的理念和技术引入建筑工地&#xff0c;从施工现场源头抓起&#xff0c;最大程度的收集人员、安全、环境、材料等关键业务数据&#xff0c;依托物联网、互联网&#xff0c;建立云端大数据管理平台&#xff0c;形成“端云大数据”的业务体系和新的管理…
阅读更多...
考虑使用自定义的序列化形式

考虑使用自定义的序列化形式

在Java中&#xff0c;有时候我们可能需要考虑使用自定义的序列化形式&#xff0c;以满足特定的需求或优化序列化过程。这通常涉及到实现Serializable接口的类&#xff0c;并自定义writeObject和readObject方法。以下是一个简单的例子&#xff0c;演示了如何使用自定义的序列化形…
阅读更多...
货物数据处理pandas版

货物数据处理pandas版

1求和 from openpyxl import load_workbook import pandas as pddef print_hi(name):# Use a breakpoint in the code line below to debug your script.print(fHi, {name}) # Press CtrlF8 to toggle the breakpoint.# Press the green button in the gutter to run the scr…
阅读更多...
vue中2种取值的方式

vue中2种取值的方式

1.url是这种方式的&#xff1a;http://localhost:3000/user/1 取得参数的方式为&#xff1a;this.$route.params.id 2.url为get方式用&#xff1f;拼接参数的&#xff1a;http://localhost:3000/user?phone131121123&companyId2ahttp://localhost:3000/ 取得参数值的方式…
阅读更多...
HTTP代理神器Fiddler的配置

HTTP代理神器Fiddler的配置

HTTP代理神器Fiddler Fiddler的简介 Fiddler是位于客户端和服务器端之间的代理&#xff0c;也是目前最常用的抓包工具之一 。它能够记录客户端和服务器之间的所有 请求&#xff0c;可以针对特定的请求&#xff0c;分析请求数据、设置断点、调试web应用、修改请求的数据&#…
阅读更多...
不是生活有意思，是你热爱生活它才有意思

不是生活有意思，是你热爱生活它才有意思

明制汉服的设计 同样是一款很重工的外套 细节上也是做到了极致 顺毛毛呢面料 领口袖口拼接仿貂毛环保毛条 前胸欧根纱刺绣圆形布 袖子贴民族风珠片刺绣织带 门襟搭配金属子母扣&#xff0c;真盘扣设计 时尚经典&#xff0c;搭配马面裙孩子穿上 真的很有气质奢华富贵 …
阅读更多...
Android hwcomposer服务启动流程

Android hwcomposer服务启动流程

Android hwcomposer服务启动流程 客户端 binder远程调用 服务端 surfaceflinger --binder--> hwcomposer .hal文件编译时生成支持binder进程间远程调用通信的cpp文件 在out/soong/.intermediates/hardware/interfaces/graphics/composer/2.1/ 目录下找…
阅读更多...
时序预测 | Python实现GRU电力需求预测

时序预测 | Python实现GRU电力需求预测

时序预测 | Python实现GRU电力需求预测 目录 时序预测 | Python实现GRU电力需求预测预测效果基本描述程序设计参考资料预测效果 基本描述 该数据集因其每小时的用电量数据以及 TSO 对消耗和定价的相应预测而值得注意，从而可以将预期预测与当前最先进的行业预测进行比较。使用该…
阅读更多...
【如何提取React项目中的公共模块，多个项目共用】

【如何提取React项目中的公共模块，多个项目共用】

文章目录 目录 前言 一、创建公共模块 二、初始化公共模块 三、给公共模块添加内容 四、添加对公共模块的依赖 五、使用公共模块里的资源 后记 前言 在工作中经常会遇到这样的需求&#xff0c;有个React项目&#xff0c;代码分为客户端&#xff0c;管理端两份&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023