JVM(1.简单的概念)

最新推荐文章于 2024-10-30 21:25:31 发布
最新推荐文章于 2024-10-30 21:25:31 发布
阅读量115 收藏
点赞数
文章标签： jvm java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47109099/article/details/126030779
版权

JVM

JVM内存结构

JVM内存

虚拟机栈
Java 栈

Java 虚拟机栈：Java Virtual Machine Stacks，每个线程运行时所需要的内存

  • 每个方法被执行时，都会在虚拟机栈中创建一个栈帧 stack frame（一个方法一个栈帧）

  • Java 虚拟机规范允许 Java 栈的大小是动态的或者是固定不变的

  • 虚拟机栈是每个线程私有的，每个线程只能有一个活动栈帧，对应方法调用到执行完成的整个过程

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

    • 局部变量表：存储方法里的 Java 基本数据类型以及对象的引用
    • 动态链接：也叫指向运行时常量池的方法引用
    • 方法返回地址：方法正常退出或者异常退出的定义
    • 操作数栈或表达式栈和其他一些附加信息

设置栈内存大小：-Xss size -Xss 1024k

  • 在 JDK 1.4 中默认为 256K，而在 JDK 1.5+ 默认为 1M

虚拟机栈特点：

  • 栈内存不需要进行GC，方法开始执行的时候会进栈，方法调用后自动弹栈，相当于清空了数据

  • 栈内存分配越大越大，可用的线程数越少（内存越大，每个线程拥有的内存越大）

  • 方法内的局部变量是否线程安全：

    • 如果方法内局部变量没有逃离方法的作用访问，它是线程安全的（逃逸分析）
    • 如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

异常：

  • 栈帧过多导致栈内存溢出 （超过了栈的容量），会抛出 OutOfMemoryError错误
  • 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 错误
局部变量

局部变量表也被称之为局部变量数组或本地变量表，本质上定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量

  • 表是建立在线程的栈上，是线程私有的数据，因此不存在数据安全问题
  • 表的容量大小是在编译期确定的，保存在方法的 Code 属性的 maximum local variables 数据项中
  • 表中的变量只在当前方法调用中有效，方法结束栈帧销毁，局部变量表也会随之销毁
  • 表中的变量也是重要的垃圾回收根节点，只要被表中数据直接或间接引用的对象都不会被回收

局部变量表最基本的存储单元是 slot（变量槽）：

  • 参数值的存放总是在局部变量数组的 index0 开始，到数组长度 -1 的索引结束，JVM 为每一个 slot 都分配一个访问索引，通过索引即可访问到槽中的数据
  • 存放编译期可知的各种基本数据类型（8种），引用类型（reference），returnAddress 类型的变量
  • 32 位以内的类型只占一个 slot（包括 returnAddress 类型），64 位的类型（long 和 double）占两个 slot
  • 局部变量表中的槽位是可以重复利用的，如果一个局部变量过了其作用域，那么之后申明的新的局部变量就可能会复用过期局部变量的槽位，从而达到节省资源的目的
操作数栈

栈：可以使用数组或者链表来实现

操作数栈：在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）或出栈（pop）

  • 保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间，是执行引擎的一个工作区

  • Java 虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈

  • 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中

栈顶缓存技术 ToS（Top-of-Stack Cashing）：将栈顶元素全部缓存在 CPU 的寄存器中，以此降低对内存的读/写次数，提升执行的效率

基于栈式架构的虚拟机使用的零地址指令更加紧凑，完成一项操作需要使用很多入栈和出栈指令，所以需要更多的指令分派（instruction dispatch）次数和内存读/写次数，由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度，所以需要栈顶缓存技术

动态链接

动态链接是指向运行时常量池的方法引用，涉及到栈操作已经是类加载完成，这个阶段的解析是动态绑定

  • 为了支持当前方法的代码能够实现动态链接，每一个栈帧内部都包含一个指向运行时常量池或该栈帧所属方法的引用

    [外链图片转存中…(img-40Zfh1tb-1658977927894)]

  • 在 Java 源文件被编译成的字节码文件中，所有的变量和方法引用都作为符号引用保存在 class 的常量池中

    常量池的作用：提供一些符号和常量，便于指令的识别

    [外链图片转存中…(img-yDv5SyPY-1658977927895)]

返回地址

Return Address：存放调用该方法的 PC 寄存器的值

方法的结束有两种方式：正常执行完成、出现未处理的异常，在方法退出后都返回到该方法被调用的位置

  • 正常：调用者的 PC 计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址
  • 异常：返回地址是要通过异常表来确定

正常完成出口：执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者

异常完成出口：方法执行的过程中遇到了异常（Exception），并且这个异常没有在方法内进行处理，本方法的异常表中没有搜素到匹配的异常处理器，导致方法退出

两者区别：通过异常完成出口退出的不会给上层调用者产生任何的返回值

附加信息

栈帧中还允许携带与 Java 虚拟机实现相关的一些附加信息，例如对程序调试提供支持的信息

本地方法栈

本地方法栈是为虚拟机执行本地方法时提供服务的

JNI：Java Native Interface，通过使用 Java 本地接口书写程序，可以确保代码在不同的平台上方便移植

  • 不需要进行 GC，与虚拟机栈类似，也是线程私有的，有 StackOverFlowError 和 OutOfMemoryError 异常

  • 虚拟机栈执行的是 Java 方法，在 HotSpot JVM 中，直接将本地方法栈和虚拟机栈合二为一

  • 本地方法一般是由其他语言编写，并且被编译为基于本机硬件和操作系统的程序

  • 当某个线程调用一个本地方法时，就进入了不再受虚拟机限制的世界，和虚拟机拥有同样的权限

    • 本地方法可以通过本地方法接口来访问虚拟机内部的运行时数据区
    • 直接从本地内存的堆中分配任意数量的内存
    • 可以直接使用本地处理器中的寄存器

图片来源：https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20%E8%99%9A%E6%8B%9F%E6%9C%BA.md

程序计数器

Program Counter Register 程序计数器（寄存器）

作用：内部保存字节码的行号，用于记录正在执行的字节码指令地址（如果正在执行的是本地方法则为空）

原理：

  • JVM 对于多线程是通过线程轮流切换并且分配线程执行时间，一个处理器只会处理执行一个线程
  • 切换线程需要从程序计数器中来回去到当前的线程上一次执行的行号

特点：

  • 是线程私有的
  • 不会存在内存溢出，是 JVM 规范中唯一一个不出现 OOM 的区域，所以这个空间不会进行 GC

Java 反编译指令：

javap -v Test.class

#20：代表去 Constant pool 查看该地址的指令

0: getstatic #20 		// PrintStream out = System.out;
3: astore_1 			// --
4: aload_1 				// out.println(1);
5: iconst_1 			// --
6: invokevirtual #26 	// --
9: aload_1 				// out.println(2);
10: iconst_2 			// --
11: invokevirtual #26 	// --
堆

Heap 堆：是 JVM 内存中最大的一块，由所有线程共享，由垃圾回收器管理的主要区域，堆中对象大部分都需要考虑线程安全的问题

存放哪些资源：

  • 对象实例：类初始化生成的对象，基本数据类型的数组也是对象实例，new 创建对象都使用堆内存
  • 字符串常量池：
    • 字符串常量池原本存放于方法区，JDK7 开始放置于堆中
    • 字符串常量池存储的是 String 对象的直接引用或者对象，是一张 string table
  • 静态变量：静态变量是有 static 修饰的变量，JDK8 时从方法区迁移至堆中
  • 线程分配缓冲区 Thread Local Allocation Buffer：线程私有但不影响堆的共性，可以提升对象分配的效率

设置堆内存指令：-Xmx Size

内存溢出：new 出对象，循环添加字符数据，当堆中没有内存空间可分配给实例，也无法再扩展时，就会抛出 OutOfMemoryError 异常

堆内存诊断工具：（控制台命令）

  1. jps：查看当前系统中有哪些 Java 进程
  2. jmap：查看堆内存占用情况 jhsdb jmap --heap --pid 进程id
  3. jconsole：图形界面的，多功能的监测工具，可以连续监测

在 Java7 中堆内会存在年轻代、老年代和方法区（永久代）：

  • Young 区被划分为三部分，Eden 区和两个大小严格相同的 Survivor 区。Survivor 区某一时刻只有其中一个是被使用的，另外一个留做垃圾回收时复制对象。在 Eden 区变满的时候，GC 就会将存活的对象移到空闲的 Survivor 区间中，根据 JVM 的策略，在经过几次垃圾回收后，仍然存活于 Survivor 的对象将被移动到 Tenured 区间
  • Tenured 区主要保存生命周期长的对象，一般是一些老的对象，当一些对象在 Young 复制转移一定的次数以后，对象就会被转移到 Tenured 区
  • Perm 代主要保存 Class、ClassLoader、静态变量、常量、编译后的代码，在 Java7 中堆内方法区会受到 GC 的管理

分代原因：不同对象的生命周期不同，70%-99% 的对象都是临时对象，优化 GC 性能

public static void main(String[] args) {
    // 返回Java虚拟机中的堆内存总量
    long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
    // 返回Java虚拟机使用的最大堆内存量
    long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;
    
    System.out.println("-Xms : " + initialMemory + "M");//-Xms : 245M
    System.out.println("-Xmx : " + maxMemory + "M");//-Xmx : 3641M
}
方法区

方法区：是各个线程共享的内存区域，用于存储已被虚拟机加载的类信息、常量、即时编译器编译后的代码等数据，虽然 Java 虚拟机规范把方法区描述为堆的一个逻辑部分，但是也叫 Non-Heap（非堆）

方法区是一个 JVM 规范，永久代与元空间都是其一种实现方式

方法区的大小不必是固定的，可以动态扩展，加载的类太多，可能导致永久代内存溢出 (OutOfMemoryError)

方法区的 GC：针对常量池的回收及对类型的卸载，比较难实现

为了避免方法区出现 OOM，在 JDK8 中将堆内的方法区（永久代）移动到了本地内存上，重新开辟了一块空间，叫做元空间，元空间存储类的元信息，静态变量和字符串常量池等放入堆中

类元信息：在类编译期间放入方法区，存放了类的基本信息，包括类的方法、参数、接口以及常量池表

常量池表（Constant Pool Table）是 Class 文件的一部分，存储了类在编译期间生成的字面量、符号引用，JVM 为每个已加载的类维护一个常量池

  • 字面量：基本数据类型、字符串类型常量、声明为 final 的常量值等
  • 符号引用：类、字段、方法、接口等的符号引用

运行时常量池是方法区的一部分

  • 常量池（编译器生成的字面量和符号引用）中的数据会在类加载的加载阶段放入运行时常量池
  • 类在解析阶段将这些符号引用替换成直接引用
  • 除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()

本地内存

基本介绍

虚拟机内存：Java 虚拟机在执行的时候会把管理的内存分配成不同的区域，受虚拟机内存大小的参数控制，当大小超过参数设置的大小时就会报 OOM

本地内存：又叫做堆外内存，线程共享的区域，本地内存这块区域是不会受到 JVM 的控制的，不会发生 GC；因此对于整个 Java 的执行效率是提升非常大，但是如果内存的占用超出物理内存的大小，同样也会报 OOM

本地内存概述图：

元空间

PermGen 被元空间代替，永久代的类信息、方法、常量池等都移动到元空间区

元空间与永久代区别：元空间不在虚拟机中，使用的本地内存，默认情况下，元空间的大小仅受本地内存限制

方法区内存溢出：

  • JDK1.8 以前会导致永久代内存溢出：java.lang.OutOfMemoryError: PerGen space

     -XX:MaxPermSize=8m		#参数设置

  • JDK1.8 以后会导致元空间内存溢出：java.lang.OutOfMemoryError: Metaspace

    -XX:MaxMetaspaceSize=8m	#参数设置

元空间内存溢出演示：

public class Demo1_8 extends ClassLoader { // 可以用来加载类的二进制字节码
    public static void main(String[] args) {
        int j = 0;
        try {
            Demo1_8 test = new Demo1_8();
            for (int i = 0; i < 10000; i++, j++) {
                // ClassWriter 作用是生成类的二进制字节码
                ClassWriter cw = new ClassWriter(0);
                // 版本号， public， 类名, 包名, 父类， 接口
                cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                // 返回 byte[]
                byte[] code = cw.toByteArray();
                // 执行了类的加载
                test.defineClass("Class" + i, code, 0, code.length); // Class 对象
            }
        } finally {
            System.out.println(j);
        }
    }
}
直接内存

直接内存是 Java 堆外、直接向系统申请的内存区间，不是虚拟机运行时数据区的一部分，也不是《Java 虚拟机规范》中定义的内存区域

直接内存详解参考：NET → NIO → 直接内存

变量位置

变量的位置不取决于它是基本数据类型还是引用数据类型，取决于它的声明位置

静态内部类和其他内部类：

  • 一个 class 文件只能对应一个 public 类型的类，这个类可以有内部类，但不会生成新的 class 文件

  • 静态内部类属于类本身，加载到方法区，其他内部类属于内部类的属性，加载到堆（待考证）

类变量：

  • 类变量是用 static 修饰符修饰，定义在方法外的变量，随着 Java 进程产生和销毁
  • 在 Java8 之前把静态变量存放于方法区，在 Java8 时存放在堆中的静态变量区

实例变量：

  • 实例（成员）变量是定义在类中，没有 static 修饰的变量，随着类的实例产生和销毁，是类实例的一部分
  • 在类初始化的时候，从运行时常量池取出直接引用或者值，与初始化的对象一起放入堆中

局部变量：

  • 局部变量是定义在类的方法中的变量
  • 在所在方法被调用时放入虚拟机栈的栈帧中，方法执行结束后从虚拟机栈中弹出，

类常量池、运行时常量池、字符串常量池有什么关系？有什么区别？

  • 类常量池与运行时常量池都存储在方法区，而字符串常量池在 Jdk7 时就已经从方法区迁移到了 Java 堆中
  • 在类编译过程中，会把类元信息放到方法区，类元信息的其中一部分便是类常量池，主要存放字面量和符号引用，而字面量的一部分便是文本字符
  • 在类加载时将字面量和符号引用解析为直接引用存储在运行时常量池
  • 对于文本字符，会在解析时查找字符串常量池，查出这个文本字符对应的字符串对象的直接引用，将直接引用存储在运行时常量池

什么是字面量？什么是符号引用？

  • 字面量：java 代码在编译过程中是无法构建引用的，字面量就是在编译时对于数据的一种表示

    int a = 1;				//这个1便是字面量
String b = "iloveu";	//iloveu便是字面量

  • 符号引用：在编译过程中并不知道每个类的地址，因为可能这个类还没有加载，如果在一个类中引用了另一个类，无法知道它的内存地址，只能用它的类名作为符号引用，在类加载完后用这个符号引用去获取内存地址

 system.in.read()

线程运行诊断

cpu 占用过多

  • 定位
  • 用top定位哪个进程对cpu的占用过高
  • ps H -eo pid,tid,%cpu | grep 进程id （用ps命令进一步定位是哪个线程引起的cpu占用过高）
  • jstack 进程id

​ 可以根据线程id 找到有问题的线程，进一步定位到问题代码的源码行号

堆内存诊断

  1. jps 工具
  • 查看当前系统中有哪些 java 进程
  1. jmap 工具
  • 查看堆内存占用情况 jmap - heap 进程id
  1. jconsole 工具
  • 图形界面的，多功能的监测工具，可以连续监测

方法区内存溢出

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

StringTable特性

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

GC

查看GC机制:jmap -dump:format=b,live,file=文件名.bin 进程ID

引用计数法

被引用计数+1 如果某个变量不再引用它就-1 变为0则可以被回收**缺点:**循环引用

可达性分析算法

JVM中的垃圾回收期是采用可达性分析算法来探索所有存活的对象:扫描堆中的对象看是否能够沿着GC Root对象作为起点为引用链找到该对象,若找不到则可以回收(本ROOT对象直接或间接引用的对象不可以被回收)

局部变量引用的对象可以作为根对象

方法参数可以作为跟对象

ROOT对象的分类:系统类,本地方法(操作系统的方法),运行的线程,以及锁

四种引用

强引用,软引用,弱引用,虚引用,终结器引用

1.强引用

  • 当没有强引用的时候,直接引用ROOT对象被称之为强引用不会被垃圾回收的对象

2.软引用

  • 当没有强引用的时候,如果内存充足,当发生垃圾回收的时候是不会被回收的,但当内存不足的时候发生垃圾回收的时候是会被垃圾回收的
  • 需要配合引用队列来释放软引用自身
  • 软引用对象:SoftReference

3.弱引用

  • 当发生垃圾回收的时候,一定会被垃圾回收的 (不管内存是否充足)
  • 需要配合引用队列来释放弱引用自身
  • 弱引用对象:WeakReference 例:list --> WeakReference --> byte[]

当被软引用和弱引用创建的时候分配了引用队列,那么当软弱引用引用的对象被回收时,软弱引用将会进入到该引用队列中,(优点:软弱引用也需要占用一定的内存,如果需要操作软弱引用占的内存,那就需要用引用队列来找到这两个引用)

4.虚引用

  • 需要配合引用队列使用,主要配合ByteBuffer使用,虚引用引用的的对象被垃圾回收时,虚引用对象自己就会放入引用队列,就会有间接的一个线程(Reference Handler线程)去调用虚引用相关方法直接释放内存

5.终结器引用

  • finalliz()方法,当对象重写了finalliz()方法并且当没有强引用引用它时,就可以被垃圾方法回收. 这个地方就用到终结器引用当没有强引用引用对象时,这个对象会有虚拟机来创建终结器引用,当对象被垃圾回收时,终结器引用就会进入到引用队列(这个对象还没有被垃圾回收),再由一个优先级很低的线程(Finalizer线程)会在后一时刻去查看引用队列中是否存在终结器引用,当发现有终结器引用时就会找到该对象去调用他的finalliz()方法,那么在下一次垃圾回收的时候就会回收该对象.

虚引用与终结器引用创建时必须要关联引用队列来使用

6.用引用队列配合软引用使用,进行清理

引用队列

//引用队列
RederenceQueue<byte[]> queue = new RederenceQueue<byte[]>;
//关联了引用队列,当软引用所关联的byte[]被回收时,软引用会自己加入到queue中
SoftReference<byte[]> ref = new SoftReference<byte[]>(new byte[1024*4*1024],queue);
Reference<? extends byte[]> poll = queue.poll();
while(poll != null){
    list.remove(poll);
    poll = queue.poll();
}

垃圾回收算法

1.标记清除算法

  • 工作方式:先标记然后进行垃圾回收的时候再清除,清除不是直接清零处理,是把这个这个对象起始结束的地址记录下来,放在空闲的地址列表里,下载分配新的对象的时候就会在地址列表里去找,看有没有足够的地址空间结束新的对象,如果有就会进行内存分配,并不会对占用的内存进行清零的处理

优点:垃圾回收的速度快 缺点:空间不连续,会产生内存碎片

2.标记整理算法

  • 在垃圾清理的时候,可用的内存碎片要移动,使内存更为紧凑一点

  • 避免标记清除算法的空间不连续产生内存碎片的问题

  • **缺点:**对象需要移动,效率会比较低

3.复制算法

  • 缺点:会占用双倍的内存空间

分代回收

三种垃圾回收算法,视情况而定---------------------------------->分代回收

  1. 新生代 ---- > 垃圾回收执行的比较频繁 Minor GC

    • 伊甸园
    • 幸存区From
    • 幸存区 To

  2. 老年代 — >垃圾回收执行的频率比较低 Full GC

  • 对象首先分配在伊甸园区域
  • 新生代空间不足时,触发minor gc,伊甸园和from存活的对象copy到to中,存活的对象年龄也要加1,并且交换from to
  • minor gc 会引发 stop the world(STW暂停其他用户线程),等垃圾回收结束,用户线程才恢复运行
  • 当对象寿命超过阈值时,会晋升值老年代,最大寿命是15(4bit)
  • 当老年代空间不足,会先尝试触发minor gc,如果之后空间仍不足,那么触发full gc(STW的时间更长)如果full gc执行后空间还是不足的话就会报:内存溢出 java.lang.OutOfMemoryError: PermGen space

----------------------->分代回收

  1. 新生代 ---- > 垃圾回收执行的比较频繁 Minor GC

    • 伊甸园
    • 幸存区From
    • 幸存区 To

  2. 老年代 — >垃圾回收执行的频率比较低 Full GC

  • 对象首先分配在伊甸园区域
  • 新生代空间不足时,触发minor gc,伊甸园和from存活的对象copy到to中,存活的对象年龄也要加1,并且交换from to
  • minor gc 会引发 stop the world(STW暂停其他用户线程),等垃圾回收结束,用户线程才恢复运行
  • 当对象寿命超过阈值时,会晋升值老年代,最大寿命是15(4bit)
  • 当老年代空间不足,会先尝试触发minor gc,如果之后空间仍不足,那么触发full gc(STW的时间更长)如果full gc执行后空间还是不足的话就会报:内存溢出 java.lang.OutOfMemoryError: PermGen space

对于OopMap与安全点和安全区域与RememberedSet 理解请看我的这篇Blog:
OopMap与安全点和安全区域与RememberedSet 理解

唯莹~
关注
初识JVM – JVM概念.pdf
05-31
### 初识JVM – JVM概念 #### 一、JVM简介 JVM，即Java Virtual Machine（Java虚拟机），是一种能够执行特定机器指令的虚拟机。它通过软件模拟了一个完整的计算机系统，允许Java程序在任何支持JVM的平台上运行而...
JVM基础.doc
09-18
本节将详细介绍JVM的基本概念及其核心技术——HotSpot。 **HotSpot VM** 是Oracle公司提供的一个高性能Java虚拟机实现，它具有以下特点： - **主要实现语言**：C++ - **执行模式**：采用了解释器和编译器混合的工作...
JVM面试.docx
03-08
### JVM核心概念与内部结构 #### 一、JVM简介 Java虚拟机（JVM, Java Virtual Machine）是一种用于执行Java字节码的虚拟机，它位于硬件与操作系统之上，提供了一个运行Java程序的安全隔离环境。JVM的主要作用是...
JVM原理.pdf
07-24
类加载机制是Java语言中的一个核心概念，它负责将.class文件加载到内存中，创建对应的java.lang.Class对象。JVM将类加载过程分为加载、链接（验证、准备、解析）、初始化三个阶段。这个过程是动态的，它允许程序在...
JVM原理.docx
03-08
### JVM原理核心知识点详解 ...综上所述，Java虚拟机的原理不仅涉及其生命周期和体系结构的基本概念，还包括类加载过程以及内存管理和垃圾回收等关键方面。了解这些原理对于深入理解Java程序的运行机制至关重要。
高级java每日一道面试题-2024年10月23日-JVM篇-说一下JVM有哪些垃圾回收算法?
qq_43071699的博客
10-25 1012
以上是 Java 虚拟机中常用的几种垃圾回收算法。每种算法都有自己的特点和适用场景。理解这些算法对于优化 Java 应用程序的性能非常重要。在实际应用中，JVM 会根据堆的大小、对象的存活率等因素选择最适合的垃圾回收策略。
【jvm】jvm对象都分配在堆上吗
王佑辉的博客
10-26 314
1.方法区（Method Area）或称为永久代（PermGen space，在JDK 8之前）或元空间（Metaspace，在JDK 8及之后）是JVM用于存储类的结构信息的内存区域。如果一个对象可以被拆解为多个标量（如基本数据类型），并且这些标量可以在栈上独立使用，那么JVM会将这些标量直接分配到栈上，而不是创建一个对象。3.方法区不是用于存储对象实例的，但一些与类相关的特殊对象（如类的静态变量、常量池中的字符串和符号引用等）会存储在方法区中。2.当创建一个新的对象时，JVM通常会在堆上为其分配内存。
面试题：JVM（一）
2301_79526467的博客
10-24 798
1. JVM概述 　 1.1 JVM的生命周期 　 1.2 简述JVM 　 1.3 能否画出JVM架构图？ 2. 字节码概述 　 2.1 字节码文件是跨平台的么？ 　 2.2 哪些类型有对应Class对象？ 3. Class文件结构 4. 字节码指令 　 4.1 概述 　 4.2 面试题
《JVM第3课》运行时数据区
避免专业名词，喜欢讲人话。
10-30 262
可分为 5 个区域，分别是方法区、堆区、虚拟机栈、本地方法栈、程序计数器。
【JVM 深入了解】JVM 到底包含什么？
激流丶的博客
10-30 850
博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主。
直接内存、死锁、方法句柄
xq514863的博客
10-28 278
当td1醒来兵尝试获取o2的锁时，它会被阻塞，因为o2的锁已经被td2持有，同样地，当td2醒来兵尝试获取o1的锁时，因为o1的锁已经被td1持有，这样，两个线程都陷入了等待状态，形成了死锁。7. 由于直接内存在Java堆外，因此它的大小不会直接受限于-Xmx指定的最大堆大小，但是系统内存是有限的，Java堆和直接内存的总和依然受限于操作系统能给出的最大内存。当flag为1时，线程首选获取o1锁，休眠500毫秒，然后尝试获取o2的锁，如果成功过，则打印"1".不受JVM内存回收管理。
【jvm】堆的默认最大值和默认最小值的计算
王佑辉的博客
10-30 295
虽然JVM会根据物理内存大小计算默认的堆大小，但系统资源限制（如操作系统对进程内存的限制）可能会影响JVM实际能够使用的堆大小。1.JVM（Java虚拟机）堆的默认最大值和默认最小值的计算主要依赖于系统的物理内存大小以及JVM的类型（客户端JVM或服务器JVM）。2.在64位JVM上，如果有128GB或更多的物理内存，默认的最大堆大小最大可以为32GB（或更高，具体取决于JVM版本和配置）。1.默认值通常是物理内存的1/64（在物理内存小于1GB的情况下）或更高的值（在物理内存足够大的情况下）。
【jvm】堆的内部结构
王佑辉的博客
10-26 545
2.在发生Minor GC（年轻代垃圾回收）时，存活的对象会从Eden区和当前的Survivor区（比如S0）复制到另一个Survivor区（比如S1），然后清空原来的区域。1.JVM堆的内部结构主要包括年轻代（Young Generation）和老年代（Old Generation），这种划分是基于对象的存活时间和使用特点来进行的。1.当年轻代中的对象存活时间较长，或者年轻代空间不足无法容纳新生成的对象时，这些对象会被转移到老年代中。2.Eden区是年轻代中最大的区域，用于存放大多数新生成的对象。
《JVM第4课》程序计数器
避免专业名词，喜欢讲人话。
10-30 226
Java程序计数器（Program Counter Register）是Java虚拟机（JVM）运行数据区的一个组成部分。每个线程都有它自己的程序计数器，这部分内存用于存储该线程下一条要执行的字节码指令的地址。如果该方法为本地方法（Native Method），则程序计数器的值为未定义。
【jvm】如何设置新生代和老年代的比例
最新发布
王佑辉的博客
10-30 365
例如，-XX:SurvivorRatio=4表示Eden区与Survivor区的比例为4:1:1（因为有两个Survivor区，所以实际比例是8:2:2，但通常简化为8:1:1来表示）。4.设置方法：例如，要设置新生代与老年代的比例为1:3，可以使用-XX:NewRatio=3。3.默认值：默认情况下，-XX:NewRatio的值为2，表示老年代与新生代的比例为2:1，即新生代占堆内存的1/3，老年代占2/3。3.-XX:NewRatio=3 设置老年代与新生代的比例为3:1，即新生代占堆内存的1/4。
嵌入式刷题（day21）
m0_49476241的博客
10-27 169
MySQL：适合需要高并发、多用户、多功能的应用，尤其是分布式和需要大量复杂查询的系统。SQLite：适合嵌入式应用、单用户系统、轻量级应用、测试环境或快速原型开发。原子操作（Atomic Operation）是指一种不可分割的操作，在计算机系统中它要么完全执行成功，要么完全不执行，即使在多线程或多进程环境下也不会被中断或打断。它是实现并发编程中线程安全的重要基础。101000// 使用 GCC 的 __sync_fetch_and_add 实现原子递增i++) {// 原子加 1。
Java虚拟机的历程（jvm01）
dhrmt的博客
10-27 1043
Java虚拟机（JVM）作为Java语言的核心技术之一，自诞生以来经历了多次迭代与演变。不同的虚拟机在性能、功能以及适用场景上各有侧重。
【JVM】——JVM运行机制、类加载机制、内存划分
阿华的博客
10-27 866
JVM运行机制，堆栈，程序计数器，元数据区，JVM加载机制，双亲委派模型
重新架构：从 Redis 到 SQLite 性能提升
极道Jdon的技术博客
10-25 879
最重要的是，如果您处于云环境中，那么您需要考虑网络延迟。因此，尽管我们付出了艰辛的努力和编写代码以尽可能快地获得 v1 客户端，但我们经常会遇到这样的情况：尽管我们尽了最大努力，但由于应用所配置的网络速度很慢，我们仍然会减慢应用的速度。我见过的每一个翻转数据库基准测试都被一层星号和限定词所覆盖，HN 上的评论充满了“如果你在编译时设置这个标志，你的读取速度就会提高 3%，而运行这个的人没有这样做这一事实证明他们得到了贿赂，并且他们积极出售疯狂的游艇摇滚 Harambe 模因的阴暗 NFT 骗局。
JVM调优精华：概念与实战
本总结涵盖了JVM调优的基本概念、垃圾回收算法、调优策略以及一些实际配置案例。 1.1 JVM调优的基本概念 - 类加载机制：JVM将字节码加载到内存中，并进行类的初始化，包括加载、验证、准备、解析和初始化五个阶段。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值