HotSpot对象

2022-05-21  本文已影响0人  程序员札记

关于对象在内存中的体现，我们还是要先提到堆和栈的概念 我们用三个例子来说明对象在内存中的创建以及引用型变量如何与对象联系起来：

                   Car c=new Car();
                   c.num=4; 
                   c.color="red";
                   c.run();

new Car();是创建一个汽车类的对象。
Car c = new Car();为小汽车这个实体起一个名字叫c，类型是Car类型。将这个汽车对象的地址赋值给c。在内存中画图表示：


image.png

例子二：


        Car c1 = new Car();
        Car c2 = new Car();
        c1.num=5;         
        c2.color="red";    
        c1.run();
image.png

`例子三：

                Car c1 = new Car();
        Car c2 = c1;
        c1.num=8;          
        c2.color="red";    
        c1.run();
        c1 = null;
image.png

由上我们看出：
只有new关键字可以产生新对象，一旦产生一个对象，这个对象肯定具备该类中描述的内容，堆内存中的对象都是实体，实体就是封装数据，和数组类似，数组是封装同一类的数据，而对象封装的是一个事物当中所具备的数据。就比如说张三，也是一个对象，封装了自己独有的数据，和其他实体（人）不一样，所以才独立化，是单独的一个实体。
引用数据类型是通过地址指向对象，多个引用数据类型可以指向同一个对象，对象通过地址可以修改属性值。
当一个引用型变量为null时，它就不再指向任何一个对象了。所以我们知道其实引用型变量的值存放的是地址：
如下图，打印出的是c 的哈希地址，Car代表Car类型，@右边的值是地址。

image.png

对象的创建过程

对象的创建

image.png

  1. 指针碰撞：假设Java堆内存是规整的，所有已分配的内存都在一边，未分配的都在另一边， 中间有指针指示器用来分隔二者，那么分配内存就是把指针指示器移动和对象大小相等的举例，这种方式成为“指针碰撞”（Serial、ParNew垃圾收集器，使用了标记-整理算法，系统采用的分配算法就为指针碰撞，简单又高效）


    image.png

  1. 空闲列表：如果Java堆空间不是连续规整的，已分配的内存和空闲的内存混合在一起，那么就需要维护一个空闲列表，来记录哪些内存是可用的，在分配内存的时候从列表中找到一块足够大的空间给对象实例，并更新列表上的记录，这种方式称为“空闲列表”（CMS垃圾收集器，“理论上”就只能使用较为复杂的空闲列表，为什么是理论上呢？因为在CMS里为了更快的分配内存，设计了一个叫Linear Allocation Buffer的分配缓冲区，通过空闲列表拿到一大块分配缓冲区后，在它里面仍然可以使用指针碰撞方式来分配）


    image.png
  1. 内存的分配方式：选择以上两种方式的哪一种，取决于Java内存是否规整，而Java内存是否规整取决于GC收集器的算法是“标记-清除”还是“标记-整理”，复制算法内存也是规整的
  1. 内存分配并发问题：在创建对象的时候有一个很重要的问题就是线程安全，因为在实际开发过程中，创建对象是很频繁的事情，作为虚拟机来说必须要保证线程安全才行，通常来讲，虚拟机采用两种方式来保证线程安全：
    a. CAS+失败重试： CAS是乐观锁的一种实现方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作， 如果因为冲突失败就重试，直到成功为止。虚拟机采用CAS配上失败重试的方式保证更新操作的原子性。
    b. TLAB： 把内存分配的动作按照线程划分在不同的空间中进行，即每个线程在Java堆中预先分配一小块内存成为本地线程缓存（Thread Local Allocation Buffer），JVM在给线程中的对象分配内存的时候，首先在TLAB分配，当对象大于TLAB中剩余内存或者TLAB中内存用尽时，再采用上述的CAS分配(可以使用-XX:+/-UseTLAB参数来开启或关闭TLAB)。

对象的内存布局

image.png

在HotSpot虚拟机中，对象在内存中的布局可以分为3块区域：对象头、实例数据和对齐填充。

内存分析小工具：

<!-- JOL依赖 -->
<dependency>
   <groupId>org.openjdk.jol</groupId>
   <artifactId>jol-core</artifactId>
   <version>0.9</version>
</dependency>

对象头包括两部分信息

  1. 第一部分用于存储对象自身的运行时数据（官方称为Mark Word）：哈希码、GC分代年龄、锁状态标志等


    image.png

32位的HotSpot虚拟机中，如对象未被同步锁锁定的状态下，Mark Word的有25bit用于存储对象的hashCode，4个比特用于存储对象分代年龄，2个比特用于存储锁标志位，1个比特固定为0，在其他状态下锁标志位的状态如下：


image.png

64位的HotSpot虚拟机中，Mark Word的存储情况如下:


image.png
  1. 另一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针确定这个对象是哪个类的实例，如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据，因为虚拟机可以通过Java对象的元数据确定Java对象的大小，如果数组的长度不确定，将无法通过元数据信息推断出数组的大小。

实例数据

实例数据部分是对象真正存储的有效信息， 也是程序中所定义的各种类型的字段内容，无论是从父类继承下来的，还是在子类中定义的字段都必须记录下来。这部分的存储顺序会受到虚拟机分配策略参数（-XX:FieldsAllocationStype参数）和字段在Java源码中定义的顺序影响。HotSpot默认的分配顺序为longs/doules、ints、shorts/chars，bytes/booleans、oops(Ordinary Objects Poninters，OOPs)，相同大小的字段总是被分配到一起存储，在满足这个条件的情况下， 父类中定义的变量会出现在子类之前。如果使用-XX:CompactFields=true(默认为true)，那子类中较小的变量也允许插入父类变量的空隙中，以省出一点点空间。
对齐填充部分不是天然存在的，也没有什么特别的含义，仅仅起占位作用。 因为Hotspot的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或者2倍），因此，当对象的实例数据部分没有对齐的时候，就需要通过对齐填充来补全，。

对象的访问定位

建立对象就是为了使用对象，我们的Java程序通过栈上的reference数据来操作堆上的具体对象。对象的访问方式由虚拟机实现而定，主流的访问方式有两种：

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

重点：String类和常量池

String创建对象的两种方式

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

这两种创建方式是不同的，第一种是直接从常量池中把"abcd"的地址拿出来了；第二种通过new创建，会在堆中创建对象实例“abcd”。因此str1和str2中持有的分别是常量池的地址和堆的地址，false。


image.png

String类型的常量池比较特殊。使用方式：

直接使用双引号声明出来的String对象会直接存储在常量池中。
如果不使用双引号声明的String对象，可以使用String提供的intern()方法，String.intern()是一个Native方法，作用是：如果常量池中已经包含一个等于此String对象内容的字符串，则返回
常量池中该字符串的引用；如果没有，则在常量池中创建于此String内容相同的字符串，并返回常量池中创建的字符串的引用。

String s1 = new String("计算机");
String s2 = s1.intern();//s2持有的是常量池中字符串的地址
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。
String s = new String(“a”)创建了几个对象
创建了两个对象。
验证：

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

解释：先有字符串“abc”放入常量池，然后new了一个字符串“abc”放入Java堆（字符串常量“abc”在编译期就已经确定放入常量池，而Java堆上的“abc”是在运行期初始化阶段才确定）,然后Java虚拟机栈的s1指向Java堆上的“abc”。

String#intern

JDK6中，intern方法会把首次遇到的字符串实例复制到永久代的字符串常量池中存储，返回的也是永久代里面这个字符串引用。
JDK7中，intern方法实现就不需要再拷贝字符串的实例到永久代了，既然字符串常量池已经移到Java堆中，那只需要在常量池中记录一下首次出现实例的引用即可。
下面这段代码在JDK6、7中的执行结果不同

public class RuntimeConstantPoolOOM {
        public static void main(String[] args) {
            String str1 = new StringBuilder("计算机").append("软件").toString();
            System.out.println(str1.intern() == str1);
            String str2 = new StringBuilder("ja").append("va").toString();
            System.out.println(str2.intern() == str2);
        }
}

JDK6：false false
str1是虚拟机栈局部变量引用，str1.intern()持有的是"计算机软件"在永久代的引用。
str2持有的是虚拟机栈局部变量引用,
JDK7：true false
str
`

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

Java基本数据类型的包装类的大部分都实现了常量池技术，即Byte、Short、Long、Character、Boolean；这5种包装类默认创建了数值[-128,127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
两种浮点数类型的包装类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进行数值比较。

对象回收

对象已死吗

引用技术算法

客观地说，引用计数算法( Reference Counting)的实现简单，判定效率也很高，在大部分情况下它都是一个不错的算法，也有一些比较著名的应用案例，例如微软公司的COM(Component Object Model)技术、使用ActionScript 3的FlashPlayer、Python 语言和在游戏脚本领域被广泛应用的Squirrel中都使用了引用计数算法进行内存管理。但是，至少主流的Java虚拟机里面没有选用引用计数算法来管理内存，其中最主要的原因是它很难解决对象之间相互循环引用的问题。

举个简单的例子，请看代码清单3-1中的testGCO)方法:对象objA和objB都有字段instance,赋值令objA.instance = objB及objB.instance = objA,除此之外，这两个对象再无任何引用，实际上这两个对象已经不可能再被访问，但是它们因为互相引用着对方，导致它们的引用计数都不为0,于是引用计数算法无法通知GC收集器回收它们。

可达性分析

JAVA垃圾回收-可达性分析算法

https://blog.csdn.net/luzhensmart/article/details/81431212

通过一系列称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索走过的路径称为“引用链”，当一个对象到 GC Roots 没有任何的引用链相连时(从 GC Roots 到这个对象不可达)时，证明此对象不可用。

在Java语言中，可作为GC Roots的对象包含以下几种：

  1. 首先第一种是虚拟机栈中的引用的对象，我们在程序中正常创建一个对象，对象会在堆上开辟一块空间，同时会将这块空间的地址作为引用保存到虚拟机栈中，如果对象生命周期结束了，那么引用就会从虚拟机栈中出栈，因此如果在虚拟机栈中有引用，就说明这个对象还是有用的，这种情况是最常见的。

  2. 第二种是我们在类中定义了全局的静态的对象，也就是使用了static关键字，由于虚拟机栈是线程私有的，所以这种对象的引用会保存在共有的方法区中，显然将方法区中的静态引用作为GC Roots是必须的。

  3. 第三种便是常量引用，就是使用了static final关键字，由于这种引用初始化之后不会修改，所以方法区常量池里的引用的对象也应该作为GC Roots。

  4. 最后一种是在使用JNI技术时，有时候单纯的Java代码并不能满足我们的需求，我们可能需要在Java中调用C或C++的代码，因此会使用native方法，JVM内存中专门有一块本地方法栈，用来保存这些对象的引用，所以本地方法栈中引用的对象也会被作为GC Roots。

JVM之判断对象是否存活（引用计数算法、可达性分析算法，最终判定）

finalize()方法最终判定对象是否存活:

即使在可达性分析算法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历再次标记过程。

标记的前提是对象在进行可达性分析后发现没有与GC Roots相连接的引用链。

  1. 第一次标记并进行一次筛选。
    筛选的条件是此对象是否有必要执行finalize()方法。
    当对象没有覆盖finalize方法，或者finzlize方法已经被虚拟机调用过，虚拟机将这两种情况都视为“没有必要执行”，对象被回收。

  2. 第二次标记
    如果这个对象被判定为有必要执行finalize（）方法，那么这个对象将会被放置在一个名为：F-Queue的队列之中，并在稍后由一条虚拟机自动建立的、低优先级的Finalizer线程去执行。这里所谓的“执行”是指虚拟机会触发这个方法，但并不承诺会等待它运行结束。这样做的原因是，如果一个对象finalize（）方法中执行缓慢，或者发生死循环（更极端的情况），将很可能会导致F-Queue队列中的其他对象永久处于等待状态，甚至导致整个内存回收系统崩溃。

Finalize（）方法是对象脱逃死亡命运的最后一次机会，稍后GC将对F-Queue中的对象进行第二次小规模标记，如果对象要在finalize（）中成功拯救自己----只要重新与引用链上的任何的一个对象建立关联即可，譬如把自己赋值给某个类变量或对象的成员变量，那在第二次标记时它将移除出“即将回收”的集合。如果对象这时候还没逃脱，那基本上它就真的被回收了。

再谈引用

在JDK 1.2之后，Java对引用的概念进行了扩充，将引用分为强引用(Strong Reference)、软引用(Soft Reference)、弱引用( Weak Reference)、虚引用(Phantom Reference) 4种，这4种引用强度依次逐渐减弱。

即使在可达性分析算法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历再次标记过程。

标记的前提是对象在进行可达性分析后发现没有与GC Roots相连接的引用链。

  1. 第一次标记并进行一次筛选。
    筛选的条件是此对象是否有必要执行finalize()方法。
    当对象没有覆盖finalize方法，或者finzlize方法已经被虚拟机调用过，虚拟机将这两种情况都视为“没有必要执行”，对象被回收。

  2. 第二次标记
    如果这个对象被判定为有必要执行finalize（）方法，那么这个对象将会被放置在一个名为：F-Queue的队列之中，并在稍后由一条虚拟机自动建立的、低优先级的Finalizer线程去执行。这里所谓的“执行”是指虚拟机会触发这个方法，但并不承诺会等待它运行结束。这样做的原因是，如果一个对象finalize（）方法中执行缓慢，或者发生死循环（更极端的情况），将很可能会导致F-Queue队列中的其他对象永久处于等待状态，甚至导致整个内存回收系统崩溃。

    Finalize（）方法是对象脱逃死亡命运的最后一次机会，稍后GC将对F-Queue中的对象进行第二次小规模标记，如果对象要在finalize（）中成功拯救自己----只要重新与引用链上的任何的一个对象建立关联即可，譬如把自己赋值给某个类变量或对象的成员变量，那在第二次标记时它将移除出“即将回收”的集合。如果对象这时候还没逃脱，那基本上它就真的被回收了。

流程图如下：


image.png

回收方法区

很多人认为方法区（或者HotSpot虚拟机中的永久代）是没有垃圾收集的，Java虚拟机规范中确实说过可以不要求虚拟机在方法区实现垃圾收集，而且在方法区进行垃圾收集的“性价比”一般比较低：在堆中，尤其是在新生代中，常规应用进行一次垃圾收集一般可以回收70%~95%的空间，而永久代的垃圾收集效率远低于此。

永久代的垃圾收集主要回收两部分内容：废弃常量和无用的类。回收废弃常量与回收Java堆中的对象非常类似。以常量池中字面量的回收为例，假如一个字符串“abc”已经进入了常量池中，但是当前系统没有任何一个String对象是叫做“abc”的，换句话说是没有任何String对象引用常量池中的“abc”常量，也没有其他地方引用了这个字面量，如果在这时候发生内存回收，而且必要的话，这个“abc”常量就会被系统“请”出常量池。常量池中的其他类（接口）、方法、字段的符号引用也与此类似。

判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要同时满足下面3个条件才能算是“无用的类”：

该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例。
加载该类的ClassLoader已经被回收。
该类对应的java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。
虚拟机可以对满足上述3个条件的无用类进行回收，这里说的仅仅是“可以”，而不是和对象一样，不使用了就必然会回收。是否对类进行回收，HotSpot虚拟机提供了-Xnoclassgc参数进行控制，还可以使用-verbose:class及-XX:+TraceClassLoading、 -XX:+TraceClassUnLoading查看类的加载和卸载信息。

在大量使用反射、动态代理、CGLib等bytecode框架的场景，以及动态生成JSP和OSGi这类频繁自定义ClassLoader的场景都需要虚拟机具备类卸载的功能，以保证永久代不会溢出。

上一篇下一篇

猜你喜欢

热点阅读