【黑马程序员JVM学习笔记】02.内存结构

1.程序计数器

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

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

getstatic  #20    // PrintStream out = System.out;
astore_1          // --
aload_1           // out.print1n(1);
iconst_1          // --
invokevirtual #26 // --
aload_1           // out.println(2);
iconst_2          // --
invokevirtual #26 // --
aload_1           // out.println(3);
iconst_3          // --
invokevirtual #26 // --
aload_1           // out.println(4);
iconst_4          // --
invokevirtual #26 // --
aload_1           // out.println(5);
iconst_5          // --
invokevirtual #26 // --
return

特点：

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

2.虚拟机栈

定义：
Java Virtual Machine Stacks (Java虚拟机栈）

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

问题辨析
1.垃圾回收是否涉及栈内存？
2.栈内存分配越大越好吗？
3.方法内的局部变量是否线程安全？

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

栈内存溢出

栈帧过多导致栈内存溢出
栈帧过大导致栈内存溢出

/*演示栈内存溢出java.lang.StackOverflowError*/
public class Demo1_1 {
		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();
		}
}

线程运行诊断

案例1：cpu占用过多
定位

• 用top定位哪个进程对cpu的占用过高
• ps H-eo pid,tid,%cpu|grep进程id（用ps命令进一步定位是哪个线程引起的cpu占用过高）
• jstack 进程id
  • 可以根据线程id找到有问题的线程，进一步定位到问题代码的源码行号

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

3.本地方法栈

4.堆

定义：
Heap 堆

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

特点：

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

堆内存溢出

import java.util.ArrayList;
import java.util.List;
/*
演示堆内存溢出java.lang.OutOfError:Java heap space
*/
public class Demo1_2 {
		public static void main(String[] args) {
				int i = 0;
		try {
				List<String> list = new ArrayList<>();
				String a = "hello";
				while (true) {
						list.add(a);
						a=a+a;
						i++;
				} catch (Throwable e) {
						e.printStackTrace();
						System.out.println(i);
				}
		}
}

堆内存诊断

1. jps 工具

• 查看当前系统中有哪些java进程

2. jmap 工具

• 查看堆内存占用情况 jmap-heap进程id

3. jconsole 工具

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

/*演示堆内存*/
public class Demo1_3 {
		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(30000);
				array = null;
				System.gc();
				System.out.println("3...");
				Thread.sleep(1000000L);
		}
}

案例

垃圾回收后，内存占用仍然很高

5.方法区

定义

https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html

组成

方法区内存溢出

• 1.8以前会导致永久代内存溢出
• 1.8之后会导致元空间内存溢出

import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.Opcodes;
    /*
     *演示证元空间内存溢出
     *-XX:MaxMetaspaceSize=8m
     */
    public class Demo04 extends ClassLoader{//可以用来加载类的二进制字节码
    public static void main(String[] args) {
        int j = 0;
        try {
            Demo04 test = new Demo04();
            for (int i = 8; 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);
        }
    }
}

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

• 演示永久代内存溢出 java.lang.OutOfMemoryError：PermGen space
• -XX：MaxPermSize=8m

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

• 演示元空间内存溢出 java.1ang.OutOfMemoryError:Metaspace
• -XX：MaxMetaspaceSize=8m

场景

• spring
• mybatis

运行时常量池

• 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
• 运行时常量池，常量池是*.class文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

StringTable

jvm-StringTable详解_爱搞技术的吴同学的博客-CSDN博客_java stringtablesize

先看几道面试题：

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");//new String("cd")
String x1 = "cd";  //"cd"
x2.intern();
// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
System.out.println(x1 == x2);  //false

StringTable叫做字符串常量池，用于存放字符串常量，这样当我们使用相同的字符串对象时，就可以直接从StringTable中获取而不用重新创建对象。

字符串常量池 是 JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。

// 在堆中创建字符串对象"ab"
// 将字符串对象"ab"的引用保存在字符串常量池中
String aa = "ab";
// 直接返回字符串常量池中字符串对象”ab“的引用
String bb = "ab";
System.out.println(aa==bb);// true

StringTable 中保存的是字符串对象的引用，字符串对象的引用指向堆中的字符串对象。

StringTable特性

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

StringTable位置

StringTable垃圾回收
代码：

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

StringTable性能调优
可参见博客：JVM专题(八)-StringTable调优

6.直接内存

定义：

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

直接内存并不是虚拟机运行时数据区的一部分，也不是Java 虚拟机规范中定义的内存区域。在JDK1.4 中新加入了NIO(New Input/Output)类，引入了一种基于通道(Channel)与缓冲区（Buffer）的I/O 方式，它可以使用native 函数库直接分配堆外内存，然后通脱一个存储在Java堆中的DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在Java堆和Native堆中来回复制数据。

• 本机直接内存的分配不会受到Java 堆大小的限制，受到本机总内存大小限制
• 配置虚拟机参数时，不要忽略直接内存 防止出现OutOfMemoryError异常

直接内存（堆外内存）与堆内存比较

1. 直接内存申请空间耗费更高的性能，当频繁申请到一定量时尤为明显
2. 直接内存IO读写的性能要优于普通的堆内存，在多次读写操作的情况下差异明显

代码验证：

package org.example;
import java.nio.ByteBuffer;
/**
 * 直接内存 与  堆内存的比较
 */
public class ByteBufferCompare {
    public static void main(String[] args) {
        allocateCompare();   //分配比较
        operateCompare();    //读写比较
    }
    /**
     * 直接内存 和 堆内存的 分配空间比较
     * 
     * 结论： 在数据量提升时，直接内存相比非直接内的申请，有很严重的性能问题
     * 
     */
    public static void allocateCompare(){
        int time = 10000000;    //操作次数                           
        long st = System.currentTimeMillis();
        for (int i = 0; i < time; i++) {
            //ByteBuffer.allocate(int capacity)   分配一个新的字节缓冲区。
            ByteBuffer buffer = ByteBuffer.allocate(2);      //非直接内存分配申请     
        }
        long et = System.currentTimeMillis();

        System.out.println("在进行"+time+"次分配操作时，堆内存 分配耗时:" + (et-st) +"ms" );

        long st_heap = System.currentTimeMillis();
        for (int i = 0; i < time; i++) {
            //ByteBuffer.allocateDirect(int capacity) 分配新的直接字节缓冲区。
            ByteBuffer buffer = ByteBuffer.allocateDirect(2); //直接内存分配申请
        }
        long et_direct = System.currentTimeMillis();

        System.out.println("在进行"+time+"次分配操作时，直接内存 分配耗时:" + (et_direct-st_heap) +"ms" );
    }
    /**
     * 直接内存 和 堆内存的 读写性能比较
     * 
     * 结论：直接内存在直接的IO 操作上，在频繁的读写时 会有显著的性能提升
     * 
     */
    public static void operateCompare(){
        int time = 1000000000;

        ByteBuffer buffer = ByteBuffer.allocate(2*time);  
        long st = System.currentTimeMillis();
        for (int i = 0; i < time; i++) {

            //  putChar(char value) 用来写入 char 值的相对 put 方法
            buffer.putChar('a');
        }
        buffer.flip();
        for (int i = 0; i < time; i++) {
            buffer.getChar();
        }
        long et = System.currentTimeMillis();

        System.out.println("在进行"+time+"次读写操作时，非直接内存读写耗时：" + (et-st) +"ms");

        ByteBuffer buffer_d = ByteBuffer.allocateDirect(2*time);
        long st_direct = System.currentTimeMillis();
        for (int i = 0; i < time; i++) {

            //  putChar(char value) 用来写入 char 值的相对 put 方法
            buffer_d.putChar('a');
        }
        buffer_d.flip();
        for (int i = 0; i < time; i++) {
            buffer_d.getChar();
        }
        long et_direct = System.currentTimeMillis();

        System.out.println("在进行"+time+"次读写操作时，直接内存读写耗时:" + (et_direct - st_direct) +"ms");
    }
}

输出：
在进行10000000次分配操作时，堆内存 分配耗时:12ms
在进行10000000次分配操作时，直接内存 分配耗时:8233ms
在进行1000000000次读写操作时，非直接内存读写耗时：4055ms
在进行1000000000次读写操作时，直接内存读写耗时:745ms

可以自己设置不同的time 值进行比较

分析：

从数据流的角度，来看

非直接内存作用链:
本地IO –>直接内存–>非直接内存–>直接内存–>本地IO
直接内存作用链:
本地IO–>直接内存–>本地IO

直接内存使用场景

有很大的数据需要存储，它的生命周期很长
适合频繁的IO操作，例如网络并发场景

分配和回收原理

• 使用了Unsafe对象完成直接内存的分配回收，并且回收需要主动调用freeMemory方法
• ByteBuffer的实现类内部，使用了Cleaner(虚引用）来监测ByteBuffer对象，一旦ByteBuffer对象被垃圾回收，那么就会由ReferenceHandler线程通过Cleaner的clean方法调用freeMemory来释放直接内存