揭秘对象

3. 揭秘对象

3.1对象是怎么产生的

　　我们都知道对象是类的一个实例,那么究竟该怎么理解呢?类被加载后存放在元空间(Metaspace),而实例一经创建却是在堆中分配空间,这两个空间又是通过什么来联系的?而对象又是如何被创建的,下面我们就来详细了解下.

3.1.1对象的创建--即内存分配

　　Java是一门面向对象的编程语言,在Java程序运行过程中无时无刻都有对象被创建出来.在语言层面上,创建对象(例如克隆、反序列化)通常仅仅是一个new关键字而已，而在虚拟机中，对象（本文探讨的对象仅限于Java对象，不包括数组和Class对象等）的创建又是怎样一个过程呢？

　　我们知道普通对象产生是通过new关键字来实现的，那么当虚拟机遇到new指令时会怎么做呢？虚拟机首先会检查这个指令的参数是否能在常量中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有加载，那必须先执行相应的类加载过程，关于类加载后面再做探讨。

　　在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定（后面我们讲怎么确定对象大小），为对象分配空间的任务等同于把一块确定大小的内存从Java堆中划分出来。假设Java堆中内存时绝对规整的，所有用过的内存放在一边，空闲的内存放在另一边，中间放置一个指针作为分界点的指示器。那所分配内存就仅仅是把那个指针向空闲空间那边挪动一段与对象大小相等的距离，这种分配方式称为“指针碰撞”（Bump the Pointer）。如果Java堆中的内存并不是规整的。已使用的内存和空闲的内存相互交错，那就没有办法简单的进行指针碰撞了，虚拟机就必须维护一个列表，记录上哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录，这种分配方式称为“空闲列表”（Free List）。选择哪种分配方式由Java堆是否规整决定，而Java堆是否规整又由采用的垃圾回收器是否带有压缩整理功能决定，因此，在使用Serial、ParNew等带有Compact过程的收集器时，系统采用的分配方式是指针碰撞，而使用CMS这种基于Mark-Sweep算法的收集器时，通常采用空闲列表。

　　除如何划分可用空间之外，还有另外一个需要考虑的问题是对象创建在虚拟机中是非常频繁地行为，即使是仅仅修改一个指针所指向的位置，在并发情况下也并不是线程安全的，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针来分配内存的情况。解决这个问题有两种方案，一种是对分配内存空间的动作进行同步处理-----实际上虚拟机采用CAS配上失败重试的方式保证更新操作的原子性：另一种是把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在Java堆中预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer，TLAB），哪个线程要分配内存，就在哪个线程的TLAB上分配，只有TLAB用完并分配新的TLAB时，才需要同步锁定。虚拟机是否使用TLAB，可以通过-XX：+/-UseTLAB参数来设定.

　　内存分配完成后,虚拟机需要将分配到的内存空间都初始化为零值(不包括对象头),如果使用TLAB.这一工作过程也可以提前至TLAB分配时进行.这一操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用,程序能访问到这些字段的数据类型所对应的零值.

　　接下来,虚拟机要对对象进行必要的设置,例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头（Object Header）之中。根据虚拟机当前的运行状态的不同。如是否启动偏向锁等，对象头会有不同的设置方式，关于对象头的具体内容，我们后面详细介绍。

　　在上面工作的完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从Java程序的视角来看，对象创建才刚刚开始-----<init>方法还没有执行,所有的字段都还为零.所以,一般来说(由字节码中是否跟随invokespecial指令所决定),执行new指令之后会接着执行<init>方法,把对象按照程序员的意愿进行初始化,这样一个真正可用的对象才是完全产生出来.

3.2 对象的内存布局

　　在上面我们知道了对象是怎么产生的,那么对象产生后在内存中是一种什么样的形态呢?除了对象头还有什么?这节我们就来好好了解一下.

　　在Hotspot虚拟机中,对象在内存中存储的布局可以分为三块区域:对象头(Header)、实例数据（Instance Data）和对齐填充(Padding).

　　HotSpot虚拟机的对象头包括两部分信息,第一部分用于存储对象自身的运行时数据,如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32位和64位的虚拟机（未开启压缩指针）中分别为32bit和64bit，官方称它为“Mark Word”，对象需要存储的运行时数据很多，其实已经超出了32位、64位Bitmap结构所能记录的限度,但是对象头信息是与对象自身定义的数据无关的额外存储成本，考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的信息,它会根据对象的状态复用自己的存储空间.例如,在32位的Hotspot虚拟机中,如果对象处于未被锁定的状态下,那么Mark Word的32bit空间中的25bit用于存储对象的哈希码,4bit用于存储对象分代年龄,2bit用于存储锁标志位,1bit固定为0,而在其他状态(轻量级锁定,重量级锁定,GC标记、可偏向)下对象的存储内容见下表。

　　对象头的另外一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。并不是所有的虚拟机实现都必须在对象数据上保留类型指针，换句话说，查找对象的元数据信息并不一定要经过对象本身，这点我们在对象的访问定位中介绍，另外，如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据，因为虚拟机可以通过普通Java对象的元数据信息确定Java对象的大小，但是从数组的元数据中却无法确定数组的大小。

　　接下来的实例数据部分是对象真正存储的有效信息,也是在程序代码中所定义的各种类型的字段内容.无论是从父类继承下来的,还是在子类中定义的,都需要记录起来.这部分的存储顺序受到虚拟机分配策略参数(FieldsAllocationStyle)和字段在Java源码中定义顺序的影响.HotSpot虚拟机默认的分配策略为longs/double、ints、shorts/chars、bytes/booleans、oops(Ordinary Object Pointers),从分配策略中可以看出,相同宽度的字段总是被分配到一起的.在满足这个前提条件的情况下,在父类中定义的变量总是出现在子类之前,如果CompactFields参数值为true(默认为true),那么子类之中较窄的变量也可能会插入到父类变量的空隙之中.

　　第三部分对齐填充并不是必然存在的,也没有特别的含义,它仅仅起着占位符的作用,由于HotSpot VM的自动内存管理系统要求对象起始地址必须是8字节的整数倍,换句话说,就是对象的大小必须是8字节的整数倍.而对象头部分正好是8字节的倍数(1倍或者2倍),因此,当对象实例数据部分没有对齐时,就需要通过对齐填充来补全.

3.3 对象的访问定位

建立对象的目的是为了使用对象,我们的Java程序需要通过栈上的reference数据来操作堆上的具体对象.由于reference类型在Java虚拟机规范中只规定了一个指向对象的引用,并没有定义这个引用应该通过何种方式去定位、访问堆中的对象的具体位置,所以对象的访问方式也是取决于虚拟机实现而定的.目前主流的访问方式有使用句柄和直接指针两种.

• 如果使用句柄访问的话，那么Java堆中将会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息，如下图所示：

　　　　　　　　　　　　　　　　通过句柄访问对象

• 如果使用直接指针访问、那么Java堆对象的布局中就必须考虑如何放置访问类型数据的相关信息，而reference中存储的直接就是对象地址,如下图所示:

 

　　　　　　　　　　　　　　通过直接指针访问对象

　　这两种对象访问方式各有优势,使用句柄来访问的最大好处就是reference中存储的是稳定的句柄地址,在对象被移动(垃圾收集时移动对象是非常普遍的行为)时只会改变句柄池中的实例数据指针,而reference本身不需要修改.

　　使用直接指针访问方式的最大好处就是速度更快,它节省了一次指针定位的时间开销,由于对象的访问在Java中非常频繁,因此这类开销积少成多后也是一项非常可观的执行成本.而我们讨论的HotSpot虚拟机就是使用的第二种方式进行对象访问的,但从整个软件开发的范围来看,各种语言和框架使用句柄来访问的情况也十分常见.

3.4 引用

　　无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象的引用链是否可达，判断对象是否存活都与“引用”有关。在JDK1.2以前，Java中的引用的定义很传统：如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就称这块内存代表着一个引用。这种定义很纯粹，但是太过狭隘，一个对象在这种定义下只有被引用或者没有被引用两种状态，对于如何描述一些“食之无味、弃之可惜”的对象就显得无能为力。我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存之中；如果内存空间在进行垃圾收集后还是紧张，则可以抛弃这些对象。很多系统的缓存功能都符合这样的应用场景。

　　在JDK1.2之后，Java对引用的概念进行了扩充，将引用分为强引用（Strong Reference）和软引用（Soft Reference）以及弱引用（Weak Reference）、虚引用（Phantom Reference）4种，这4种引用强度依次逐渐减弱。

•   强引用就是指在程序代码之中普遍存在的，类似“Object obj = new Object()”这类的引用,只要强引用还存在,垃圾收集器永远不会回收掉被引用的对象。
• 软引用是用来描述一些还有用但并非必须的对象。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出溢出异常。在JDK1.2之后，提供了SoftReference类来实现软引用。
• 弱引用也是用来描述非必要对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK1.2之后，提供了WeakReference类来实现弱引用。
• 虚引用也被称为幽灵引用或者幻影引用，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。在JDK1.2之后，提供了PhantomReference类来实现虚引用。

3.5 对象的生与死

　　即使在可达性分析算法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历两次标记过程：如果对象在进行可达性分析后发现没有与GC Roots相连接的引用链，那它将会被第一次标记并且进行一次筛选，筛选的条件是此对象是否有必要执行finalize（）。当对象没有覆盖finalize（），或者finalize（）方法已经被虚拟机调用过，虚拟机将这两种情况都视为“没有必要执行”。

　　如果这个对象被判定为有必要执行finalize（），那么这个对象就会放置在一个叫做F-Queue的对列之中,并在稍后由一个虚拟机自动建立的、低优先级的Finalizer线程去执行它。这里所谓的“执行”是指虚拟机会触发这个方法，但并不承诺会等待它运行结束，这样做的原因是，如果一个对象在finalize（）方法中执行缓慢，或者发生了死循环（更极端的情况），将很可能会导致F-Queue对列中其他对象永久处于等待,甚至导致整个内存回收系统崩溃。Finalize（）是对象逃脱死亡命运的最后一次机会，稍后GC将对F-Queue中的对象进行第二次小规模标记，如果对象要在finalize（）中成功拯救自己----只要重新与引用链上的任何一个对象建立关联即可，譬如把自己（this关键字）赋值给某个类变量或者对象的成员变量，那在第二次标记时它将被移除出“即将回收”的集合；如果对象这时候还没有逃脱，那基本上它就真的被回收了。下面我们通过一段代码来看一下：

package cn.object.life;

public class FinalizeEscapeGC {
    public static FinalizeEscapeGC SAVE_HOOK = null;
    
    public void isAlive(){
        System.out.println("yes,i am still alive :)");
    }
    
    @Override
    protected void finalize() throws Throwable {
        // TODO Auto-generated method stub
        super.finalize();
        System.out.println("finalize method is executed!");
        FinalizeEscapeGC.SAVE_HOOK = this;
    }
    
    public static void main(String[] args) throws InterruptedException {
        SAVE_HOOK = new FinalizeEscapeGC();
        //对象第一次拯救自己
        SAVE_HOOK = null;
        System.gc();
        //因为finalize方法优先级很低,所以暂停线程0.5秒等待
        Thread.sleep(500);
        if(SAVE_HOOK != null){
            SAVE_HOOK.isAlive();
        }else {
            System.out.println("no,i am dead :(");
        }
        //下面的代码与上面的代码完全相同,但是这次却自救失败了
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(500);
        if(SAVE_HOOK != null){
            SAVE_HOOK.isAlive();
        }else {
            System.out.println("no,i am dead :(");
        }
    }
}

　　从上面的运行结果可以看出，SAVE_HOOK对象的finalize（）确实被GC收集器触发过，并且在被收集前成功逃脱了。

　　另外一个需要注意的地方是，代码中有两段完全一样的代码片段，执行结果却是完全不同的，这是因为任何一个对象的finalize（）都只会被系统自动调用一次，如果对象面临下一次回收，它的finalize（）方法不会被再次执行，因此第二段代码的自救行动失败了。

　　需要特别说明的是，上面关于对象死亡时finalize（）方法的描述可能带有悲情的艺术色彩，并不鼓励通过这种方法来拯救对象。相反，应该尽量避免使用它，因为它不是C/C++中的析构函数,而是Java刚诞生时为了使C/C++程序员更容易接受他所做的一个妥协.它的运行代价高昂,不确定性大,无法保证各个对象的调用顺序。有些地方描述它适合做“关闭外部资源”之类的工作，这完全是对这个方法用途的一种自我安慰。Finalize（）能做的所有工作，使用try-finally或者其它方式可以做得更好、更及时，所以我们可以忽略这个方法了，知道对象回收的一个流程就可以了。