黑马jvm课程笔记d1

最新推荐文章于 2024-04-19 02:33:49 发布
最新推荐文章于 2024-04-19 02:33:49 发布
阅读量297 收藏
点赞数
文章标签： 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ydin00/article/details/126200693
版权

目录

一、堆内存相关

1.1.定义

1.2堆内存溢出

1.2.1 堆内存内存诊断工具

二、方法区相关

2.1.方法区组成

2.2.方法区内存溢出

2.3.方法区内常量池

2.4.运行时常量池

三.StringTable相关

3.1 StringTable延迟实例

3.2 StringTable特性

3.3 StringTable—intern方法将字符串添加到串池子

 3.4 StringTable—垃圾回收功能验证

3.5 StringTable—调优

b站黑马jvm课程学习笔记

一、堆内存相关

1.1.定义

1.2堆内存溢出

堆内存溢出时，将抛出以下异常：

java.lang.OutOfMemoryError: Java heap space

1.2.1 堆内存内存诊断工具

1.2.1.1 jps工具和jmap工具使用案例，执行如下代码：

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

 同时在Terminal终端执行以下命令：

1.jps

结果显示：

17440 Demo1_16
21216 Launcher
25184 Jps
19060
25316 Launcher
16748 Demo1_4
2.jmap -heap 16748

结果显示：

Attaching to process ID 16748, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.301-b09

using thread-local object allocation.
Parallel GC with 10 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 4234149888 (4038.0MB)//最大堆内存
   NewSize                  = 88604672 (84.5MB)//新生代内存
   MaxNewSize               = 1411383296 (1346.0MB)
   OldSize                  = 177733632 (169.5MB)//老年代内存
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 66584576 (63.5MB)
   used     = 17149144 (16.354698181152344MB)
   free     = 49435432 (47.145301818847656MB)
   25.755430206539124% used
From Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
To Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
PS Old Generation
   capacity = 177733632 (169.5MB)
   used     = 0 (0.0MB)
   free     = 177733632 (169.5MB)
   0.0% used

3188 interned Strings occupying 282184 bytes.
 在三个不同的时间段执行jmap -heap 16748，所得的 used数值分别为：

   used     = 6663368 (6.354682922363281MB)
   used     = 17149144 (16.354698181152344MB)
   used     = 1331712 (1.27001953125MB)

 1.2.1.2 控制台终端执行jconsole命令

在三个不同的时段内，jconsole测试结果如下：

 1.2.1.3 控制台终端执行jvisualvm命令

 

二、方法区相关

方法区特点：

1.所有java虚拟机线程共享的区域（与堆一样）

2.存储了和类相关的信息，如成员变量、方法数据、成员方法和构造方法的代码部分、特殊方法（类构造器）、运行时常量池

3.方法区在虚拟机启动时候创建，逻辑上是堆的组成部分

4.规范上并不强制指定方法区的位置（不同jvm的实现方法区的位置会不同）

5.方法区也会有内存溢出问题

2.1.方法区组成

2.2.方法区内存溢出

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

 设置方法空间的内存大小，模拟内存溢出：

2.3.方法区内常量池

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

在target目录下的HelloWold.class文件所在目录的控制台执行：
javap -v HelloWorld.class
可得信息如下：

//类的基本信息：
  Last modified 2022-8-5; size 583 bytes
  MD5 checksum 5eac5b526dee075f096a14efdf25dd55
  Compiled from "HelloWorld.java"
public class com.whx.cn.itcast.jvm.t5.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/whx/cn/itcast/jvm/t5/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/whx/cn/itcast/jvm/t5/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/whx/cn/itcast/jvm/t5/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.whx.cn.itcast.jvm.t5.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 4: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/whx/cn/itcast/jvm/t5/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 6: 0
        line 7: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"

2.4.运行时常量池

三.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";
        String s4 = s1 + s2; // new StringBuilder().append("a").append("b").toString()  new String("ab")
        System.out.println(s3 == s4);//false

        String s5 = "a" + "b";  // javac 在编译期间的优化，结果已经在编译期确定为ab

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

}

//通过javap -v Demo1_22.class执行反编译命令：
Constant pool:
   #1 = Methodref          #12.#36        // java/lang/Object."<init>":()V
   #2 = String             #37            // a
   #3 = String             #38            // b
   #4 = String             #39            // ab
   #5 = Class              #40            // java/lang/StringBuilder
   #6 = Methodref          #5.#36         // java/lang/StringBuilder."<init>":()V
   #7 = Methodref          #5.#41         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #8 = Methodref          #5.#42         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #9 = Fieldref           #43.#44        // java/lang/System.out:Ljava/io/PrintStream;
  #10 = Methodref          #45.#46        // java/io/PrintStream.println:(Z)V
  #11 = Class              #47            // com/whx/cn/itcast/jvm/t1/stringtable/Demo1_22
  #12 = Class              #48            // java/lang/Object
  #13 = Utf8               <init>
  #14 = Utf8               ()V
  #15 = Utf8               Code
  #16 = Utf8               LineNumberTable
  #17 = Utf8               LocalVariableTable
  #18 = Utf8               this
  #19 = Utf8               Lcom/whx/cn/itcast/jvm/t1/stringtable/Demo1_22;
  #20 = Utf8               main
  #21 = Utf8               ([Ljava/lang/String;)V
  #22 = Utf8               args
  #23 = Utf8               [Ljava/lang/String;
  #24 = Utf8               s1
  #25 = Utf8               Ljava/lang/String;
  #26 = Utf8               s2
  #27 = Utf8               s3
  #28 = Utf8               s4
  #29 = Utf8               s5
  #30 = Utf8               StackMapTable
  #31 = Class              #23            // "[Ljava/lang/String;"
  #32 = Class              #49            // java/lang/String
  #33 = Class              #50            // java/io/PrintStream
  #34 = Utf8               SourceFile
  #35 = Utf8               Demo1_22.java
  #36 = NameAndType        #13:#14        // "<init>":()V
  #37 = Utf8               a
  #38 = Utf8               b
  #39 = Utf8               ab
  #40 = Utf8               java/lang/StringBuilder
  #41 = NameAndType        #51:#52        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #42 = NameAndType        #53:#54        // toString:()Ljava/lang/String;
  #43 = Class              #55            // java/lang/System
  #44 = NameAndType        #56:#57        // out:Ljava/io/PrintStream;
  #45 = Class              #50            // java/io/PrintStream
  #46 = NameAndType        #58:#59        // println:(Z)V
  #47 = Utf8               com/whx/cn/itcast/jvm/t1/stringtable/Demo1_22
  #48 = Utf8               java/lang/Object
  #49 = Utf8               java/lang/String
  #50 = Utf8               java/io/PrintStream
  #51 = Utf8               append
  #52 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #53 = Utf8               toString
  #54 = Utf8               ()Ljava/lang/String;
  #55 = Utf8               java/lang/System
  #56 = Utf8               out
  #57 = Utf8               Ljava/io/PrintStream;
  #58 = Utf8               println
  #59 = Utf8               (Z)V
{
  public com.whx.cn.itcast.jvm.t1.stringtable.Demo1_22();
    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 4: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/whx/cn/itcast/jvm/t1/stringtable/Demo1_22;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, 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/String;
        27: astore        4
        29: ldc           #4                  // String ab
        31: astore        5
        33: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
        36: aload_3
        37: aload         5
        39: if_acmpne     46
        42: iconst_1
        43: goto          47
        46: iconst_0
        47: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
        50: return
      LineNumberTable:
        line 11: 0
        line 12: 3
        line 13: 6
        line 14: 9
        line 15: 29
        line 17: 33
        line 21: 50
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      51     0  args   [Ljava/lang/String;
            3      48     1    s1   Ljava/lang/String;
            6      45     2    s2   Ljava/lang/String;
            9      42     3    s3   Ljava/lang/String;
           29      22     4    s4   Ljava/lang/String;
           33      18     5    s5   Ljava/lang/String;
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 46
          locals = [ class "[Ljava/lang/String;", class java/lang/String, class java/lang/String, class java/lang/String, class java/lang/String, class java/lang/String ]
          stack = [ class java/io/PrintStream ]
        frame_type = 255 /* full_frame */
          offset_delta = 0
          locals = [ class "[Ljava/lang/String;", class java/lang/String, class java/lang/String, class java/lang/String, class java/lang/String, class java/lang/String ]
          stack = [ class java/io/PrintStream, int ]
}
SourceFile: "Demo1_22.java"

 s4的生成过程为：

s5的生成过程为：

3.1 StringTable延迟实例

3.2 StringTable特性

 

3.3 StringTable—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
    }
}

 s2是串池中的“ab”,s是new String(“ab”),二者不同

面试题解答：

 3.4 StringTable—垃圾回收功能验证

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Demo1_7 {
    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        try {
            for (int j = 0; j < 10000; j++) { // j=100, j=10000
                String.valueOf(j).intern();
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }

    }
}

根据循环次数的不同，可体现垃圾回收功能

不循环时：

循环10000次时：

循环1000次时：

 

3.5 StringTable—调优

（1）通过调节StringTable的桶大小-XX:StringTableSize=设置大小，可以进行调优

/**
 * 演示串池大小对性能的影响
 * -Xms500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=1009
 */
public class Demo1_24 {

    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
            String line = null;
            long start = System.nanoTime();
            while (true) {
                line = reader.readLine();
                if (line == null) {
                    break;
                }
                line.intern();
            }
            System.out.println("cost:" + (System.nanoTime() - start) / 1000000);
        }


    }
}

（2）通过调节让大量字符串入池，可以减少堆内存使用

/**
 * 演示 intern 减少内存占用
 * -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
 * -Xsx500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=200000
 */
public class Demo1_25 {

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

        List<String> address = new ArrayList<>();
        System.in.read();
        for (int i = 0; i < 10; i++) {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
                String line = null;
                long start = System.nanoTime();
                while (true) {
                    line = reader.readLine();
                    if(line == null) {
                        break;
                    }
                    address.add(line.intern());
                    //address.add(line);
                }
                System.out.println("cost:" +(System.nanoTime()-start)/1000000);
            }
        }
        System.in.read();


    }
}
padDio
关注
黑马毕向东Java课程笔记（day11）:多线程（第一部分）——进程与线程+线程创建+线程安全与同步代码块+同步锁/死锁
LKJgdut的博客
08-20 313
1、进程与线程概述   首先，对于CPU执行每一个程序，其实都是在快速切换程序，一个核的CPU只能同时执行一个任务，因为CPU切换很快，我们反应不过来。   所谓进程，字面意思上理解就是“是一个正在执行中的程序”。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。对于一个进程，它还有可能分为多条执行路径（如进程迅雷下载可能分为多路径进行下载，这多条路径同时发送下载请求到...
java零基础风清扬黑马笔记
奇犽的博客
11-13 710
==== 一.变量运算符 今日内容介绍  变量  运算符 第1章 变量 1.1 变量概述 前面我们已经学习了常量，接下来我们要学习变量。在Java中变量的应用比常量的应用要多很多。所以变量也是尤为重要的知识点！ 什么是变量？变量是一个内存中的小盒子（小容器），容器是什么？生活中也有很多容器，例如水杯是容器，用来装载水；你家里的大衣柜是容器，用来装载衣裤；饭盒是容器，用来装载饭菜。那么变量是装载什么的呢？答案是数据！结论：变量是内存中装载数据的小盒子，你只能用它来存数据和取数据。 1.2 计算机存储单
黑马java教程知识点笔记整理
02-04
之前收藏的一个大牛的知识点总结，结合黑马java视频看效果较好，希望能帮助到需要的人
黑马JVM学习笔记一
stay hungry,stay foolish!
01-13 1177
title: 黑马解密JVM date: 2020-01-13 1:00:00 tags: JVM categories: JVM 黑马jvm blibli视频地址：黑马JVM解密 引言 什么是jvm jvm运行在操作系统之上 数组下标越界异常检查解释：jvm如果没有提供这个机制，当数组下标越界，如果没检查出来异常，有可能会覆盖数据，这个是比较危险的。 学习jvm有什么用 面试...
学习黑马JVM的笔记
qinchengmei的博客
08-22 2716
学习黑马JVM的笔记。炒鸡详细
黑马程序员jvm笔记总集
abaidaye的博客
02-22 9212
黑马程序员jvm笔记(一)–程序计数器 虚拟机栈 堆 黑马程序员jvm笔记(二)–方法区 串池 直接内存 黑马程序员jvm笔记（三）–垃圾回收部分心得 黑马程序员jvm笔记（四）–字节码部分心得 黑马程序员jvm笔记（五）–类加载部分心得 黑马程序员jvm笔记（六）–JMM内存模型部分心得 ...
黑马JVM学习笔记二
stay hungry,stay foolish!
01-13 730
title: 黑马JVM学习笔记二 date: 2020-01-13 1:00:00 tags: JVM categories: JVM 黑马jvm 内存结构 内存结构总览图： 程序计数器 1.定义：Program Counter Register 程序计数器 (寄存器) 程序计数器是Java对物理硬件的一些屏蔽和抽象，物理上通过寄存器来实现，寄存器是整个cpu里读取最快的一个单元。...
学习笔记：黑马程序员Java-中级篇（第二部分），2024年最新中级java工程师面试常见问题
最新发布
2301_82243364的博客
04-19 957
可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。System.out.println(“相差的千年数:” + ChronoUnit.MILLENNIA.between(birthDate, today));
js基础-课堂笔记
huanghai_fu的博客
06-22 415
JavaScript-课堂笔记 表单【重点】 <form name="名称" action="提交路径" method="提交方式get/post"> <!-- 任何表单项的数据，如果想要提交，就必须有name属性 --> 文本框：<input type="text" name="username" value="默认值"> 密码框：<input type="password" name="password" value="默认值"&
Javase进阶-day03-面向对象_常用API
qq_45263618的博客
07-13 277
黑马Java笔记
java黑马学习笔记
02-21
是我从黑马资源中抓出来的每天教师上课的笔记,对于基础学习者帮助还是很大的,毕竟视频太多了,不可能全部看完,但是笔记就不一样.
JVM性能优化笔记
10-27
JVM性能优化笔记 ------------------------------------------
黑马jvm笔记
qq_59676409的博客
05-01 310
JVM内存结构_→_→洋洋的博客-CSDN博客 JVM垃圾回收_→_→洋洋的博客-CSDN博客 类加载与字节码技术_→_→洋洋的博客-CSDN博客 jvm内存模型_→_→洋洋的博客-CSDN博客
黑马程序员《JVM完整教程》笔记 - p001- p015
qq_44005101的博客
02-20 1555
黑马程序员《JVM完整教程》笔记 - p001- p010引言什么是JVM？学习JVM有什么用？内存结构 程序计数器 虚拟机栈 栈内存溢出 b站链接： 引言 什么是JVM？ Java Visual Machine程序的运行环境，（Java二进制字节码的运行环境） JVM优点： 一次编写，到处运行。。。 开发Java EE程序（JDK + 应用服务器 + IDE 工具）
黑马jvm课程笔记d2
Ydin00的博客
08-09 424
黑马jvm自学简单笔记第二篇
JVM黑马版：笔记、应用、速查
大吉的博客
10-24 1724
由于工作中时常和JVM打交道，但是对JVM的体系缺乏系统深入了解。日前跟随b站上黑马程序猿的课程成体系地学习了JVM，结合工作中的实践写就了此笔记。
黑马程序员《JVM完整教程》笔记 - p015 - p026
qq_44005101的博客
02-22 749
黑马程序员《JVM完整教程》笔记 - p015 - p015本地方法栈堆定义堆内存溢出堆内存诊断案例：垃圾回收后，内存占用仍然很高方法区定义方法区内存溢出 b站链接：黑马程序员JVM完整教程 本地方法栈 native方法：不是本地创建的方法。 本地方法栈的作用：给本地方法的运行提供一个内存空间。 堆 定义 Heap 堆 通过new关键字，创建对象都会使用堆内存 特点 它是线程共享的，堆中对象都需要考虑线程安全的问题 有垃圾回收机制（堆中不再被引用的对象都需要考虑线程安全问题）
黑马JVM学习笔记-内存结构
weixin_60347335的博客
11-26 814
Java Virtual Machine - java 程序的运行环境(Java二进制字节码的运行环境)好处：3一次编写，到处运行自动内存管理，垃圾回收功能数组下标越界检查(下标越界抛出异常比数组新元素覆盖其他部分造成的危害小)多态(面向对象编程的基石，jvm内部采用虚方法表的方式实现多态)jvm屏蔽Java代码与底层操作系统之间的差异jdk+集成开发工具->JavaSEjdk+应用服务器(如：tomcat)+集成开发工具->JavaEE。
JVM学习笔记：类加载子系统详解
"JVM类加载子系统的学习笔记，包括内存结构概述、类加载器和加载过程的详细解析。" 在Java虚拟机（JVM）中，类加载子系统是程序运行的基础，它负责将类的.class文件加载到内存中，以便程序能够执行。这篇学习笔记...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值