Home Tags Posts tagged with "内存情况"

内存情况

0 86

Java内存区域详解

如无特殊说明,都是针对HotSopt虚拟机;

HotSpot:HotSpot实际上是把Java的bytecode编译成Native code, 然后运行。

常见面试题

基本问题

介绍下Java内存区域(运行时数据区)

Java对象的创建过程(五步,能默写并知道每一步虚拟机做了什么)

对象的访问定位的两种方式(句柄和直接指针两种方式)

扩展问题

String类和常量池

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

一 概述

对于Java程序员来说,在虚拟机自动内存管理机制下,不再需要像C/C++程序开发那样为每一个new操作去写对应的delete/free操作,不容易出现内存泄露和内存溢出问题;正是因为Java程序员把内存控制权交给虚拟机,一旦出现内存泄漏和溢出方面的问题,如果不了解虚拟机是是怎样使用内存的,那么排查错误将会是一个非常艰巨的任务;

二 运行时数据区域

Java虚拟机在执行Java程序的过程中会把它管理的内存划分为若干个不同的数据区域;

JDK1.8:

线程私有的:

程序计数器   PCR

虚拟机栈   VM Stack

本地方法栈    Native Method Stack

线程共享的:

堆   Heap

方法区   Method Area

直接内存(非运行时数据区的一部分,不在上图中)

2.1程序计数器

程序计数器是一块较小的内存空间,可以看作是当前线程的字节码执行的行号指示器;字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支,循环,跳转,异常处理,线程恢复等功能都需要依赖这个计数器完成;另,为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各线程之间的程序计数器互不影响(以保存该线程的状态),独立存储,我们称这类内存区域为“线程私有”的区内存;

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

1.字节码解释器通过改变程序计数器来依次读取指令,从而实现代码的流程控制,如:顺序执行,选择,循环,异常处理;

2.在多线程的情况下,程序计数器用于记录当前线程执行的位置,从而当线程被切换回来的时候,能够知道该线程上次运行到哪儿了;

注意:程序计数器是唯一一个不会出现OutOfMemory的内存区域,它的生命周期随着线程的创建而创建,随着线程的结束而死亡(线程私有的内存区域都是如此,例如程序计数器,虚拟机栈,本地方法栈);

2.2Java虚拟机栈

与程序计数器一样,Java虚拟机也是线程私有的,它的生命周期和线程相同,描述的是Java方法执行的内存模型,每次方法调用的数据都是通过栈传递的;

Java内存可以粗略的区分为堆内存(Heap)和栈内存(Stack),其中栈就是现在说的虚拟机栈,或者说是虚拟机栈中局部变量表部分(实际上,Java虚拟机是由一个个栈帧组成,而每个栈帧中都拥有:局部变量表、操作数栈、动态链接、方法出口信息)

局部变量表:主要存放了编译器可知的各种数据类型(boolean,byte,char,short,int,float,long,double),对象引用(reference类型,它不同于对象本身,可能是一个指向对象起始地址的引用指针,也可能是指向一个代表对象的句柄);

Java虚拟机栈会出现两种错误:StackOverFlowError和OutMemoryError

StaclOverFlowError:若Java虚拟机栈的内存大小不允许动态扩展,那么当线程请求栈的深度超过当前虚拟机栈的最大深度时,就会抛出StackOverFlowError错误;

OutMemoryError:若Java虚拟机堆中没有空闲内存,并且垃圾回收器也无法提供更多内存的话,就会抛出OutOfMemoryError错误;

重要:那么方法/函数如何调用?

Java栈可类比数据结构中的栈,Java栈中保存的主要内存是栈帧,欸一次函数调用都会有一个对应的栈帧被压入Java栈,每一次函数调用结束后,都会有一个栈帧被弹出(线程调用A函数,A栈帧被压入Java虚拟机栈,A函数内部调用B函数,B栈帧被压入Java虚拟机栈,当B函数调用结束时,B栈帧被弹出,A函数调用结束时,A栈帧被弹出);

Java方法有两种返回方式:

1.return 语句;

2.抛出异常;

不管哪种返回方式都会导致栈帧被弹出;

2.3本地方法栈

和虚拟机栈所发挥的作用非常相似,区别是:虚拟机栈为虚拟机执行Java方法(也就是字节码)服务,而本地方法栈则为虚拟机所使用到的Native方法服务;在HotSpot虚拟机中和Java虚拟机栈合二为一;

本地方法被执行的时候,在本地方法栈也会创建一个栈帧,用于存放该本地方法的局部变量表、操作数栈、动态链接、出口信息;

方法执行完毕后相应的栈帧也会出栈并释放内存空间,也会出现StackOverFlowError和OutMemoryError两种错误;

2.4堆

Java虚拟机所管理的内存中最大的一块,Java堆是所有线程共享的一块内存区域,在虚拟机启动时创建;此内存区域的唯一目的就是存放对象实例,几乎所有的对象实例以及数组都在这里分配内存;

Java世界中“几乎”所有的对象都在堆中分配,但是随着JIT编译器(解释和编译共存)的发展和逃逸分析技术逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化,所有的内存都分配到对上也渐渐变得不那么“绝对”了;从JDK1.7开始已经默认开启逃逸分析(现在正使用着逃逸分析),如果某些方法中的对象引用没有被返回或者未被外面使用(也就是未逃逸出去),那么对象可以直接在栈上分配内存;

Java堆是垃圾收集器管理的主要区域,因此也被称作GC堆,从垃圾回收的角度,由于现在收集器基本都采用分代垃圾收集算法,所有Java堆还可以细分为:新生代、老年代,再细致一些有:Eden空间,From Survivor、To Survivor空间等;进一步划分的目的是为了更好地回收内存(实现各种内存回收算法,例如标记—清除,复制回收等),或者更快地分配内存;

JDK1.8之前永久代被元空间所取代,元空间使用的是直接内存;

 

2.5方法区

方法区与Java堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据;虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分,但是它却有一个别名叫做Non-Heap(非堆),目的应该是与Java堆区分开来;

方法区也被称为永久代;

2.5.1方法区和永久代的关系很像Java中接口和类的关系,类实现了接口,而永久代就是HotSpot虚拟机对虚拟机规范中方法区的一种实现方式;也就是说永久代是HotSpot的概念,方法区是虚拟机是Java虚拟机中规范中的定义,是一种规范,永久代是一种实现;其他的虚拟机并没有永久代这一说法(好比方法区是大家都承认的打饭要排队的规则,永久代则是具体某一个食堂对这个规则的实现,其他食堂则没有这个规则(没有永久代));

2.5.2常用参数

JDK1.8之前永久代还没被彻底移除的时候,通常通过下面这些参数调节方法区的大小;

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

相对而言,垃圾收集行为在这个区域是比较少出现的,但并非数据进入方法区后就“永久存在”了。

JDK 1.8 的时候,方法区(HotSpot 的永久代)被彻底移除了(JDK1.7 就已经开始了),取而代之是元空间,元空间使用的是直接内存。

 

下面是一些常用参数:

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

与永久代很大的不同就是,如果不指定大小的话,随着更多类的创建,虚拟机会耗尽所有可用的系统内存。

 

2.5.3 为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) 呢?

  1. 整个永久代有一个 JVM 本身设置固定大小上限,无法进行调整,而元空间使用的是直接内存,受本机可用内存的限制,虽然元空间仍旧可能溢出,但是比原来出现的几率会更小。

当你元空间溢出时会得到如下错误: java.lang.OutOfMemoryError: MetaSpace

你可以使用 -XX:MaxMetaspaceSize 标志设置最大元空间大小,默认值为 unlimited,这意味着它只受系统内存的限制。-XX:MetaspaceSize 调整标志定义元空间的初始大小如果未指定此标志,则 Metaspace 将根据运行时的应用程序需求动态地重新调整大小。

  1. 元空间里面存放的是类的元数据,这样加载多少类的元数据就不由 MaxPermSize 控制了, 而由系统的实际可用空间来控制,这样能加载的类就更多了。
  2. 在 JDK8,合并 HotSpot 和 JRockit 的代码时, JRockit 从来没有一个叫永久代的东西, 合并之后就没有必要额外的设置这么一个永久代的地方了。

 

运行时常量池

运行时常量池是方法区的一部分;Class文件中除了有类的版本、字段、方法、接口等描述信息外,还有常量池表(用于存放编译期生成的各种字面量和符号引用)

既然运行时常量池也是方法区的一部分,自然也受到方法区内存的限制,当常量池无法再申请到内存时,也会抛出OutOfMemoryError错误;

1.JDK1.7之前运行时常量池逻辑包含字符串常量池存放在方法区,此时HotSpot虚拟机对方法区的实现为永久代

2.JDK1.7字符串常量池从方法区拿到了堆中,仅仅是字符串常量池被单独拿到堆中,运行时常量池剩下的东西还在方法区,也就是HotSpot永久代;

3.JDK1.8HotSpot移除了永久代,用元空间取而代之,这时字符串常量池还在堆,运行时常量池还在方法区,只不过方法区的实现从永久代变成了元空间;

JVM常量池中存储的是引用;

 

2.7直接内存

直接内存并不是虚拟机运行时数据区的一部分,也不是虚拟机规范中定义的内存区域,但是这部分内存被频繁使用,而且也可能导致OutOfMemoryError错误出现;

JDK1.4中新加入的NIO(New Input/Output)类,引入了一种基于通道(Channel)与缓存区(Buffer)的I/O方式,它可以直接使用Native函数库直接分配堆外内存,然后通过一个存储在Java堆中的DirectByteBuffer对象作为这块内存的引用进行操作;这样就能再一些场景中显著提高性能,因为避免了在Java堆中和Native堆中来回复制数据;

本机直接内存的分配不会受到 Java 堆的限制,但是,既然是内存就会受到本机总内存大小以及处理器寻址空间的限制。

 

 

三 HotSpot虚拟机及Java对象

JAVA是解释型语言,但它并不一定被解释执行;早期的虚拟机确实一条一条指令解释执行,但人们发现这样效率太低,不满足各种要求,于是出现了许多其他虚拟机,如JIT(Just in time)的虚拟机,HotSpot也是类似一种虚拟机;

采用HotSpot的java虚拟机,将java的bytecode编译成Native code,然后运行;

实际上在HotSpot的虚拟机中,有两个技术是至关重要的:动态编译和Profiling,HotSpot对bytecode的编译,不是在程序运行之前预先编译的,而是在程序运行过程中,动态编译的;

hotspot使用运行监视器来监视程序运行中有那一部分运用频度大,哪些对性能的影响至关重要;对于哪些对程序运行效率影响较大的代码,称之为热点,即hot spot,HotSpot会把这些部分(热点)动态地编译成机器码,Native code,同时也对机器码进行优化,从而提高运行效率;而运行较少的Code,HotSpot虚拟机就不再浪费时间将其编译;

总体来看 Java bytecode以解释方式被load到虚拟机,但虚拟机的分析器根据一段运行,获知对程序执行效率影响最大的部分,然后通过动态编译,同时进行优化,编译成机器码,然后为接下来的运行部分加速;

总的来说,HotSpot对bytecode有三层处理:不编译,编译,编译并优化;至于程序哪部分不便宜,那部分编译,那部分做何种优化,由Profile  Monitor决定;

补充:静态编译器通常很难准确预知程序运行过程中究竟什么部分最需要优化,静态编译器虽然可以把java全部编译成Native Code,但做不到动态编译器那样的优化;

 

HotSpot虚拟机在Java堆中对象分配,布局和访问的全过程;

3.1对象的创建

step1.类加载检查

虚拟机在遇到一条new指令时,首先去检查这个指令的参数是否能在常量池中定位到这个类的符号引用,并且检查这个符号引用代表的类是否已经被加载过,解析和初始化过,如果没有,必须先执行相应的类加载过程;

step2.分配内存

在类加载检查通过后,接下来虚拟机为新生对象分配内存,对象所需的大小在类加载后即可确定,为对象分配空间的任务等同于把一块确定大小的内存从java堆中划分出来;分配方式有“指针碰撞”和“空闲列表”两种,选择哪种分配方式由Java堆是否规整决定,而Java堆是否规整又由其所采用的垃圾收集器是否具有压缩整理功能决定;

内存分配的两种方式:

选择“指针碰撞”还是“空闲列表”的分配内存空间的方式由Java堆是否规整决定,而Java堆是否规整,取决于GC收集器的算法是“标记-清除”还是标记-整理(压缩),值得注意的是,复制算法内存也是规整的;

内存分配并发问题

在创建对象的时候有一个很重要的问题,就是线程安全,因为在实际开发过程中,创建对象是很频繁的事情,作为虚拟机来说,必须要保证线程是安全的,通常来讲,虚拟机采用两种方式来保证线程安全:

CAS+失败重试:CAS是乐观锁的一种实现方式,所谓乐观锁就是,每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败就重试,直到成功为止;虚拟机采用CAS配上失败重试的方式保证更新操作的原子性;

TLAB:为每一个线程预先在Eden区分配一块内存,JVM在给线程中的对象分配内存时,首先在TLAB分配,当对象大于TLAB中的剩余内存或者二TLAB内存已经用完时,再采用CAS+失败重试进行内存分配;

step3.初始化零值

内存分配完成后,虚拟机需要将分配到的内存空间都初始化为零值(不包括对象头),这一步操作保证了对下个的实例字段在Java代码中可以不赋初始值就可以使用,程序能访问到这些字段的数据类型所对应的零值(boolean—false);

step4.设置对象头

初始化零值完成之后,虚拟机要对对象进行必要的设置,例如这个对象是哪个类的实例,如何才能找到类的元数据类型, 对象的哈希码,对象的GC分代年龄等信息;这些信息存放在对象头中;另,根据虚拟机当前运行状态的不同,如是否采用偏向锁等,对象头会有不同的设置方式;

step5.执行init()方法

在上面工作都完成之后,从虚拟机角度上一个新的对象已经产生了,但从Java程序的视角来看,对象创建才刚刚开始,<init>方法还没有执行,所有的字段都还只是零值,所以一般来说,执行new指令之后会接着执行<init>方法,把对象按照程序员的意愿进行初始化;

3.2对象的内存布局

在HotSpot虚拟机中,对象在内存中的布局可以分为三块区域:对象头、实例数据和对齐填充;

HotSpot虚拟机的对象头包括两部分信息,第一部分用于存储对象自身的运行时数据(哈希码,GC分代年龄,锁状态标志等),另一部分是类型指针,即对象指向它的类元数据的指针,虚拟机通过这个指针来判断该对象是哪个类的实例;

实例数据部分是对象真正存储的有效信息,也就是程序中定义的各种类型的字段内容;

对齐填充部分不是必然存在的,也没有什么特别的含义,仅仅起占位作用;因为HotSpot虚拟机的自动内存管理系要求对象起始地址必须是8字节的整数倍,换句话说就是对象的大小必须是8字节的整数倍,而对象头部分正好是8字节的倍数(一倍或两倍),因此,当对象实例数据部分没有对齐时,就需要通过对齐填充来补全;

3.3对象的访问定位

建立对象的目的是为了使用对象,我们的Java程序通过栈上的reference数据来操作堆上的具体对象;对象的访问方式由虚拟机实现而定,目前主流的访问方式有:“使用句柄”    和     “直接指针”两种:

1.句柄:如果使用句柄的话,那么Java堆中将会划分出一块内存来作为句柄池,reference中存储的就是都西昂的句柄地址,而句柄地址中包含了对象实例数据与类型数据各自的具体地址信息;

2.直接指针:如果使用直接指针访问,那么Java堆对象的布局中就必须考虑如何方式访问类型数据的相关信息,而referece中存储的直接就是对象的地址;

这两种对象访问方式各有优势;使用句柄来访问的最大好处是reference中存储的是稳定的句柄地址,在对象被移动时只会改变句柄中的实例数据指针,而reference本身不需要修改;使用直接指针方式最大的好处是速度快,它节省了一次指针定位的时间开销;

 

 

四  重点内容补充

4.1Stirng类和常量池

String对象的两种创建方式:

String str1 = "abcd";//先检查字符串常量池中有没有"abcd",如果字符串常量池中没有,则创建一个,然后 str1 指向字符串常量池中的对象,如果有,则直接将 str1 指向"abcd"";
String str2 = new String("abcd");//堆中创建一个新的对象
String str3 = new String("abcd");//堆中创建一个新的对象
System.out.println(str1==str2);//false
System.out.println(str2==str3);//false

这两种创建对象的方式是有差别的;

第一种方式是在常量池中拿对象;

第二种方式是直接在堆内存空间创建一个新的对象;

关键点:只要使用new方法,就需要创建新的对象;

String类型的常量池比较特殊,它的主要使用方法有两种:

直接使用双引号声明出来的String对象会直接存储在常量池中;

如果不是双引号声明的String对象,可以使用String提供的intern方法;intern()是一个Native方法,它的作用是返回常量池中该字符串的引用了如果没有,JDK1.7之前的处理方式是在常量池中创建与此String内容相同的字符串,并返回常量池中创建的字符串的引用,JDK1.7及以后的处理方式是在常量池中记录此字符串的引用,并返回该引用;

String s1 = new String("计算机");
	      String s2 = s1.intern();
	      String s3 = "计算机";
	      System.out.println(s2);//计算机
	      System.out.println(s1 == s2);//false,因为一个是堆内存中的 String 对象一个是常量池中的 String 对象,
	      System.out.println(s3 == s2);//true,因为两个都是常量池中的 String 对象
字符串拼接
		  String str1 = "str";
		  String str2 = "ing";
		 
		  String str3 = "str" + "ing";//常量池中的对象
		  String str4 = str1 + str2; //在堆上创建的新的对象	  
		  String str5 = "string";//常量池中的对象
		  System.out.println(str3 == str4);//false
		  System.out.println(str3 == str5);//true
		  System.out.println(str4 == str5);//false
尽量避免多个字符串拼接,因为这样会重新创建对象。如果需要改变字符串的话,可以使用 StringBuilder 或者 StringBuffer。


4.2 String s1 = new String("abc")这句话创建了几个字符串对象?
将创建一个或者两个字符串对象;如果池中已经存在字符串常量"abc",则只会在堆空间创建一个字符串常量"abc",如果池中没有字符串常量"abc",那么它首先在池中创建,然后在堆空间创建,因此总共创建两个字符串对象;

验证:

		String s1 = new String("abc");// 堆内存的地址值
		String s2 = "abc";
		System.out.println(s1 == s2);// 输出 false,因为一个是堆内存,一个是常量池的内存,故两者是不同的。
		System.out.println(s1.equals(s2));// 输出 true

结果:

false
true

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

Java 基本类型的包装类的大部分都实现了常量池技术,即 Byte,Short,Integer,Long,Character,Boolean;前面 4 种包装类默认创建了数值[-128,127] 的相应类型的缓存数据,Character创建了数值在[0,127]范围的缓存数据,Boolean 直接返回True Or False。如果超出对应范围仍然会去创建新的对象。 为啥把缓存设置为[-128,127]区间?(参见issue/461)性能和资源之间的权衡。

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}
private static class CharacterCache {         
    private CharacterCache(){}
          
    static final Character cache[] = new Character[127 + 1];          
    static {             
        for (int i = 0; i < cache.length; i++)                 
            cache[i] = new Character((char)i);         
    }   
}

两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。

		Integer i1 = 33;
		Integer i2 = 33;
		System.out.println(i1 == i2);// 输出 true
		Integer i11 = 333;
		Integer i22 = 333;
		System.out.println(i11 == i22);// 输出 false
		Double i3 = 1.2;
		Double i4 = 1.2;
		System.out.println(i3 == i4);// 输出 false

Integer 缓存源代码:

/**
*此方法将始终缓存-128 到 127(包括端点)范围内的值,并可以缓存此范围之外的其他值。
*/
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

应用场景:

  1. Integer i1=40;Java 在编译的时候会直接将代码封装成 Integer i1=Integer.valueOf(40);,从而使用常量池中的对象。
  2. Integer i1 = new Integer(40);这种情况下会创建新的对象。
  Integer i1 = 40;
  Integer i2 = new Integer(40);
  System.out.println(i1==i2);//输出 false

Integer 比较更丰富的一个例子:

  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));
  System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
  System.out.println("i1=i4   " + (i1 == i4));
  System.out.println("i4=i5   " + (i4 == i5));
  System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
  System.out.println("40=i5+i6   " + (40 == i5 + i6));

结果:

i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

解释:

语句 i4 == i5 + i6,因为+这个操作符不适用于 Integer 对象,首先 i5 和 i6 进行自动拆箱操作,进行数值相加,即 i4 == 40。然后 Integer 对象无法与数值进行直接比较,所以 i4 自动拆箱转为 int 值 40,最终这条语句转为 40 == 40 进行数值比较。