java虚拟机_《深入理解Java虚拟机》：Java内存区域

Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域，这些区域称作运行时数据区域，分为5个部分：程序计数器、虚拟机栈、本地方法栈、堆、方法区。

这是在网上找的一张图，今天就来把各个区的用途和创建销毁时机来说一下。

1、程序计数器：它是当前程序执行的字节码的行号指示器，jvm执行引擎具体要执行哪一行指令，是由程序计数器来指示的。

javap是jkd自带的反编译命令，在命令行执行以下命令，得到MyStack的字节码文件，程序计数器指示的就是#1,#2,#3之类的行号：

javap -verbose MyStack.class > MyStack.txt
Constant pool:
   #1 = Class              #2             //  com/bill99/MyStack
   #2 = Utf8               com/bill99/MyStack
   #3 = Class              #4             //  java/lang/Object
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Methodref          #3.#9          //  java/lang/Object."<init>":()V
   #9 = NameAndType        #5:#6          //  "<init>":()V
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/bill99/MyStack;
  #14 = Utf8               print
  #15 = Fieldref           #16.#18        //  java/lang/System.out:Ljava/io/PrintStream;
  #16 = Class              #17            //  java/lang/System
  #17 = Utf8               java/lang/System
  #18 = NameAndType        #19:#20        //  out:Ljava/io/PrintStream;
  #19 = Utf8               out
  #20 = Utf8               Ljava/io/PrintStream;
  #21 = String             #22            //  print()
  #22 = Utf8               print()
  #23 = Methodref          #24.#26        //  java/io/PrintStream.println:(Ljava/lang/String;)V
  #24 = Class              #25            //  java/io/PrintStream
  #25 = Utf8               java/io/PrintStream
  #26 = NameAndType        #27:#28        //  println:(Ljava/lang/String;)V
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
  #29 = Utf8               main
  #30 = Utf8               ([Ljava/lang/String;)V
  #31 = Methodref          #1.#9          //  com/bill99/MyStack."<init>":()V
  #32 = Methodref          #1.#33         //  com/bill99/MyStack.print:()V
  #33 = NameAndType        #14:#6         //  print:()V
  #34 = Utf8               args
  #35 = Utf8               [Ljava/lang/String;
  #36 = Utf8               myStack
  #37 = Utf8               SourceFile
  #38 = Utf8               MyStack.java

2、虚拟机栈：每个方法在执行的时候都会创建一个栈帧，用于存储局部变量、操作数栈、动态链接、方法出口等信息然后压入虚拟机栈，每一个方法结束对应出栈的操作。

如下示例代码，debug调用栈也是main()方法先入栈，然后print()入栈，print()执行结束出栈，main()执行。

如下public class MyStack
{

	public void print(){
		System.out.println("print()");
	}
	public static void main(String[] args) {
		MyStack myStack = new MyStack();
		myStack.print();
	}
}

这块区域常见异常有两种：线程请求栈的深度大于虚拟机栈所允许的深度，将抛出StackOverflowError；栈扩展的时候无法申请到足够内存空间，则抛出OutOfMemoryError。

改写一下print()方法，让它不断递归调用自己，可以看到栈深度到1万以上抛异常了。

private static int depth = 0;
public void print(){
		System.out.println("print()"+(++depth));
		print();
}

print()11422
Exception in thread "main" java.lang.StackOverflowError

3、本地方法栈：由于java代码本身的限制，有些和操作系统直接交互的方法，可能是基于c或者c++编写的，java代码可以通过本地方法间接的去调用操作系统底层的一些功能。本地方法运行时使用的内存空间就是本地方法栈。

比如Thread类的一些方法，如下：

public static native Thread currentThread();
public static native void yield();

4、Java堆：Java堆是虚拟机管理内存中最大的一块，是被所有线程共享的一块内存区域，常说的线程安全，指的就是堆中对象的线程安全问题。几乎所有new出来的对象都存放在这里，常说的内存分配和垃圾回收，针对的就是堆内存。

堆内存按两部分划分，可以是新生代和老年代，比例1:2；更细粒度划分，新生代又分Eden(伊甸园区)，from，to，比例8:1:1.

1、创建一个MyHeap，这个对象有一个私有变量byte1，占1M内存

public class MyHeap
{

	private static final int MB = 1024 * 1024;
  byte[] byte1 = new byte[MB];
	public static void main(String[] args) {
		List<MyHeap> list = new ArrayList<>();
		MyHeap myStack = new MyHeap();
		list.add(myStack);
	}
}

2、配置堆内存初始值和最大值为20M，其中新生代占10M，并且打印堆内存信息

-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8

3、分析运行结果：

可以看出新生代PSYoungGen显示的内存总大小是9216K，为什么不是设置的10M呢？是因为from和to区总有一个是空闲的，不能用来存储对象的（因为垃圾回收需要复制，即从from复制到to，to必须和from空间一样大并且空闲，才能接收from的对象）。MyHeap对象占用了Eden2026K内存，2026K/8192K=24%；

老年代ParOldGen有堆内存-新生代：20M-10M=10240K；

永久代PSPermGen有20M。

Heap
 PSYoungGen      total 9216K, used 2026K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 24% used [0x00000000ff600000,0x00000000ff7faa88,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 0K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 0% used [0x00000000fec00000,0x00000000fec00000,0x00000000ff600000)
 PSPermGen       total 21504K, used 2550K [0x00000000f9a00000, 0x00000000faf00000, 0x00000000fec00000)
  object space 21504K, 11% used [0x00000000f9a00000,0x00000000f9c7d9f0,0x00000000faf00000)

5、方法区：与Java堆一样，是线程共享区域，主要存储类信息、常量、静态变量、即时编译器编译后的代码等数据。hotspot虚拟机实现中把此方法区又称作“永久代”。

运行时常量区：它是方法区的一部分。前面程序计数器字节码文件举例时，文件中Constant pool指的就是常量区，用于存放编译器生成的各种字面量和符号引用。

能进入常量池的内容不一定是编译器产生的，像String.intern();是在运行时把数据放入常量池的。

public static void main(String[] args) {
		String s1 = "a";//行号6
		String s2 = "b";//行号7
		String s3 = "ab";//行号8
		String s4 = s1+s2;//行号9
		System.out.println(s3==s4);//行号10
}//行号11

以上代码编译后的部分字节码如下，我们发现第9行代码编译成了new StringBuilder对象，而6,7,8行代码编译后分别是0,3,6对应的常量字符串，所以可以验证第11行输出肯定是false，因为s4对象在堆中，而s3在常量池。

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC

    Code:
      stack=3, locals=5, args_size=1
         0: ldc           #16                 // String a
         2: astore_1      
         3: ldc           #18                 // String b
         5: astore_2      
         6: ldc           #20                 // String ab
         8: astore_3      
         9: new           #22                 // class java/lang/StringBuilder
        12: dup           
        13: aload_1       
        14: invokestatic  #24                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
        17: invokespecial #30                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
        20: aload_2       
        21: invokevirtual #33                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        24: invokevirtual #37                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        27: astore        4
        29: getstatic     #41                 // Field java/lang/System.out:Ljava/io/PrintStream;
        32: ldc           #20                 // String ab
        34: aload         4
        36: if_acmpne     43
        39: iconst_1      
        40: goto          44
        43: iconst_0      
        44: invokevirtual #47                 // Method java/io/PrintStream.println:(Z)V
        47: return        
      LineNumberTable:
        line 6: 0     
        line 7: 3
        line 8: 6
        line 9: 9
        line 10: 29
        line 11: 47

用一下神奇的String.intern()，再看看结果

public static void main(String[] args) {
		String s1 = "a";//行号6
		String s2 = "b";//行号7
		String s3 = "ab";//行号8
		String s4 = s1+s2;//行号9
		System.out.println(s3==s4);//行号10
    String s5 = s4.intern();
		System.out.println(s3==s5);
  
}//行号11

System.out.println("ab"==s5);就会输出true，因为s4.intern()方法是主动把字符串放入常量池，s5现在是指向常量池中的ab。

6、直接内存：在没有直接内存的情况下，磁盘I/O的内容，需要先从磁盘读取到系统内存，然后再从系统内存读取到Java堆内存；而直接内存是系统内存和Java堆内存的一块共享内存区域，避免了在Java堆和Native堆中来回复制数据，很大的提高了读写性能。