Java虚拟机内存详解

概述

Java虚拟机会自动管理内存,不容易出现内存泄漏和内存溢出问题。Java虚拟机会在执行过程中将管理的内存分为若干个不同的数据区域。

运行时数据区域

在jdk1.8之前的版本与1.8版本略有不同,在jdk1.8之前:

jdk1.8:

以上图片来源:https://github.com/LikFre/JavaGuide

 线程共享区域:

    1.堆

    2.方法区

    3.直接内存(非运行时数据区)

线程私有区域:

    1.虚拟机栈

    2.本地方法栈

    3.程序计数器

线程私有区域:

1.虚拟机栈

  1.它的生命周期随着线程的创建而创建,随着线程的结束而死亡;

  2.描述的是java方法执行的内存模型,java虚拟机栈是由一个个栈帧组成,每个栈帧都有局部变量表、动态链接、操作数栈、方法出口信息。

  3.局部变量表主要存放可知的各种数据类型(8种基本数据类型变量,对象引用变量);

  4.Java虚拟机栈是线程私有的,每个线程都有自己的虚拟机栈;

  5.java虚拟机栈中主要存放的是一个个栈帧,每调用一次方法都会有对应的栈帧压入虚拟机栈,每一个方法执行结束后,都会有一个栈帧弹出。

    Java方法有两种返回方式:1、return;

                 2、抛出异常;

    这两种方式都会导致栈帧弹出;

  java虚拟机栈会出现两种异常:StackOverFlowError和OutOfMemoryError :

    1.StackOverFlowError:如果java虚拟机栈的内存大小不允许动态扩展,当虚拟机栈请求的内存超过栈的最大内存时就会出现StackOverFlowError异常;

    2.OutOfMemoryError:如果java虚拟机栈的内存大小允许动态扩展,当线程请求栈的内存已用完,且无法再动态扩展时,抛出OutOfMemoryError异常;

2.本地方法栈

  1.与java虚拟机栈的生命周期相同,都是线程私有,随着线程的创建而创建,线程的结束而死亡。

  2.描述的是Native方法执行的内存模型,也是由栈帧组成,每个栈帧用于存放本地方法的局部变量表,操作数栈、动态链接、方法出口信息;

  3.也会出现两种异常:StackOverFlowError和OutOfMemoryError

  在HotSpot虚拟机中,虚拟机栈与本地方法栈合二为一;

3.程序计数器

  1.程序计数器是一块较小的内存空间,字节码解释器通过改变计数器的值来选取下一条字节码指令。分支、跳转、循环、异常处理、线程恢复都需要依赖程序计数器;

  2.程序计数器也是线程私有的,每个线程都有自己的程序计数器;

  3.程序计数器主要有两个作用:

    1.字节码解释器通过改变程序计数器的值来顺序的执行字节码指令;如:顺序执行、循环、跳转等;

    2.在多线程环境下,程序计数器用于记录当前线程执行的位置,当CPU切换再次执行当前线程时从程序计数器记录的位置继续执行;

  注意:程序计数器是唯一一个不会出现OutOfMemoryError异常的内存区域,它的生命周期随着线程的创建而创建,线程的结束而死亡;

线程共享区域:

1.堆

  1.java虚拟机管理的最大的一块内存区域,是所有线程共享的内存区域,随着虚拟机的启动而创建,主要用于存放对象实例,几乎所有的对象实例和数组都在堆中存储

  2.堆也是垃圾收集器主要管理的区域,因此也被称为GC堆(Garbage Collected Heap);从垃圾回收的角度:由于现在的收集器都采用分代收集算法,堆又被分为:新生代和老年代,进一步分为Eden空间、From  Survivor、ToSurvivor。进一步划分目的是为了更好的回收内存或者更好的分配内存。

  

  3.上图中,Eden、S0、S1是新生代,TenTired是老年代。大部分情况,一个对象实例创建后存储在Eden区域,经历过一次垃圾回收之后,如果对象还存活,对象的年龄加+1(由Eden区进入到Survivor区),进入S0或者S1,当对象的年龄达到一定的阈值(默认是15),这个对象才会进入老年代区域,对象的阈值可以通过参数(-XX:MaxTenuringThreshold)来设置;

2.方法区

  1.与java堆一样,是线程共享的内存区域,主要用于存储加载过的类信息、被final修饰的常量、静态变量以及即时编译器编译的代码,虽然java虚拟机规范把方法区列为堆的一个逻辑部分,但是它却有一个别名NON-Heap(非堆),可能就是为了和堆区分开。

  2.方法区也被称为永久代,方法区是java虚拟机中的一种规范,并没有去实现它,在不同的JVM方法区的实现也不同,永久代是HotSpot的概念,在HotSpot虚拟机中永久代是对方法区的一种实现,其他的虚拟机并没有永久代这一说法。

  3.在jdk1.8之前,方法区还没有被移除,通过两个参数可以设置永久代的大小:

    -XX:PermSize=N //方法区 (永久代) 初始大小

    -XX:MaxPermSize=N //方法区 (永久代) 最大大小,超过这个值将会抛出 OutOfMemoryError 异常

  垃圾收集行为在这个区域很少出现,但并不是数据进入方法区就一直存在

  4.jdk1.8版本,方法区(永久代)被移除,取而代之的时元空间,使用的是直接内存,可以通过以下两个参数设置

     -XX:MetaspaceSize=N //设置 Metaspace 的初始(和最小大小)

     -XX:MaxMetaspaceSize=//设置 Metaspace 的最大大小

        与方法区最大的的不同就是,如果不指定大小,随着更多的类创建,虚拟机可能会耗尽所有可用的系统内存  

    5.为什么要用元空间替换永久代?

  整个永久代有JVM设置的固定大小上限,无法进行调整,而元空间使用的是直接内存,只受本机可用内存大小的限制,如果不指定最大元空间大小,-XX:MaxMetaspaceSize默认大小是unlimited,只受到本机可用内存大小限制,如果不指定初始大小,JVM会动态的分配应用程序所需要的大小。这只是其中一个原因,有兴趣的可以去查阅资料。

3.运行时常量池

  1.是方法区的一部分,主要用来存放编译器生成的各种字面量和引用。字面量(文本字符串、基本数据类型的值、声明为final的常量值、其他)

  2.常量池的大小也受到方法区大小的限制,超过常量池的大小会报OutOfMemoryError异常。

  3.jdk1.7及以后JVM将运行时常量池从方法区移出,在堆中开辟了一块区域用来存放运行时常量池。

直接内存:

  不属于运行时数据区,也不是虚拟机规范中定义的内存区域,但是被频繁的使用,也有可能引起OutOfMemoryError异常。

  jdk1.4中新加入的NIO,使用一种基于通道(Channel)和缓存(Buffer)的方式,直接使用Native方法分配堆外内存,通过在java堆中一个DirectByteBuffer对象作为这块内存的引用来操作,避免了java堆与Native堆之间来回复制数据,提高了性能。

HotSpot虚拟机:

1.对象的创建:

Step1:类加载检查,虚拟机遇到一条new指令时,首先检查指令的参数是否能在常量池中定位到这个类的符号引用,然后检查符号引用代表的类是否被加载、解析和初始化过,没有则执行相应的类加载过程。

Step2:分配内存,类加载检查通过后,虚拟机为新生的对象分配内存,在类加载完成后已经确定了对象的大小,分配内存实际就是在堆中分配一块确定大小的内存,分配内存有两种方式:指针碰撞空闲列表

    分配内存的方式取决于java堆内存是否规整,java堆内存是否规整取决于GC收集算法是“标记-清理”还是“标记-整理”;

    1.指针碰撞:堆内存规整,使用过的内存全部整合到一边,没有使用的内存在另一边,中间有一个分界值指针,只需要将指针往没有使用的内存方向移动对象内存大小即可。GC收集器:Serial、ParNew;

    2.空闲列表:堆内存不规整,虚拟机会维护一个列表,列表中记录未使用的内存大小,选择一块足够的内存来为对象分配,更新列表的记录。GC收集器:CMS

     分配内存的并发问题:对象的创建是很频繁的,虚拟机要保证线程的安全性,采用两种方式:

    1.CAS+失败重试:CAS是乐观锁的一种方式,每次认为不会有冲突的去执行某项操作,遇到冲突一直重试,知道成功为止。虚拟机使用CAS加失败重试的方式来保证更新操作的原子性。

    2.TLAB:为每一个线程预先在Eden区分配一块内存,线程为对象分配内存时,首先在TLAB中分配,TLAB中内存不够时或者已经用尽时,再使用CAS上述方式。

Step3:初始化零值,内存分配完成后,需要将分配到的内存空间初始化为零值,这一步保证了对象在不初始化的情况下,对象的实例字段在java代码中可以不赋初始值就使用。

Step4:设置对象头,初始化零值完成之后,虚拟机要对对象进行必要的设置,列如:这个对象是哪个类的实例、如何才能找到对象的元数据、对象的哈希码、对象的GC分代年龄等信息,这些信息存储在对象头中。

Step5:执行init方法,在new出对象之后,把对象按照程序员的意愿进行初始化,执行init方法。

2.对象在内存中的布局:

对象在内存中的布局可分为三个区域:对象头、实例数据和对齐填充

1.对象头分为两部分:一部分存储自身的运行时数据(哈希码、GC分代年龄等),另一部分类型指针,通过指针来确定这个对象是哪个类的实例

2.实例数据:是真正存储对象的有效信息,对象的各种类型的字段内容。

3.对齐填充:不是必然存在的只是起到占位作用。HotSpot虚拟机的自动内存管理系统要求对象的起始地址必须是8字节的整数倍,前两部分不足8字节的整数倍时,使用对齐填充补足。

3.对象的访问定位:

创建对象就是为了使用对象,通过在栈上存储的引用类型变量来操作堆上的具体类型变量,对象的访问方式由虚拟机决定,目前主流的有两种:①使用句柄 ②直接指针

1.使用句柄java堆中会有一块内存作为句柄池,栈中的引用类型变量中保存的是句柄池的句柄,句柄池中有对象的实例数据和对象类型信息的地址,也就是引用变量访问句柄池,句柄池再访问对象。

2.直接指针:栈中的引用类型变量中直接保存的是对象的地址,可以直接访问。

使用句柄访问的好处是,变量中保存的是稳定的句柄池的地址,在对象被移动时改变句柄池中的地址即可,变量保存的地址不需要改变。

使用直接指针的好处是:速度快,节省了一次指针定位的时间。

内容补充:

String类与常量池

String对象的两种创建方式:

String str1 = "Hello" ;
String str2 = new String("Hello");
String str3 = new String("Hello");
System.out.println(str1 == str2);//false
System.out.println(str2 == str3);//false

 str1.先检查常量池中有没有“Hello”,没有就在常量池中创建,人后str1指向常量池中“Hello”的地址,常量池中已经有的话,str1直接指向常量池中“Hello”的地址。

str2,在堆中重新创建一个新的对象

第一种方式:在常量池中拿对象,

第二种方式:直接在堆内存中创建新的对象

String类型的常量池有两种使用方式

        String str1 = new String("Hello" );
        String str2 = str1.intern();
        String str3 = "Hello";
        System.out.println(str1 == str2);//true
        System.out.println(str2 == str3);//false    

上述代码中 str2和str3指向的都是字符串常量池中的“Hello”

第一种方式:使用双引号声明的String对象会直接存储在常量池中

第二种方式:使用String提供的intern方法,intern()方法是一个本地方法,它的作用是:如果当前字符串对象的字符串已经在常量池中,那么直接返回常量池中该字符串的引用,如果当前字符串对象的字符串内容不在常量池中,那么在常量池中创建一个字符串,返回该字符串的引用。

字符串拼接:

        String str1 = "hel";
        String str2 = "lo";
        String str3 = "hel"+"lo";
        String str4 = str1 + str2;
        String str5 = "hello";
        System.out.println(str3 == str4);//false
        System.out.println(str4 == str5);//false
        System.out.println(str3 == str5);//true 

str4是在堆上新建的对象,str3与str5都是常量池中的“hello”

8种基本类型的包装类与常量池

java基本类型的包装类中有六种实现的常量池技术:Byte、Short、Integer、Long、Character、Boolean,前五种默认使用[-128,127]的缓存数据,超出这个范围才会创建对象。Double和Float没有实现常量池技术

Integer  i1 = 44; 默认使用Integer.valueOf(44),从而使用常量池中的数据,只有超过【-128,127】才会在对中创建对象。  

Integer i2 = new Integer(44);这种直接在堆中创建对象,

 Integer i1 = 40;
  Integer i2 = 40;
  Integer i3 = 0;
  Integer i4 = new Integer(40);
  Integer i5 = new Integer(40);
  Integer i6 = new Integer(0);
  
  System.out.println("i1=i2   " + (i1 == i2));//true
  System.out.println("i1=i2+i3   " + (i1 == i2 + i3));//true
  System.out.println("i1=i4   " + (i1 == i4));//false
  System.out.println("i4=i5   " + (i4 == i5));//false
  System.out.println("i4=i5+i6   " + (i4 == i5 + i6));//true   
  System.out.println("40=i5+i6   " + (40 == i5 + i6));//true

 i5+i6这个操作符“+”不适用于Integer对象,所以i5与i6自动拆箱,加之后就变为:i4=40,又因为i4是Integer对象,无法与int对象比较,i4自动拆箱为int值为40,所以相等

 原文地址:https://github.com/LikFre/JavaGuide/blob/master/docs/java/jvm/Java%E5%86%85%E5%AD%98%E5%8C%BA%E5%9F%9F.md

原文地址:https://www.cnblogs.com/YpfBolg/p/11066394.html