一、什么是JVM以及JVM的内存区域

已于 2022-07-24 08:26:41 修改
阅读量102 收藏 1
点赞数 1
分类专栏： JVM 文章标签： java JVM
于 2022-05-28 10:55:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zimojiang/article/details/125015012
版权

一、什么是JVM？

定义

Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）

好处

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

比较

JVM JRE JDK的区别
在这里插入图片描述

二、内存结构

0、整体架构

在这里插入图片描述

1、程序计数器

作用

用于保存JVM中下一条所要执行的指令的地址

特点

  • 线程私有
    • CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
    • 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
  • 不会存在内存溢出

2、虚拟机栈

定义

  • 每个线程运行需要的内存空间，称为虚拟机栈
  • 每个栈由多个栈帧组成，对应着每次调用方法时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的方法

演示

代码

public class Main {
	public static void main(String[] args) {
		method1();
	}

	private static void method1() {
		method2(1, 2);
	}

	private static int method2(int a, int b) {
		int c = a + b;
		return c;
	}
}

img

在控制台中可以看到，主类中的方法在进入虚拟机栈的时候，符合栈的特点

问题辨析

  • 垃圾回收是否涉及栈内存？
    • 不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
  • 栈内存的分配越大越好吗？
    • 不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
  • 方法内的局部变量是否是线程安全的？
    • 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
    • 如果如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题

内存溢出

Java.lang.stackOverflowError 栈内存溢出

发生原因

  • 虚拟机栈中，栈帧过多（无限递归）
  • 每个栈帧所占用过大

线程运行诊断

CPU占用过高

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

3、本地方法栈

一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法

4、堆

定义

通过new关键字创建的对象都会被放在堆内存

特点

  • 所有线程共享，堆内存中的对象都需要考虑线程安全问题
  • 有垃圾回收机制

堆内存溢出

java.lang.OutofMemoryError ：java heap space. 堆内存溢出

堆内存诊断

jps

jmap

jconsole

jvirsalvm

5、方法区

定义

在这里插入图片描述

结构

方法区是概念上的，具体实现：JDK1.6是永久代，JDK1.8是元空间。
在这里插入图片描述
注：图片中【常量池】应该改为【运行时常量池】。

JDK1.8之前的永久代

Class:类的元信息、 例如上图中：field、methods、constructors
ClassLoader: 类加载器也在永久代存着。
运行时常量池：其中有个重要的StringTable（串池）

JDK1.8 元空间

JDK1.8 中永久代废弃了，方法区当然还是概念上的，实现变成了元空间，也包含Class、ClassLoader、运行时常量池，不过它已经不占用堆内存了，也就是说不归JVM来管理它的内存结构了，移出到本地内存当中。本地内存也是操作系统内存，同时还会跑其它的进程。
还有个不一样的地方，串池不放在元空间，移出到堆内存中。

方法区内存溢出

  • 1.8以前会导致永久代内存溢出
      	* 演示永久代内存溢出 java.lang.OutOfMemoryError: PermGen space
	* -XX:MaxPermSize=8m
  • 1.8以后会导致元空间内存溢出
    	* 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
	* -XX:MaxMetaspaceSize=8m

常量池

二进制字节码的组成：类的基本信息、常量池、类的方法定义（包含了虚拟机指令）

二进制字节码看不懂，需要 通过反编译来查看类的信息

  • 获得对应类的.class文件

    • 在JDK对应的bin目录下运行cmd，也可以在IDEA控制台输入

      img

    • 输入 javac 对应类的绝对路径

      F:\JAVA\JDK8.0\bin>javac F:\Thread_study\src\com\nyima\JVM\day01\Main.java

      输入完成后，对应的目录下就会出现类的.class文件

  • 在控制台输入 javap -v 类的绝对路径

    javap -v F:\Thread_study\src\com\nyima\JVM\day01\Main.class

  • 然后能在控制台看到反编译以后类的信息了

    • 类的基本信息
    Classfile /D:/Code/Huiwei/target/classes/com/jzt/jvm/HelloWorld.class
  Last modified 2022-5-28; size 557 bytes
  MD5 checksum 8b8fb71f533f8ee3463924248f75dabc
  Compiled from "HelloWorld.java"
public class com.jzt.jvm.HelloWorld
  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 World
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // com/jzt/jvm/HelloWorld
   #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               Lcom/jzt/jvm/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               hello World
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               com/jzt/jvm/HelloWorld
  #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 com.jzt.jvm.HelloWorld();
    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   Lcom/jzt/jvm/HelloWorld;

  public static void main(java.lang.String[]);
    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 World
         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;
}

运行时常量池

  • 常量池
    • 就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
  • 运行时常量池
    • 常量池是*.class文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址（不是根据#1#2这种编号方式找，而是内存地址去找类名、方法名、参数类型、字面量等信息）

常量池与串池的关系

先看几道面试题

String s1 = "a";
String s2 = "b";
String s3 = "a" + "b";
String s4 = s1 + s2;
String s5 = "ab";
String s6 = s4.intern();
// 问
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
String x2 = new String("c") + new String("d");
String x1 = "cd";
x2.intern();
// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
System.out.println(x1 == x2);
串池StringTable

特征

  • 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是StringBuilder
  • 字符串常量拼接的原理是编译器优化
  • 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中
    • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
    • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池， 会把串池中的对象返回
  • 注意：无论是串池还是堆里面的字符串，都是对象

用来放字符串对象且里面的元素不重复

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a"; 
		String b = "b";
		String ab = "ab";
	}
}

常量池中的信息，都会被加载到运行时常量池中，但这是a b ab 仅是常量池中的符号，还没有成为java字符串

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 时，会把符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构 不可扩容）

当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中

当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中

最终StringTable [“a”, “b”, “ab”]

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

使用拼接字符串变量对象创建字符串的过程

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a";
		String b = "b";
		String ab = "ab";
		//拼接字符串对象来创建新的字符串
		String ab2 = a+b; 
	}
}

反编译后的结果

	 Code:
      stack=2, locals=5, 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
        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/Str
ing;
        27: astore        4
        29: return

通过拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()

最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中

String ab = "ab";
String ab2 = a+b;
//结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中
System.out.println(ab == ab2);

使用拼接字符串常量对象的方法创建字符串

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";
	}
}

反编译后的结果

 	  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
        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/Str
ing;
        27: astore        4
        //ab3初始化时直接从串池中获取字符串
        29: ldc           #4                  // String ab
        31: astore        5
        33: return
  • 使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致。
  • 使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建
intern方法 1.8

调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

  • 如果串池中没有该字符串对象，则放入成功
  • 如果有该字符串对象，则放入失败

无论放入是否成功，都会返回串池中的字符串对象

注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象

例1

public class Main {
	public static void main(String[] args) {
		//"a" "b" 被放入串池中，str则存在于堆内存之中
		String str = new String("a") + new String("b");
		//调用str的intern方法，这时串池中没有"ab"，则会将该字符串对象放入到串池中，此时堆内存与串池中的"ab"是同一个对象
		String st2 = str.intern();
		//给str3赋值，因为此时串池中已有"ab"，则直接将串池中的内容返回
		String str3 = "ab";
		//因为堆内存与串池中的"ab"是同一个对象，所以以下两条语句打印的都为true
		System.out.println(str == st2);
		System.out.println(str == str3);
	}
}

例2

public class Main {
	public static void main(String[] args) {
        //此处创建字符串对象"ab"，因为串池中还没有"ab"，所以将其放入串池中
		String str3 = "ab";
        //"a" "b" 被放入串池中，str则存在于堆内存之中
		String str = new String("a") + new String("b");
        //此时因为在创建str3时，"ab"已存在与串池中，所以放入失败，但是会返回串池中的"ab"
		String str2 = str.intern();
        //false
		System.out.println(str == str2);
        //false
		System.out.println(str == str3);
        //true
		System.out.println(str2 == str3);
	}
}
intern方法 1.6

调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

  • 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
  • 如果有该字符串对象，则放入失败

无论放入是否成功，都会返回串池中的字符串对象

注意：此时无论调用intern方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象
在这里插入图片描述

StringTable 垃圾回收

StringTable在内存紧张时，会发生垃圾回收

StringTable调优

  • 因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间

    -XX:StringTableSize=xxxx

  • 考虑是否需要将字符串对象入池

    可以通过intern方法减少重复入池

6、直接内存

  • 属于操作系统，常见于NIO操作时，用于数据缓冲区
  • 分配回收成本较高，但读写性能高
  • 不受JVM内存回收管理

看个例子：文件的拷贝。缓冲区大小都是1MB
使用两个方法：

  • 传统的阻塞IO读写
  • directBuffer方法使用了ByteBuffer分配读写缓冲区。

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

上述两种读写的性能：传统阻塞IO3秒左右，而directBuffer不到1秒。结论：使用ByteBuffer（直接内存）IO性能较高。

文件读写流程

传统阻塞IO

img
上图解释：首先Java的应用程序是不能直接读文件的，需要调用操作系统的读文件函数。CPU进入内核态，由操作系统去读文件。操作系统将磁盘中的文件读到系统缓存区，而系统缓冲区中的数据，Java的代码是不能直接运行的。所以Java会在堆内存中分配一块Java缓冲区（对应于new byte[]）。刚才的代码要访问流中的数据，还需要再从系统缓冲区间接地读入到Java缓冲区。到了下一个状态，再调用输出流的写入操作。反复进行读写读写。把整个文件复制到目标位置。
问题：不必要的数据复制。因为Java应用程序访问不到系统缓冲区数据，所以数据还要再拷贝，导致不必要的数据复制，效率降低。

使用了DirectBuffer

img
上图解释：当调用ByteBuffer.allocateDirect()函数时，会分配一块直接内存。会在操作系统划出一块缓冲区（上图的direct memory），跟之前不一样的是：操作系统这块内存缓冲区，Java代码可以直接访问。直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率。

释放原理

在这里插入图片描述

在这里插入图片描述

直接内存的回收不是通过JVM的垃圾回收来释放的，而是通过unsafe.freeMemory来手动释放
在这里插入图片描述

通过

  //通过ByteBuffer申请1M的直接内存
  ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);

申请直接内存，但JVM并不能回收直接内存中的内容，它是如何实现回收的呢？

allocateDirect的实现

  public static ByteBuffer allocateDirect(int capacity) {
      return new DirectByteBuffer(capacity);
  }

DirectByteBuffer类

  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;
      }
      cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); //通过虚引用，来实现直接内存的释放，this为虚引用的实际对象
      att = null;
  }

这里调用了一个Cleaner的create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象（这里是DirectByteBuffer）被回收以后，就会调用Cleaner的clean方法，来清除直接内存中占用的内存

public void clean() {
       if (remove(this)) {
           try {
               this.thunk.run(); //调用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);
}
直接内存的回收机制总结
  • 使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法
  • ByteBuffer的实现内部使用了Cleaner（虚引用）来检测ByteBuffer。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存

为了防止Full GC对性能产生影响，我们打开开关：DisableExplicitGC，会产生如下问题：
在这里插入图片描述
上图：导致直接内存长时间得不到释放。
怎么解决？

去掉DisableExplicitGC？那不行，别的代码System.gc()会Full GC导致垃圾回收对性能产生影响。
使用unsafe直接释放即可，程序员手动管理这块内存。

三、常见面试题

谈谈对 OOM 的认识？如何排查 OOM 的问题？

除了程序计数器，其他内存区域都有 OOM 的风险。

  • 栈一般经常会发生 StackOverflowError，比如 32 位的 windows 系统单进程限制 2G 内存，无限创建线程就会发生栈的 OOM
  • Java 8 常量池移到堆中，溢出会出 java.lang.OutOfMemoryError: Java heap space，设置最大元空间大小参数无效；
  • 堆内存溢出，报错同上，这种比较好理解，GC 之后无法在堆中申请内存创建对象就会报错；
  • 方法区 OOM，经常会遇到的是动态生成大量的类、jsp 等；
  • 直接内存 OOM，涉及到 -XX:MaxDirectMemorySize 参数和 Unsafe 对象对内存的申请。

排查 OOM 的方法：

  • 增加两个参数 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof，当 OOM 发生时自动 dump 堆内存信息到指定目录；
  • 同时 jstat 查看监控 JVM 的内存和 GC 情况，先观察问题大概出在什么区域；
  • 使用 MAT 工具载入到 dump 文件，分析大对象的占用情况，比如 HashMap 做缓存未清理，时间长了就会内存溢出，可以把改为弱引用 。

参考

一、什么是JVM
二、解密JVM【黑马程序员出品】

涛歌依旧fly
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 成员变量的线程安全
allin01的专栏
03-26 7529
           本文讲解的是关于java成员变量的线程安全问题，包括静态变量和实例变量。静态变量好理解，所有实例都共享一份内存，任何对静态变量的修改都会引发线程安全问题。然而，对于实例变量，在大多数情况下的访问和修改都是线程安全的。但是，当这个类，在系统里面被实现为单例模式时，由于整个系统中，只存在一份对象内存，所以，系统的各线程对该实例变量的修改则又会引发线程安全问题。这种情况别说是jav
JVM学习笔记001：内存结构
耿鬼不会笑的博客
04-18 319
黑马程序员：JVM学习笔记整理 本博客根据 解密JVM【黑马程序员出品】 教学视频整理记录，仅用于个人/学习交流使用 一、什么是JVM 1、定义 Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境） 2、好处 一次编写，到处运行 自动内存管理，垃圾回收机制 数组下标越界检查 3、比较 JVM JRE JDK的区别 二、内存结构 0、整体架构 1、程序计数器 作用 用于保存JVM中下一条所要执行的指令的地址 特点 线程私有 （每个线程都有自己的
深入理解java虚拟机1——内存结构
qq_41157876的博客
08-02 457
第二章 2.2 内存结构 1.方法区 它用于存储已被虚拟机加载 的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据 运行时常量池：Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池表（Constant Pool Table），用于存放编译期生 成的各种字面量与符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。 当常量池无法再申请到内存 时会抛出OutOfMemoryError异常 共享
类的实例中的私有成员是否线程安全--实例
阿勇的博客
08-21 2597
// 本程序用来说明 类的实例中的私有成员是否线程安全 public class Zy_thread_test1  {     public static void main(String[] args)      {         hello  tHello=new hello(); //这里创建一个对象                     for(int j=0;j&lt;5;...
Java虚拟机入门，内存结构详解
weixin_46065854的博客
07-12 398
JVM；JRE和JDK；JVM的位置；JVM的内存结构：方法区 (Method Area)、堆、虚拟机栈、本地方法栈、程序计数器；常量池、运行时常量池和字符串常量池；新生代、年轻代和老年代
JVM中有哪些内存区域及其作用
08-25
主要介绍了JVM中有哪些内存区域，分别是用来干什么的,vm内又是如何划分内存的呢？这个内被加载到了那一块内存中？,需要的朋友可以参考下
一文读懂什么是JVM内存区域
01-20
一、什么叫做java内存区域 1、什么是内存？ 在计算机硬件中，内存指的是cpu运算时，用于暂时存放cpu运算过程中的数据的区域，主要负责从固存中提取cpu运算需要的数据并将cpu运算结果如要保存到固定存储中则保存的一...
JVM前世今生和内存区域
06-26
讲述JVM的基础概念
学习JVM之java内存区域与异常
09-01
关于JVM内存区域的知识对于初学者来说其实是很重要的，了解Java内存分配的原理，这对于以后JAVA的学习会有更深刻的理解。下面来看看详细介绍。
基于jvm java内存区域的介绍
08-30
下面小编就为大家带来一篇基于jvm java内存区域的介绍。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java多线程中static变量的使用
weixin_34290352的博客
08-10 1708
有时候，对于在多线程中使用static变量有没有冲突，是否存在安全问题不能十分的确定。在使用过程中有点含糊，总想找点时间好好追究一下，可总因开发项目时间的紧迫而搁浅。我想，没有做进一步的研究而拿项目繁忙说事，这是自己的借口吧！鲁迅先生曾说过：“时间就像海绵里的水，只要愿挤，总还是有的”。不管肿(怎)么说，这事还是要做的啊。如果越往后推，可能造成的潜在影...
Java内存结构分析
u010257931的博客
07-03 2225
局部变量表存放了编译器可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象应用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是一个代表对象句柄或其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。局部变量表所需的内存空间在编译期间完成分配，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表的大小。
java—JVM结构和内存分布
qq_40177185的博客
08-19 409
java虚拟机内存结构
Java 多线程访问成员变量与局部变量
u010395804的专栏
07-24 817
public class HelloThreadTest { public static void main(String[] args) { HelloThread r = new HelloThread(); Thread t1 = new Thread(r); Thread t2 = new Thread(r);
类私有变量在并发情况下的变化问题
liuzi1990的博客
03-15 870
    前段时间做的一个增值税发票扫描识别项目，用的SSM框架，部署在weblogic应用服务器上。    需要在登录的时候选择登录人所属公司id，并在登录成功后保存在session里，但在用类私有变量声明所属公司id后，真正在生产环境使用取值时，多用户并发访问会出现所属公司id混乱现象，因为私有变量在另一个线程使用时会重新赋值，以后再次切换到自身的线程时这个私有变量仍然是前一个线程赋的值，故需要...
Java 虚拟机内存结构
mywaya2333的博客
11-01 368
jvm内存結構
Java虚拟机内存结构——JDK1.8
lihongtai的专栏
10-20 1856
一、Java虚拟机整体结构 二、JVM内存结构 (1)线程私有部分 1.本地方法栈：登记native方法，在执行引擎执行时加载本地方法库 2.程序计数器：就是一个指针，存储指向下一条指令的地址 ,由执行引擎读取下一条指令， 是一个非常小的空间，可以忽略不计 - 程序计数器的原因时CPU执行线程的时间分片导致的 3.java栈：Java线程...
JAVA的内存结构
热门推荐
黄雄杰
08-01 2万+
1、运行时数据区 JVM所管理的内存包括以下几个运行时数据区域，如图所示 方法区和堆为线程共享区，虚拟机栈、本地方法栈及程序计数器为线程独占区。 程序计数器 程序计数器是一块较小的空间，它可以看作是当前线程所执行的字节码的行号指示器。 如果线程执行的是java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址（可以理解为上图所...
什么是jvm内存模型
最新发布
09-07
JVM内存模型是指Java虚拟机将内存划分为不同的区域，以存储不同类型的数据和实现不同的功能。JVM内存模型包括以下几个部分： 1. 程序计数器：程序计数器用于记录当前线程执行的字节码指令位置，是线程私有的内存...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

涛歌依旧fly

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

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

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

打赏作者

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

抵扣说明：

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

余额充值