JVM学习笔记（上）

已于 2023-05-30 12:58:16 修改
阅读量3.4k 收藏 4
点赞数 5
分类专栏： JVM 文章标签： jvm 学习 笔记
于 2023-05-29 00:01:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57818853/article/details/130919580
版权

1、总体路线

在这里插入图片描述

2、程序计数器

Program Counter Register 程序计数器（寄存器）
作用：是记录下一条 jvm 指令的执行地址行号。
特点：

  • 是线程私有的
  • 不会存在内存溢出

解释器会解释指令为机器码交给 cpu 执行，程序计数器会记录下一条指令的地址行号，这样下一次解释器会从程序计数器拿到指令然后进行解释执行。
多线程的环境下，如果两个线程发生了上下文切换，那么程序计数器会记录线程下一行指令的地址行号，以便于接着往下执行。

3、栈

定义

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

问题辨析：

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

不会。栈内存是方法调用产生的，方法调用结束后会弹出栈。

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

不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。

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

如果方法内部的变量没有逃离方法的作用范围，它是线程安全的
如果是局部变量引用了对象，并逃离了方法的作用范围，那就要考虑线程安全问题。

在这里插入图片描述
m1是线程安全的，m2,m3都不算线程安全的。

栈内存溢出

栈帧过大、过多、或者第三方类库操作，都有可能造成栈内存溢出 java.lang.stackOverflowError ，使用 -Xss256k 指定栈内存大小！

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

线程运行诊断

案例一：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 进制的，需要转换。

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

4、堆

定义

Heap 堆

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

特点

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

堆内存溢出

java.lang.OutofMemoryError ：java heap space. 堆内存溢出
可以使用 -Xmx8m 来指定堆内存大小。

堆内存诊断

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

5、方法区

定义

Java 虚拟机有一个在所有 Java 虚拟机线程之间共享的方法区域。方法区域类似于用于传统语言的编译代码的存储区域，或者类似于操作系统进程中的“文本”段。它存储每个类的结构，例如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括特殊方法，用于类和实例初始化以及接口初始化方法区域是在虚拟机启动时创建的。

组成

在这里插入图片描述

方法区内存溢出

1.8 之前会导致永久代内存溢出
使用 -XX:MaxPermSize=8m 指定永久代内存大小
1.8 之后会导致元空间内存溢出
使用 -XX:MaxMetaspaceSize=8m 指定元空间大小

运行时常量池

二进制字节码包含（类的基本信息，常量池，类方法定义，包含了虚拟机的指令）
首先看看常量池是什么，编译如下代码：

public class Test {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

}

然后使用 javap -v Test.class 命令反编译查看结果。
在这里插入图片描述
常量池：
就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
运行时常量池：
常量池是 *.class 文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

6、StringTable

  • 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是StringBuilder
  • 字符串常量拼接的原理是编译器优化
  • 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中

例1：

// 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";
        String s4 = s1 + s2; // new StringBuilder().append("a").append("b").toString()  new String("ab")
        String s5 = "a" + "b";  // javac 在编译期间的优化，结果已经在编译期确定为ab

        System.out.println(s3 == s5);//true
 		System.out.println(s3 == s4);//flase


    }
}

intern方法 1.8

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

  • 如果串池中没有该字符串对象，则放入成功
    如果有该字符串对象，则放入失败
  • 无论放入是否成功，都会返回串池中的字符串对象

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

public class Demo1_23 {

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

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

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

        System.out.println( s2 == x);//true
        System.out.println( s == x );//false
    }

}

面试题

/**
 * 演示字符串相关面试题
 */
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";
        x2.intern();
// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
        System.out.println(x1 == x2);//false
    }
}

理解intern方法：intern是将字符串放到常量池里，常量池如果没有，就把自己的地址放到常量池，如果有，就返回常量池里面的对象地址。

StringTable位置

jdk1.6 StringTable 位置是在永久代中，1.8 StringTable 位置是在堆中。

StringTable 垃圾回收

-Xmx10m 指定堆内存大小
-XX:+PrintStringTableStatistics 打印字符串常量池信息
-XX:+PrintGCDetails
-verbose:gc 打印 gc 的次数，耗费时间等信息

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Code_05_StringTableTest {

    public static void main(String[] args) {
        int i = 0;
        try {
            for(int j = 0; j < 10000; j++) { // j = 100, j = 10000
                String.valueOf(j).intern();
                i++;
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            System.out.println(i);
        }
    }

}

StringTable调优

在介绍性能调优之前不得不说一说StringTable的底层实现，前面已经提到了StringTable底层是一个HashTable，HashTable长什么样呢？其实就是数组+链表，每个元素是一个key-value。当存入一个元素的时候，就会将其key通过hash函数计算得出数组的下标并存放在对应的位置。

在这里插入图片描述
比如现在有一个key-value，这个key通过hash函数计算结果为2，那么就把value存放在数组下标为2的位置。但是如果现在又有一个key通过hash函数计算出了相同的结果，比如也是2，但2的位置已经有值了，这种现象就叫做哈希冲突，怎么解决呢？这里采用了链表法：
在这里插入图片描述
链表法就是将下标一样的元素通过链表的形式串起来，如果数组容量很小但是元素很多，那么发生哈希冲突的概率就会提高。大家都知道，链表的效率远没有数组那么高，哈希冲突过多会影响性能。所以为了减少哈希冲突的概率，所以可以适当的增加数组的大小。数组的每一格在StringTable中叫做bucket，我们可以增加bucket的数量来提高性能，默认的数量为60013个，来看一个对比：

long startTime = System.nanoTime();
String str = "hello";
for(int i = 0;i < 500000;i++) {
    String s = str + i;
    s.intern();
}
long endTime = System.nanoTime();
System.out.println("花费的时间为："+(endTime-startTime)/1000000 + "毫秒");

先通过一个虚拟机参数将bucket指定的小一点，来个2000吧：

-XX:StringTableSize=2000

运行一下：
在这里插入图片描述
一共花费了1.2秒。再来将bucket的数量增加一点，来个20000个：

-XX:StringTableSize=20000

运行一下：
在这里插入图片描述
可以看到，这次只花了0.19秒，性能有了明显的提升，说明这样确实可以优化StringTable。

7、直接内存

定义

Direct Memory

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

使用直接内存的好处

文件读写流程：
在这里插入图片描述
因为 java 不能直接操作文件管理，需要切换到内核态，使用本地方法进行操作，然后读取磁盘文件，会在系统内存中创建一个缓冲区，将数据读到系统缓冲区， 然后在将系统缓冲区数据，复制到 java 堆内存中。缺点是数据存储了两份，在系统内存中有一份，java 堆中有一份，造成了不必要的复制。

使用了 DirectBuffer 文件读取流程
在这里插入图片描述
直接内存是操作系统和 Java 代码都可以访问的一块区域，无需将代码从系统内存复制到 Java 堆内存，从而提高了效率。

使用ByteBuffer.allocateDirect

/**
 *  IO:阻塞式                  NIO (New IO / Non-Blocking IO):非阻塞式
 *  byte[] / char[]     Buffer
 *  Stream              Channel
 *
 * 查看直接内存的占用与释放
 */
public class BufferTest {

    private static final int BUFFER = 1024 * 1024 * 1024; //1GB

    public static void main(String[] args){
        //直接分配本地内存空间
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
        System.out.println("直接内存分配完毕，请求指示！");

        Scanner scanner = new Scanner(System.in);
        scanner.next();

        System.out.println("直接内存开始释放！");
        byteBuffer = null;
        System.gc();
        scanner.next();
    }

}

使用unsafe类

/**
 * 直接内存分配的底层原理：Unsafe
 */
public class Demo1_27 {
    static int _1Gb = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();
        // 分配内存
        long base = unsafe.allocateMemory(_1Gb);
        unsafe.setMemory(base, _1Gb, (byte) 0);
        System.in.read();

        // 释放内存
        unsafe.freeMemory(base);
        System.in.read();
    }

    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            Unsafe unsafe = (Unsafe) f.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

8、垃圾回收

如何判断对象可以回收

引用计数法

当一个对象被引用时，引用对象的值加一，当一个对象不被引用时，引用对象的值减一，当值为 0 时，就表示该对象不被引用，可以被垃圾收集器回收。
这个引用计数法听起来不错，但是有一个弊端，如下图所示，循环引用时，两个对象的计数都为1，导致两个对象都无法被释放，造成内存泄露。
在这里插入图片描述

可达性分析算法

  • JVM 中的垃圾回收器通过可达性分析来探索所有存活的对象
  • 扫描堆中的对象，看能否沿着 GC Root 对象为起点的引用链找到该对象，如果找不到，则表示可以回收
  • 可以作为 GC Root 的对象
    • 虚拟机栈（栈帧中的本地变量表）中引用的对象。
    • 方法区中类静态属性引用的对象
    • 方法区中常量引用的对象
    • 本地方法栈中 JNI（即一般说的Native方法）引用的对象
    • 已启动且未停止的 Java 线程
public static void main(String[] args) throws IOException {

        ArrayList<Object> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add(1);
        System.out.println(1);
        System.in.read();

        list = null;
        System.out.println(2);
        System.in.read();
        System.out.println("end");
    }

对于以上代码，可以使用如下命令将堆内存信息转储成一个文件，然后使用
Eclipse Memory Analyzer 工具进行分析。
第一步：
使用 jps 命令，查看程序的进程
在这里插入图片描述
第二步
在这里插入图片描述
使用 jmap -dump:format=b,live,file=1.bin 16104 命令转储文件
dump：转储文件
format=b：二进制文件
file：文件名
16104：进程的id
第三步：打开 Eclipse Memory Analyzer 对 1.bin 文件进行分析。
在这里插入图片描述
分析的 gc root，找到了 ArrayList 对象，然后将 list 置为null，再次转储，那么 list 对象就会被回收。

java定义常量是在方法区还是堆区

在Java中，常量通常被定义为静态final字段，它们被存储在方法区中的运行时常量池中。这意味着它们在程序运行期间只被分配一次，并且可以被所有对象共享。堆区是用于存储对象实例的区域，而不是常量。

四种引用

在这里插入图片描述
强引用
只有所有 GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收

软引用（SoftReference）
仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象可以配合引用队列来释放软引用自身

弱引用（WeakReference）
仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象
可以配合引用队列来释放弱引用自身

虚引用（PhantomReference）
必须配合引用队列使用，主要配合 ByteBuffer 使用，被引用对象回收时，会将虚引用入队，由 Reference Handler 线程调用虚引用相关方法释放直接内存

终结器引用（FinalReference）
无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由 Finalizer 线程通过终结器引用找到被引用对象并调用它的 finalize 方法，第二次 GC 时才能回收被引用对象。

演示软引用

/**
 * 演示 软引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Code_08_SoftReferenceTest {

    public static int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        method2();
    }

    // 设置 -Xmx20m , 演示堆内存不足,
    public static void method1() throws IOException {
        ArrayList<byte[]> list = new ArrayList<>();

        for(int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);
        }
        System.in.read();
    }

    // 演示 软引用
    public static void method2() throws IOException {
        ArrayList<SoftReference<byte[]>> list = new ArrayList<>();
        for(int i = 0; i < 5; i++) {
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB]);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }
        System.out.println("循环结束：" + list.size());
        for(SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
    }
}

method1 方法解析：
首先会设置一个堆内存的大小为 20m，然后运行 mehtod1 方法，会抛异常，堆内存不足，因为 mehtod1 中的 list 都是强引用。
在这里插入图片描述
method2 方法解析：
在 list 集合中存放了 软引用对象，当内存不足时，会触发 full gc，将软引用的对象回收。细节如图：
在这里插入图片描述
上面的代码中，当软引用引用的对象被回收了，但是软引用还存在，所以，一般软引用需要搭配一个引用队列一起使用。
修改 method2 如下：
// 演示 软引用 搭配引用队列

    public static void method3() throws IOException {
        ArrayList<SoftReference<byte[]>> list = new ArrayList<>();
        // 引用队列
        ReferenceQueue<byte[]> queue = new ReferenceQueue<>();

        for(int i = 0; i < 5; i++) {
            // 关联了引用队列，当软引用所关联的 byte[] 被回收时，软引用自己会加入到 queue 中去
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB], queue);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }

        // 从队列中获取无用的 软引用对象，并移除
        Reference<? extends byte[]> poll = queue.poll();
        while(poll != null) {
            list.remove(poll);
            poll = queue.poll();
        }

        System.out.println("=====================");
        for(SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
    }

在这里插入图片描述
弱引用

/**
 * 演示弱引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_5 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {
        //  list --> WeakReference --> byte[]
        List<WeakReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            WeakReference<byte[]> ref = new WeakReference<>(new byte[_4MB]);
            list.add(ref);
            for (WeakReference<byte[]> w : list) {
                System.out.print(w.get()+" ");
            }
            System.out.println();

        }
        System.out.println("循环结束：" + list.size());
    }
}
杭州下小雨~
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
黑马JVM学习笔记二
01-20
title: 黑马JVM学习笔记二 date: 2020-01-13 1:00:00 tags: JVM categories: JVM 黑马jvm 内存结构 内存结构总览图： 程序计数器 1.定义：Program Counter Register 程序计数器 (寄存器) 程序计数器是Java对物理...
JVM学习笔记
04-28
从JVM内存模型、常用JVM参数、垃圾回收算法和垃圾回收器等几个角度学习JVM
宋红康老师JVM课程学习笔记
qq_44300280的博客
01-10 616
宋红康老师JVM课程学习笔记
JVM学习笔记-马士兵老师
Mark_able
03-21 242
当垃圾回收线程a标记完1就去休息了。这个时候A突然指向D，然后a重新开始执行标记2;1,2皆为灰色，此时线程a不知道A还有一个D孩子，故直接把A标成黑色，D漏标。由于以前内存较小因此回收较方便，但是随着内存的增加，回收算法也必须不断增强。有一条线把每个节点连起来，没有连接到的就是垃圾。引用技术但不能解决循环引用的问题。
宋红康JVM 学习笔记
qq_41183828的博客
01-16 1098
为什么要学 JVM？ ⚫ 面试的需要：入职 BATJ、TMD、PKQ 等一线大厂不光关注技术的广度，更关注 技术的深度，JVM 技术是大厂面试的必备技能，掌握越深越好 ⚫ 中高级程序员、架构师必备技能：架构师每天都在思考如何让我的系统更快， 如何避免系统出现性能瓶颈。单纯的依靠物理机不足以解决问题，分析系统 性能、调优系统瓶颈离不了对 JVM 中内存、垃圾回收、字节码指令、性能监 控工具、调优参数的熟练掌握。 ⚫ 精进技术、极客追求：JVM 是 Java 生态的核心价值的体现，垃圾回收算法、 JIT、底层原
JVM学习笔记：类加载器
RuaaaHaHa的博客
12-04 1432
类加载器是一个负责加载类的对象。是一个抽象类。给定类的二进制名称，类加载器应该尝试定位或生成构成类定义的数据。典型的策略是将名称转换为文件名，然后从文件系统中读取该名称的"类文件"。每个Java类都有一个引用指向加载它的。不过，数组类不是通过创建的，而是JVM在需要的时候自动创建的，数组类通过方法获取的时候和该数组的元素类型的是一致的。由此可得类加载器是一个负责加载类的对象，用于实现类加载过程中的加载这一步。每个Java类都有一个引用指向加载它的数组类不是通过。
JVM 学习笔记 内存结构
热门推荐
Gettler的博客
01-12 1万+
元空间是方法区的在 HotSpot JVM 中的实现，方法区主要用于存储类信息、常 量池、方法数据、方法代码、符号引用等。JDK8 彻底将永久代移除出 HotSpot JVM，将其原有的数据迁移至 Java Heap 或 Native Heap（Metaspace），取代它的是另一个内存区域被称为元空间（Metaspace）。存储每个类的结构，如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括类和实例初始化和接口初始化中使用的特殊方法。命令定位查看是否发生死锁。创建的对象都会使用堆内存。
JVM学习笔记，java数据库面试问题
2401_84434237的博客
04-21 1004
方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊的方法，如构造函数，接口代码也在此定义，简单说，所有定义的方法信息都保存在该区域。静态变量、常量、类信息（构造方法、接口定义）、运行时的常量池存在方法区中，但是实例存在堆内存中，和方法区无关。容量小，存取速度快，适合存储生命周期短的数据，栈中存储变量（称为局部变量），特点是先进后出，使用完后就会销毁；新生代与老年代的比例，如 –XX:NewRatio=2，则新生代占整个堆空间的1/3，老年代占2/3。第4步：调优一台服务器，对比观察调优前后的差异；
JVM 学习笔记
futurn_hero的博客
04-21 1200
JVM 学习笔记 JVM的机构体系 类加载器 双亲委派机制 沙箱安全机制 Native关键字 native： function： 来调用底层C、C++的库 example： private native void start（）； 进入本地方法栈 调用本地方法本地接口JNI 方法区 static final class 常量池 被所有线程共享 所有的方法字节码，字段，一些特殊方法：构造函数，接口代码在此定义 所有定义的方法的信息在此区域 静态变量、常量、类信息（构造函数，接口代码）、运行时的常量池存
JVM学习笔记02
xizheng2018的博客
06-10 90
三十九、运行时数据区内部数据
B站狂神说JVM学习笔记
jacknoe的博客
11-11 601
JVM
JVM学习笔记(一)
06-02
一份JVM学习的笔记,含查看JVM运行时信息\JVM垃圾收集信息\JVM锁信息等
jvm学习笔记.zip
04-04
jvm经典笔记
Java的JVM自测题
qq_45981373的博客
06-17 703
提示：在 Java 中，JVM 可以理解的代码就叫做 字节码 （即扩展名为 .class 的⽂件）。
2024-6-17(沉默JVM，Spring)
cxr的博客
06-17 931
要想使用反射，首先需要获得反射类的 Class 对象，每一个类，不管它最终生成了多少个对象，这些对象只会对应一个 Class 对象，这个 Class 对象是由 Java 虚拟机生成的，由它来获悉整个类的结构信息。Class 对象中包含了与类相关的很多信息，如类的名称、类的父类、类实现的接口、类的构造方法、类的方法、类的字段等等。，因为项目中每次创建对象是很麻烦的，所以我们使用 Spring IoC 容器来管理这些对象，需要的时候你就直接用，不用管它是怎么来的、什么时候要销毁，只管用就好了。
JVM-GC-CMS垃圾回收器
最新发布
qq_43676797的博客
06-17 480
CMS从提出概念到实际完成用了10年多的时间，在此之前没有过并发回收的垃圾回收器，因此它是一个垃圾回收器的里程碑，后来的G1也是基于CMS做的一些改进。由于CMS是并发清除的新时代，它也存留了很多问题，JDK任何版本都不会使用CMS作为默认垃圾回收器。incremental update:增量更新，关注引用的增加，如果要给黑色对象引用增加，将黑色对象标记为灰色。
C++中的堆和栈内存定义以及区别
2402_85246552的博客
06-15 427
栈的大小在程序编译时确定，通常是有限的（例如，在大多数系统中，栈的大小可能只有几兆字节）。：与栈内存相比，堆内存的访问速度较慢，因为系统需要维护一个复杂的内存管理结构来跟踪哪些内存块是可用的，哪些已经被分配了。综上所述，堆和栈在管理方式、申请方式、生长方向、空间大小、内存利用率、用途和错误处理等方面都存在明显的区别。与栈不同，堆的大小在程序运行时动态确定，并且由程序员负责分配和释放内存（使用。下，栈的大小是固定的（编译时确定），不适合在函数内申请过多的栈空间，否则可能导致程序栈溢出。
宋红康jvm学习笔记 逃逸分析
05-19
逃逸分析可以优化程序的性能，因为当对象不逃逸时，JVM可以将它们放在线程栈上分配内存，而不需要在堆上分配内存，这样可以减少GC的负担。 逃逸分析有两种类型：全局逃逸和本地逃逸。全局逃逸是指对象逃逸到方法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

杭州下小雨~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值