文章目錄

JVM-記憶體結構
- 1.程式計數器
- - 1-1 定義
  - 1-2 作用
  - 1-3 特點
- 2.虛擬機堆疊
- - 2-1 定義
  - 2-2 演示
  - 2-3 常見問題
  - 2-4 堆疊記憶體溢位
  - 2-5 執行緒運行診斷
- 3.本地方法堆疊
- 4.堆
- - 4-1 定義
  - 4-2 特點
  - 4-3 堆記憶體溢位
  - 4-4 堆記憶體診斷
- 5.方法區
- - 5-1 定義
  - 5-2 結構
  - 5-3 方法區記憶體溢位
  - 5-4 通過反編譯來查看類的資訊
  - 5-5 運行時常量池
  - 5-6 常量池與串池StringTable的關系
  - 5-7 StringTable 位置
  - 5-8 StringTable 垃圾回收
  - 5-9 StringTable 性能調優
- 6.直接記憶體
- - 6-1 定義
  - 6-2 分配和回收原理

JVM-記憶體結構

本文章參考：黑馬程式員JVM

整體架構：

1.程式計數器

1-1 定義

Program Counter Register 程式計數器（暫存器）

1-2 作用

用于保存JVM中下一條所要執行的指令的地址，

PC 暫存器用來存盤指向下一條指令的地址，即將要執行的指令代碼，由執行引擎讀取下一條指令，

1-3 特點

是執行緒私有的
- CPU會為每個執行緒分配時間片，當當前執行緒的時間片使用完以后，CPU就會去執行另一個執行緒中的代碼
- 程式計數器是每個執行緒所私有的，當另一個執行緒的時間片用完，又回傳來執行當前執行緒的代碼時，通程序式計數器可以知道應該執行哪一句指令
不會存在記憶體溢位

2.虛擬機堆疊

2-1 定義

每個執行緒運行需要的記憶體空間，稱為虛擬機堆疊
每個堆疊由多個堆疊幀組成，對應著每次方法呼叫時所占用的記憶體空間
每個執行緒只能有一個活動堆疊幀，對應當前正在執行的那個方法

在這里插入圖片描述

2-2 演示

public class main1 {
    public static void main(String[] args) {
        method1();
    }![在這里插入圖片描述](https://img-blog.csdnimg.cn/0e3218e6a4284167881513ba6ceae8b9.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBATEwuTEVCUk9O,size_20,color_FFFFFF,t_70,g_se,x_16)


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

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

在這里插入圖片描述

2-3 常見問題

垃圾回收是否涉及堆疊記憶體？

不需要，因為虛擬機堆疊中是由一個個堆疊幀組成的，在方法執行完畢后，對應的堆疊幀就會被彈出堆疊，所以無需通過垃圾回識訓制去回收記憶體，
堆疊記憶體分配越大越好嗎？

不是，因為物理記憶體是一定的，堆疊記憶體越大，可以支持更多的遞回呼叫，但是可執行的執行緒數就會越少，

方法內的區域變數是否執行緒安全？

如果方法內部區域變數沒有逃離方法的作用訪問，它是執行緒安全的
如果是區域變數參考了物件，并逃離方法的范圍，需要考慮執行緒安全問題

例如：

public class main1 {
    public static void main(String[] args) {

    }
    //下面各個方法會不會造成執行緒安全問題？

    //不會
    public static void m1() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    //會，可能會有其他執行緒使用這個物件
    public static void m2(StringBuilder sb) {
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    //會，其他執行緒可能會拿到這個執行緒的參考
    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;
    }
    
}

2-4 堆疊記憶體溢位

Java.lang.stackOverflowError 堆疊記憶體溢位

導致堆疊記憶體溢位的情況：

堆疊幀過多導致堆疊記憶體溢位
堆疊幀過大導致堆疊記憶體溢位

設定虛擬機堆疊記憶體大小：

在這里插入圖片描述

2-5 執行緒運行診斷

案例：CPU占用過高

Linux環境下運行某些程式的時候，可能導致CPU的占用過高，這時需要定位占用CPU過高的執行緒

用top定位哪個行程對cpu的占用過高
ps H -eo pid,tid,%cpu | grep 行程id ，剛才通過top查到的行程號，用ps命令進一步定位是哪個執行緒引起的cpu占用過高
jstack 行程id，通過查看行程中的執行緒的nid，剛才通過ps命令看到的tid來對比定位，注意jstack查找出的執行緒id是16進制的，需要轉換

3.本地方法堆疊

一些帶有native關鍵字的方法就是需要JAVA去呼叫本地的C或者C++方法，因為JAVA有時候沒法直接和作業系統底層互動，所以需要用到本地方法，

4.堆

4-1 定義

通過new關鍵字創建的物件都會使用堆記憶體

4-2 特點

它是執行緒共享的，堆中物件都需要考慮執行緒安全的問題
有垃圾回識訓制

4-3 堆記憶體溢位

java.lang.OutofMemoryError ：java heap space 堆記憶體溢位

案例：

/**
 * 演示堆記憶體溢位 java.lang.OutOfMemoryError: Java heap space
 * -Xmx8m ，最大堆空間的jvm虛擬機引數，默認是4g
 */
public class main1 {
    public static void main(String[] args) {
        int i = 0;

        try {
            ArrayList<String> list = new ArrayList<>();// new 一個list 存入堆中
            String a = "hello";
            while (true) {
                list.add(a);// 不斷地向list 中添加 a
                a = a + a;
                i++;
            }
        } catch (Throwable e) {// list 使用結束，被jc 垃圾回收
            e.printStackTrace();
            System.out.println(i);
        }
    }
}

結果：

java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Arrays.java:3332)
	at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
	at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:448)
	at java.lang.StringBuilder.append(StringBuilder.java:136)
	at com.itcast.itheima.xpp.main1.main(main1.java:14)
22

4-4 堆記憶體診斷

jps 工具

查看當前系統中有哪些 java 行程
jmap 工具

查看堆記憶體占用情況 jmap - heap 行程id
jconsole 工具

圖形界面的，多功能的監測工具，可以連續監測

5.方法區

5-1 定義

方法區是各個執行緒共享的記憶體區域，它用于**存盤已被虛擬機加載的類資訊(比如class檔案)、常量、靜態變數、即時編譯器編譯后的代碼等資料，（**什么是類資訊：類版本號、方法、介面，）

5-2 結構

永久代用的堆記憶體
元空間用的本地記憶體

5-3 方法區記憶體溢位

1.8以前會導致永久代記憶體溢位java.lang.OutOfMemoryError: PermGen space
1.8以后會導致元空間記憶體溢位java.lang.OutOfMemoryError: Metaspace

案例：

調整虛擬機引數：

在這里插入圖片描述

/**
 * 演示元空間記憶體溢位:java.lang.OutOfMemoryError: Metaspace
 * -XX:MaxMetaspaceSize=8m
 */
public class main1 extends ClassLoader {//可以用來加載類的二進制位元組碼

    public static void main(String[] args) {
        int j = 0;
        try {
            main1 test = new main1();
            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);
            }
        } finally {
            System.out.println(j);
        }
    }
}

Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
	at com.itcast.itheima.xpp.main1.main(main1.java:26)
4865

Process finished with exit code 1

5-4 通過反編譯來查看類的資訊

獲得對應類的.class檔案，javac xxx.java
- 在JDK對應的bin目錄下運行cmd，也可以在IDEA控制臺輸入
- 輸入 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

然后能在控制臺看到反編譯以后類的資訊了
- 類的基本資訊
- 常量池
- 虛擬機中執行編譯的方法（框內的是真正編譯執行的內容，#號的內容需要在常量池中查找）

5-5 運行時常量池

常量池：就是一張表，虛擬機指令根據這張常量表找到要執行的類名、方法名、引數型別、字面量等資訊
運行時常量池：常量池是 *.class 檔案中的，當該類被加載，它的常量池資訊就會放入運行時常量池，并把里面的符號地址變為真實地址

5-6 常量池與串池StringTable的關系

StringTable 特性

常量池中的字串僅是符號，只有在被用到時才會轉化為物件
利用串池的機制，來避免重復創建字串物件
字串變數拼接的原理是StringBuilder
字串常量拼接的原理是編譯器優化
可以使用intern方法，主動將串池中還沒有的字串物件放入串池中
- 1.8 將這個字串物件嘗試放入串池，如果有則并不會放入，如果沒有則放入串池，會把串池中的物件回傳
- 1.6 將這個字串物件嘗試放入串池，如果有則并不會放入，如果沒有會把此物件復制一份，放入串池，會把串池中的物件回傳

栗子1：

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）時，該字串才會被創建并放入串池中，

栗子2：使用拼接字串變數物件創建字串的程序

public class HelloWorld {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        String s4=s1+s2;//new StringBuilder().append("a").append("2").toString()  new String("ab")
        System.out.println(s3==s4);//false
//結果為false,因為s3是存在于串池之中，s4是由StringBuffer的toString方法所回傳的一個物件，存在于堆記憶體之中
    }
}

反編譯后的結果

	 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方法的回傳值是一個新的字串，但字串的值和拼接的字串一致，但是兩個不同的字串，一個存在于串池之中，一個存在于堆記憶體之中

栗子3：使用拼接字串常量物件的方法創建字串

public class HelloWorld {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        String s4=s1+s2;//new StringBuilder().a|ppend("a").append("2").toString()  new String("ab")
        String s5="a"+"b";
        System.out.println(s5==s3);//true
    }
}

反編譯后的結果

 	  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”，所以s5直接從串池中獲取值，所以進行的操作和 s3= “ab” 一致，
使用拼接字串變數的方法來創建新的字串時，因為內容是變數，只能在運行期確定它的值，所以需要使用StringBuilder來創建

intern方法 1.8：

呼叫字串物件的intern方法，會將該字串物件嘗試放入到串池中

如果串池中沒有該字串物件，則放入成功
如果有該字串物件，則放入失敗

無論放入是否成功，都會回傳串池中的字串物件

例子：

public class HelloWorld {

    public static void main(String[] args) {
        String x = "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
    }
}

intern方法 1.6：

呼叫字串物件的intern方法，會將該字串物件嘗試放入到串池中

如果串池中沒有該字串物件，會將該字串物件復制一份，再放入到串池中
如果有該字串物件，則放入失敗

無論放入是否成功，都會回傳串池中的字串物件

面試題（1.8）：

package com.itcast.itheima.xpp;

public class main {
    public static void main(String[] args) {

        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);//false
        System.out.println(s3==s5);//true
        System.out.println(s3==s6);//true

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


        String x4=new String("e")+new String("f");
        x4.intern();
        String x3="ef";
        System.out.println(x3==x4);//true

    }
}

5-7 StringTable 位置

在這里插入圖片描述

JDK1.6 時，StringTable是屬于常量池的一部分，
JDK1.8 以后，StringTable是放在堆中的，

5-8 StringTable 垃圾回收

StringTable在記憶體緊張時，會發生垃圾回收

5-9 StringTable 性能調優

因為StringTable是由HashTable實作的，所以可以適當增加HashTable桶的個數，來減少字串放入串池所需要的時間
```
-XX:StringTableSize=xxxx
//最低為1009
```
考慮是否將字串物件入池

可以通過intern方法減少重復入池，保證相同的地址在StringTable中只存盤一份

6.直接記憶體

6-1 定義

屬于作業系統，常見于NIO操作時，用于資料緩沖區
分配回收成本較高，但讀寫性能高
不受JVM記憶體回收管理

6-2 分配和回收原理

檔案讀寫程序：

使用了DirectBuffer：

直接記憶體是作業系統和Java代碼都可以訪問的一塊區域，無需將代碼從系統記憶體復制到Java堆記憶體，從而提高了效率

直接記憶體也會導致記憶體溢位

public class Main {
    static int _100MB = 1024 * 1024 * 100;

    public static void main(String[] args) throws IOException {
        List<ByteBuffer> list = new ArrayList<>();
        int i = 0;
        try {
            while (true) {
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100MB);
                list.add(byteBuffer);
                i++;
            }
        } finally {
            System.out.println(i);
        }

    }
}
//輸出：
2
Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
	at java.nio.Bits.reserveMemory(Bits.java:694)
	at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
	at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
	at main.Main.main(Main.java:19)

直接記憶體釋放原理：

直接記憶體的回收不是通過JVM的垃圾回收來釋放的，而是通過unsafe.freeMemory來手動釋放

通過申請直接記憶體，但JVM并不能回收直接記憶體中的內容，它是如何實作回收的呢？

//通過ByteBuffer申請1M的直接記憶體
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);

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 來釋放直接記憶體

最后喜歡的小伙伴別忘了一鍵三連哦🎈🎈🎈

在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/323297.html

標籤：其他

上一篇：hadoop集群拓撲配置

下一篇：2021-10-18-JMS學習總結

（超詳解）JVM-記憶體結構

文章目錄

JVM-記憶體結構

1.程式計數器

1-1 定義

1-2 作用

1-3 特點

2.虛擬機堆疊

2-1 定義

2-2 演示

2-3 常見問題

2-4 堆疊記憶體溢位

2-5 執行緒運行診斷

3.本地方法堆疊

4.堆

4-1 定義

4-2 特點

4-3 堆記憶體溢位

4-4 堆記憶體診斷

5.方法區

5-1 定義

5-2 結構

5-3 方法區記憶體溢位

5-4 通過反編譯來查看類的資訊

5-5 運行時常量池

5-6 常量池與串池StringTable的關系

5-7 StringTable 位置

5-8 StringTable 垃圾回收

5-9 StringTable 性能調優

6.直接記憶體

6-1 定義

6-2 分配和回收原理