JVM-java虚拟机

已于 2023-04-08 16:08:29 修改
阅读量323 收藏
点赞数
文章标签： jvm
于 2022-07-14 15:23:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60875109/article/details/125780562
版权

目录

jvm组成部分

---------------------------------内存结构-----------------------------------------

1. 程序计数器

1.1 定义

1.2 特点

1.3 作用

1.4 java代码执行流程

2. 虚拟机栈

2.1 定义

​编辑

2.2 栈内存溢出

2.3 线程运行诊断

3. 本地方法栈

4.堆

4.1 定义

4.2 堆内存溢出

4.3 堆内存诊断

5. 方法区

5.1 定义

5.2 组成

5.3 方法区内存溢出

5.4 运行时常量池

5.5 StringTable 特性

5.6 StringTable 位置

5.7 StringTable 垃圾回收

5.8 StringTable 性能调优

6. 直接内存

6.1 定义

6.2 分配和回收原理

----------------------------------垃圾回收----------------------------------------

1. 如何判断对象可以回收

1.1 引用计数法

1.2 可达性分析算法

1.3 四种引用

强引用

软引用（SoftReference）

弱引用（WeakReference）

虚引用（PhantomReference）

2. 垃圾回收算法

2.1 标记清除

2.2 标记整理

2.3 复制

3. 分代垃圾回收

3.1 相关VM参数

3.2 GC分析

3.3 GC分析之大对象

4. 垃圾回收器

4.1串行（Serial）垃圾回收器

4.2并行（Parallel）垃圾回收器（吞吐量优先）

4.3响应时间（CMS）优先垃圾回收器

4.4 G1垃圾回收器

-----------------------类加载与字节码技术------------------------------------

1. 类文件结构

1.1 魔数

1.2 版本

1.3 常量池Constant

5. 类加载器

5.1 启动类加载器

5.2 扩展类加载器

5.3 双亲委派模式

5.3.1 如何打破双亲委派机制

5.4 线程上下文类加载器

5.5 自定义类加载器

5.5.1 什么时候需要自定义类加载器

5.5.2 步骤：

5.5.3 示例

-----------------------------------内存模型---------------------------------------

1. java 内存模型

1.1 原子性

1.2 问题分析

 1.3 解决方法

2. 可见性

2.1 退不出的循环

 2.2 解决方法

2.3 可见性

3. 有序性

3.1 诡异的结果

3.2 解决方法

3.3 有序性理解

 4. CAS 与 原子类

4.1 CAS

4.2 乐观锁与悲观锁

 4.3 原子操作类​​​​​​​

jvm组成部分

---------------------------------内存结构-----------------------------------------

  1. 程序计数器
  2. 虚拟机栈
  3. 本地方法栈
  4. 堆
  5. 方法区

1. 程序计数器

1.1 定义

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

1.2 特点

是线程私有的，每个线程都会有自己的程序计数器。

不会存在内存溢出，唯一一个不会存在内存溢出的区，堆，栈，方法区等均会出现内存溢出。

1.3 作用

作用是记住下一条jvm指令的执行地址。

1.4 java代码执行流程

java源代码会编译成二进制字节码，二进制字节码会被解释器变成机器码，其中程序计数器的作用是记住下一条指令的执行地址，且程序计时器采用处理速度最快的寄存器，机器码交给CPU执行。

2. 虚拟机栈

2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

  • 每个线程运行时所需要的内存，称为虚拟机栈。

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

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

问题辨析：

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

不会，栈内存由每个栈帧内存组成，栈帧内存是在每个方法调用时入栈被使用，方法调用结束后弹出栈，所以不会被垃圾回收。

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

不是，我们物理内存的大小是一定的，所以当栈内存划分过大时，会时线程数减少，从而降低程序性能。

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

如果局部变量没有逃离该方法的作用范围则是线程安全的。

如果局部变量引用了对象，并且逃离了该方法的作用范围（局部变量的引用是传入的参数或者是返回值），则需要考虑线程安全问题。

package cn.itcast.jvm.t1.stack;
​
/**
 * 局部变量的线程安全问题
 */
public class Demo1_17 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append(4);
        sb.append(5);
        sb.append(6);
        new Thread(()->{
            m2(sb);
        }).start();
    }
​//线程安全，sb属于方法局部变量，其他线程不能访问到该变量，所以线程是安全的
    public static void m1() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }
​//线程不安全，可能被其他线程调用修改传入的参数sb的值
    public static void m2(StringBuilder sb) {
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }
​//线程不安全，可能被其他线程调用返回的结果sb
    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;
    }
}

2.2 栈内存溢出

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

  • 栈帧过大导致栈内存溢出。（默认1m，不太容易出现）

应用场景：

  • 递归调用没有写结束条件。

package cn.itcast.jvm.t1.stack;

/**
 * 演示栈内存溢出 java.lang.StackOverflowError
 * -Xss256k
 */
public class Demo1_2 {
    private static int count;

    public static void main(String[] args) {
        try {
            method1();
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(count);
        }
    }

    private static void method1() {
        count++;
        method1();
    }
}

  • 进行json格式转换的时候对象的循环调用。

package cn.itcast.jvm.t1.stack;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Arrays;
import java.util.List;

/**
 * 演示栈内存溢出 java.lang.StackOverflowError
 * json 数据转换
 */
public class Demo1_19 {

    public static void main(String[] args) throws JsonProcessingException {
        Dept d = new Dept();
        d.setName("Market");

        Emp e1 = new Emp();
        e1.setName("zhang");
        e1.setDept(d);

        Emp e2 = new Emp();
        e2.setName("li");
        e2.setDept(d);

        d.setEmps(Arrays.asList(e1, e2));

        // { name: 'Market', emps: [{ name:'zhang', dept:{ name:'', emps: [ {}]} },] }
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(d));
    }
}

class Emp {
    private String name;
    //@JsonIgnore：该注解表示在进行json格式转换的时候不会存在循环调用
    private Dept dept;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}
class Dept {
    private String name;
    private List<Emp> emps;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Emp> getEmps() {
        return emps;
    }

    public void setEmps(List<Emp> emps) {
        this.emps = emps;
    }
}

2.3 线程运行诊断

案例1： cpu 占用过多（while-true）

定位（linux下）

首先运行死循环java代码        nohup表示代码在后台运行

用top定位哪个进程对cpu的占用过高

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

jstack 进程id

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

案例2：程序运行很长时间没有结果（死锁）

package cn.itcast.jvm.t1.stack;

/**
 * 演示线程死锁
 */
class A {
};

class B {
};

public class Demo1_3 {
    static A a = new A();
    static B b = new B();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (a) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b) {
                    System.out.println("我获得了 a 和 b");
                }
            }
        }).start();
        Thread.sleep(1000);
        new Thread(() -> {
            synchronized (b) {
                synchronized (a) {
                    System.out.println("我获得了 a 和 b");
                }
            }
        }).start();
    }
}

3. 本地方法栈

java虚拟机不能直接与操作系统做交互，所以如果要与操作系统做交互则需要用到由c或者c++编写的本地方法，而本地方法栈中就存放的本地方法，如wait()，notify(),notifyAll(),equals(),clone()等。且本地方法由native修饰。

4.堆

4.1 定义

Heap 堆：通过 new 关键字，创建对象都会使用堆内存。

特点

  • 它是线程共享的，堆中对象都需要考虑线程安全的问题。

  • 有垃圾回收机制。

4.2 堆内存溢出

注意：调整堆内存大小参数为 -Xmx 8m。

-Xmx 8m

堆内存溢出代码演示：

package cn.itcast.jvm.t1.heap;
​
import java.util.ArrayList;
import java.util.List;
​
/**
 * 演示堆内存溢出 java.lang.OutOfMemoryError: Java heap space
 * -Xmx8m
 */
public class Demo1_5 {
​
    public static void main(String[] args) {
        int i = 0;
        try {
            List<String> list = new ArrayList<>();
            String a = "hello";
            while (true) {
                list.add(a); // hello, hellohello, hellohellohellohello ...
                a = a + a;  // hellohellohellohello
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(i);
        }
    }
}

4.3 堆内存诊断

代码演示：

package cn.itcast.jvm.t1.heap;
​
/**
 * 演示堆内存
 */
public class Demo1_4 {
​
    public static void main(String[] args) throws InterruptedException {
        System.out.println("1...");
        Thread.sleep(30000);
        byte[] array = new byte[1024 * 1024 * 10]; // 10 Mb
        System.out.println("2...");
        Thread.sleep(20000);
        array = null;
        System.gc();
        System.out.println("3...");
        Thread.sleep(1000000L);
    }
}
​

  1. jps ：工具查看当前系统中有哪些 java 进程

jmap 工具：查看堆内存占用情况 jmap - heap 进程id

 jconsole 工具：图形界面的，多功能的监测工具，可以连续监测

jvisualvm工具：具备jconsole不具备的更多功能，

5. 方法区

5.1 定义

JVM规范-方法区定义

5.2 组成

类的相关信息，如成员变量，成员方法，构造方法，运行时常量池等。

5.3 方法区内存溢出

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

演示永久代内存溢出 java.lang.OutOfMemoryError: PermGen space。

方法区内存大小（1.8之前永久代）参数设置：-XX:MaxPermSize=8m。

package cn.itcast.jvm;
​
​
import com.sun.xml.internal.ws.org.objectweb.asm.ClassWriter;
import com.sun.xml.internal.ws.org.objectweb.asm.Opcodes;
​
/**
 * 演示永久代内存溢出  java.lang.OutOfMemoryError: PermGen space
 * -XX:MaxPermSize=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 < 20000; i++, j++) {
                ClassWriter cw = new ClassWriter(0);
                cw.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                byte[] code = cw.toByteArray();
                test.defineClass("Class" + i, code, 0, code.length);
            }
        } finally {
            System.out.println(j);
        }
    }
}
​

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

演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace。

方法区内存大小（1.8之后元空间）参数设置：-XX:MaxMetaspaceSize=8m。

package cn.itcast.jvm.t1.metaspace;

import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.Opcodes;

/**
 * 演示元空间内存溢出 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 < 26000; 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);
        }
    }
}

场景：

spring、mybatis使用动态代理技术时会产生大量的动态代理类可能会造成内存溢出。

5.4 运行时常量池

常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息。我们可以通过javap -v helloword.class指令来进行反编译来获取二进制字节码的相关信息。

package cn.itcast.jvm.t5;

// 二进制字节码（类基本信息，常量池，类方法定义，包含了虚拟机指令）
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

 运行时常量池，常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址。

package cn.itcast.jvm.t1.stringtable;

// StringTable [ "a", "b" ,"ab" ]  hashtable 结构，不能扩容
public class Demo1_22 {
    // 常量池中的信息，都会被加载到运行时常量池中， 这时 a b ab 都是常量池中的符号，还没有变为 java 字符串对象
    // ldc #2 会把 a 符号变为 "a" 字符串对象
    // ldc #3 会把 b 符号变为 "b" 字符串对象
    // ldc #4 会把 ab 符号变为 "ab" 字符串对象

    public static void main(String[] args) {
        String s1 = "a"; // 懒惰的
        String s2 = "b";
        String s3 = "ab";
 // new StringBuilder().append("a").append("b").toString()  new String("ab")
        String s4 = s1 + s2;
//返回false
        System.out.println(s3 == s4);
// javac 在编译期间的优化，结果已经在编译期确定为ab，所以如果常量池中有则不会加入
        String s5 = "a" + "b";  
//返回ture
        System.out.println(s3 == s5);

    }
}

5.5 StringTable 特性

  1. 常量池中的字符串仅是符号，第一次用到时才变为对象。

  2. 利用串池的机制，来避免重复创建字符串对象。

  3. 字符串变量拼接的原理是 StringBuilder （1.8）。

  4. 字符串常量拼接的原理是编译期优化。

  5. 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池。

  6. 运行时常量池的 一部分，储存字符串常量

  • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回。

package cn.itcast.jvm.t1.stringtable;

public class Demo1_23 {

    //  ["ab", "a", "b"]
    public static void main(String[] args) {

        String x = "ab";
        // 堆  new String("a")   new String("b")     new String("ab")
        String s = new String("a") + new String("b");

        // 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池，不管有没有都会把串池中的对象返回
        String s2 = s.intern(); 

        System.out.println( s2 == x);//返回值为true
        System.out.println( s == x );//返回值为false
    }

}

  • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池， 会把串池中的对象返回。

package cn.itcast.jvm;

public class Demo1_23 {

    // ["a", "b", "ab"]
    public static void main(String[] args) {


        String s = new String("a") + new String("b");

        // 堆  new String("a")   new String("b")  new String("ab")
        String s2 = s.intern(); // 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
        // s 拷贝一份，放入串池

        String x = "ab";
        System.out.println( s2 == x);//返回值true
        System.out.println( s == x );//返回值false
    }

}

面试题：

package cn.itcast.jvm.t1.stringtable;

/**
 * 演示字符串相关面试题
 */
public class Demo1_21 {

    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "a" + "b"; // ab
        String s4 = s1 + s2;   // new String("ab")
        String s5 = "ab";
        String s6 = s4.intern();

// 问
        System.out.println(s3 == s4); // false
        System.out.println(s3 == s5); // true
        System.out.println(s3 == s6); // true

        String x2 = new String("c") + new String("d"); // new String("cd")
        x2.intern();
        String x1 = "cd";

// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
        System.out.println(x1 == x2);
    }
}

5.6 StringTable 位置

 演示StringTable的位置jdk1.6下：

package cn.itcast.jvm;

import java.util.ArrayList;
import java.util.List;

/**
 * 演示 StringTable 位置
 * 在jdk8下设置 -Xmx10m -XX:-UseGCOverheadLimit
 * 在jdk6下设置 -XX:MaxPermSize=10m
 */
public class Demo1_6 {

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        int i = 0;
        try {
            for (int j = 0; j < 260000; j++) {
                list.add(String.valueOf(j).intern());
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}

演示StringTable的位置jdk1.8下：

package cn.itcast.jvm.t1.stringtable;

import java.util.ArrayList;
import java.util.List;

/**
 * 演示 StringTable 位置
 * 在jdk8下设置 -Xmx10m -XX:-UseGCOverheadLimit
 * 在jdk6下设置 -XX:MaxPermSize=10m
 */
public class Demo1_6 {

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        int i = 0;
最低0.47元/天 解锁文章
李钟意·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JVM java虚拟机
dawn_36的博客
03-13 113
一、什么是JVM JVM 是 Java Virtual Machine 的缩写，它是一个虚构出来的计算机，一种规范。通过在实际的计算机上仿真模拟各类计算机功能实现··· 1、Java文件是如何被执行的？ 在聊这个之前，需要了解几个概念：类加载器、方法区、堆、栈、程序计数器 类加载器：将 .class文件全部搬进JVM里面 方法区：用于存放类似于元数据信息方面的数据的，比如类信息，常量，静态变量，...
JVM-虚拟机栈
LLLyx_key的博客
08-09 249
虚拟机栈可以理解为每个线程的私有内存区域，用于支持方法的调用和执行。在现代的JVM实现中，操作数栈的底层数据结构可能采用链表或其他更灵活的数据结构，以支持动态变化的需求。操作数栈的深度（栈的大小）在JVM启动时可以通过参数进行配置，这样可以控制栈的大小以适应不同程序的执行需求。操作数栈（Operand Stack）是JVM中虚拟机栈中的一个部分，用于存储方法执行过程中的操作数和临时数据。总之，操作数栈是用于存储方法执行过程中操作数和临时数据的一种数据结构，其底层实现可以基于数组、链表或其他适当的数据结构。
JVM（java虚拟机）
weixin_43771403的博客
11-13 2万+
一、了解JVM 1、什么是JVM JVM是Java Virtual Machine（Java虚拟机）的缩写，是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟计算机功能来实现的，JVM屏蔽了与具体操作系统平台相关的信息，Java程序只需生成在Java虚拟机上运行的字节码，就可以在多种平台上不加修改的运行。JVM在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。 2、JRE/JDK/JVM是什么关系 JRE（Java Runtime Environment）：是Java运行环境，所有
JVM学习- - -虚拟机栈详解
热门推荐
退役复学在校大学生，目光所至，皆为华夏
01-06 3万+
比如：描述一个方法调用了另外的其他方法时，就是通过常量池汇总指向方法的符号引用来表示的，那么。Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。如果Java虚拟机栈可以动态拓展，并且在尝试拓展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存区创建对应的虚拟机栈，那Java虚拟机栈将会抛出一个OutOfMemoryError异常。
JVM-Java虚拟机
07-15
资源概要：JVM基础知识；类加载子系统；运行时数据区；对象的创建流程与内存分配；...从广义上讲Java，Kotlin、Clojure、JRuby、Groovy等运行于Java虚拟机上的编程语言及其相关的程序都属于Java技术体系中的一员。
深入理解JVM-java虚拟机栈.docx
06-27
Java虚拟机栈也是线程私有的，它的生命周期与线程相同（随线程而生，随线程而灭） 2. 如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常； 如果虚拟机栈可以动态扩展，如果扩展时无法申请...
JVM——Java虚拟机架构
03-01
Java虚拟机（Javavirtualmachine）实现了Java语言最重要的特征：即平台无关性。平台无关性原理：编译后的Java程序（.class文件）由JVM执行。JVM屏蔽了与具体平台相关的信息，使程序可以在多种平台上不加修改地运行。...
2024年java面试题-jvm之java虚拟机面试题
04-20
核心内容在于介绍java虚拟机即jvm相关的面试题，包括jre、jdk、jvm等等内容，有该背诵的八股文内容，也有源码coding借鉴，应付下面试还是ok的！！！
Lombok的hashCode方法
LiZhen314的博客
06-27 187
在继承关系中，父类的hashCode针对父类的所有属性进行运算，而子类的hashCode却只是针对子类才有的属性进行运算，立此贴提醒自己。callSuper = false，根据子类自身的字段值 来生成hashcode， 当两个子类对象比较时，只有子类对象的本身的字段值相同，父类字段值可以不同，callSuper = true，根据子类自身的字段值和从父类继承的字段值 来生成hashcode，当两个子。比较时，只有子类对象的本身的字段值和继承父类的字段值都相同，equals方法的返回值是true。
数据库工具之 —— SQLite
一个bug是bug，多个bug能work
06-27 447
SQLite 是一个非常流行的轻量级数据库，它是一个嵌入式的数据库，意味着数据库文件是存储在磁盘上的一个单一文件。SQLite 不需要一个独立的服务器进程，这使得它非常适合用于小型应用、移动应用、桌面应用，或者任何需要轻量级数据库解决方案的场景。sqlite3SQLite 可以通过多种编程语言进行操作，包括但不限于 Python、Java、C#、PHP 等。每种语言都有相应的库或模块来与 SQLite 交互。
JAVA高级进阶11多线程
2402_84667776的博客
06-26 659
线程安全问题多线程给我们带来了很大性能上的提升,但是也可能引发线程安全问题线程安全问题指的是当个多线程同时操作同一个共享资源的时候,可能会出现的操作结果不符预期问题。
最新Java面试题及答案（Java基础、设计模式、Java虚拟机（jvm))
weixin_43516258的博客
06-27 501
毕业季意味着即将找工作面试，以下是我整理的部分Java面试题目，以供面试者参考。
C语言的内存知识
U2396573637的博客
06-25 925
这节我们主要认识一下内存，便于理解指针操作和后续内存管理。
强引用、软引用、弱引用、幻象引用有什么区别?
Cool
06-27 212
【代码】强引用、软引用、弱引用、幻象引用有什么区别?
JVM专题八：JVM如何判断可回收对象
Jeremy程序员
06-24 698
在中提到JVM的垃圾回收机制是一个自动化的后台进程，它通过周期性地检查和回收，帮助管理内存资源，确保应用程序的高效运行。今天就让我们来看看JVM到底是怎么定义“垃圾”对象的。
Java面试八股之JVM永久代会发生垃圾回收吗
u012151345的博客
06-20 398
但从Java 8开始，永久代被元空间（Metaspace）所替代，元空间使用的是直接的本地内存而不是虚拟机内存，因此它不参与Java堆的垃圾回收过程。元空间的大小可以通过JVM参数进行调整，并且当元空间耗尽时，JVM会抛出OutOfMemoryError错误，而不是像堆内存那样进行垃圾回收来释放空间。不过，虽然元空间本身不进行垃圾回收，但类加载器相关的无用类定义可以被卸载，从而间接回收元空间的内存。这一过程主要是为了回收不再使用的类定义和其他可以被释放的资源，以避免永久代的内存溢出。
JVM专题十三：总结与整理（持续更新）
最新发布
Jeremy程序员
06-27 556
我们项目根据不同服务数据不一样，之前待在某互联网保险公司有2kw最有的活跃用户，我们的核心服务是4核8g，峰值QPS 4-5000，tps-3-400。但是任何套路的问题都不适用于所有场景，只是提供一个思路，主要还是要了解各个回收器的优缺点，然后根据自己项目的实际情况去设置。图解JVM主要是放了前面12个章节的我们给大家画的图，做了整体的汇总，大家可以根据图区回忆我们所说的内容，查缺补漏。: 设置JVM可以使用的最大堆大小。: 动态追踪Java应用程序的工具，可以在不重启应用的情况下添加追踪点。
jvm-sandbox
07-28
JVM-Sandbox是一个基于Java虚拟机（JVM）的沙箱环境，用于限制Java应用程序的权限和资源访问。它提供了一种安全的执行环境，可以防止恶意代码对系统造成损害。 JVM-Sandbox通过使用Java安全管理器和安全策略文件来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值