Java JVM——10.对象实例化、内存布局、访问定位和直接内存

目录

• 对象实例化
  • 对象创建方式
  • 创建对象的步骤
  • 总结：对象实例化的过程
• 对象内存布局
  • 对象头
  • 实例数据（Instance Data）
  • 对象填充
  • 内存布局图解
• 对象的访问定位
  • 句柄访问
  • 直接指针（HotSpot采用）
• 直接内存（Direct Memory）
  • 非直接缓存区
  • 直接缓冲区
  • 使用NIO和BIO复制大文件
  • 直接内存与OOM

 

---

1|0对象实例化

1|1对象创建方式

　　★ new：最常见的方式、单例类中调用getInstance的静态类方法，XXXFactory的静态方法。

　　★ Class的newInstance方法：在JDK9里面被标记为过时的方法，因为只能调用空参构造器。

　　★ Constructor的newInstance(Xxx)：反射的方式，可以调用空参的，或者带参的构造器。

　　★ 使用clone()：不调用任何的构造器，要求当前的类需要实现Cloneable接口中的clone()方法。

　　★ 使用反序列化：反序列化一般用于Socket的网络传输。

　　★ 第三方库：Objenesis。

 

1|2创建对象的步骤

1|0① 判断对象对应的类是否加载、链接、初始化

　　虚拟机遇到一条new指令，首先去检查这个指令的参数能否在Metaspace的常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已经被加载、解析和初始化（即判断类元信息是否存在）。

　　如果没有，那么在双亲委派模式下，使用当前类加载器以ClassLoader + 包名 + 类名为key进行查找对应的.class文件。如果没有找到文件，则抛出ClassNotFoundException异常；如果找到，则进行类加载，并生成对应的Class对象。

1|0② 为对象分配内存

　　首先计算对象占用空间的大小，接着在堆中划分一块内存给该对象。如果实例的成员变量是引用变量，仅分配引用变量空间即可，即4个字节大小。

　　☂ 如果内存规整：

　　　　♬ 指针碰撞

　　☂ 如果内存不规整：

　　　　♬ 虚拟表需要维护一个列表，即空闲列表分配

　　如果内存是规整的，那么虚拟机将采用的是指针碰撞法（Bump The Point）来为对象分配内存。意思是所有用过的内存在一边，空闲的内存放另外一边，中间放着一个指针作为分界点的指示器，分配内存就仅仅是把指针指向空闲那边挪动一段与对象大小相等的距离罢了。

　　指针碰撞的优点是分配内存的速度很快，只需简单地移动一个指针即可完成。而且由于已分配的对象区域和未分配的空闲区域是连续的，所以内存的利用率也比较高。

　　然而，指针碰撞算法的缺点是需要保证堆内存的连续性，即堆内存必须是一块连续的内存空间。

　　如果垃圾收集器选择的是Serial、ParNew这种基于压缩算法的，Java堆空间是完整的，虚拟机采用这种分配方式。一般使用带Compact（整理）过程的这种收集器时，使用指针碰撞方式分配内存空间。

　　如果内存不是规整的，已使用的内存和未使用的内存相互交错，那么虚拟机将采用的是空闲列表（Free List）来为对象分配内存。意思是虚拟机维护了一个列表，记录上那些内存块是可用的，再分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的内容。

　　选择哪种分配方式由Java堆是否规整所决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。Serial、ParNew等压缩整理过程的收集器就使用“指针碰撞”，基于CMS这种清除算法就使用“空闲列表”。

1|0③ 处理并发问题

　　对象创建在虚拟机中是非常频繁的行为，即使仅仅修改一个指针所指向的位置，在并发情况下也并不是线程安全的，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针来分配内存的情况。两种解决方式：

　　☃ 对分配内存空间的动作进行同步处理——采用CAS配上失败重试保证更新的原子性。

　　☃ 把内存分配的动作按照线程划分在不同的空间中进行——在Eden区给每个线程预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer，简称TLAB），哪个线程要分配内存，就在哪个线程的本地缓冲区中分配，只有本地缓冲区用完了，分配新的缓存区时才需要同步锁定。通过设置-XX:+UseTLAB参数来设置（区域加锁机制）

1|0④ 初始化分配到的内存

　　内存分配完成之后，虚拟机必须将分配到的内存空间（但不包括对象头）都初始化为零值，如果使用了TLAB的话，这一项工作也可以提前至TLAB分配时顺便进行。这步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用，使程序能访问到这些字段的数据类型所对应的零值。

1|0⑤ 设置对象的对象头

　　将对象的所属类（即类的元数据信息）、对象的HashCode和对象的GC信息、锁信息等数据存储在对象的对象头中。这个过程的具体设置方式取决于JVM实现。

1|0⑥ 执行init方法进行初始化

　　在Java程序的视角看来，初始化才正式开始。

　　初始化成员变量，执行实例化代码块，调用类的构造方法，并把堆内对象的首地址赋值给引用变量。

　　给对象属性赋值的操作：

　　　　1、属性的默认初始化

　　　　2、显示初始化

　　　　3、代码块中的初始化

　　　　4、构造器初始化

　　因此一般来说（由字节码中跟随invokespecial指令所决定），new指令之后会接着就是执行init()方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完成创建出来。

 

1|3总结：对象实例化的过程

　　① 加载类元信息

　　② 为对象分配内存

　　③ 处理并发问题

　　④ 属性的默认初始化（零值初始化）

　　⑤ 设置对象头信息

　　⑥ 属性的显示初始化、代码块中初始化、构造器中初始化

 

---

 

2|0对象内存布局

2|1对象头

　　对象头包含了两部分，分别是运行时元数据（Mark Word）和类型指针。

　　如果是数组，还需要记录数组的长度。

1|0运行时元数据

　　用于存储自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分的数据的长度在32位和64位的虚拟机（未开启压缩指针）中分别为32个比特和64个比特，称它为“Mark Word”。

　　对象需要存储的运行时数据很多，其实已经超出了32、64位Bitmap结构所能记录的最大限度，但对象头里的信息是与对象自身定义的数据无关的额外存储成本，考虑到虚拟机的空间效率，Mark Word被设计成一个有着动态定义的数据结构，以便在极小的空间内存储尽量多的数据，根据对象的状态复用自己的存储空间。

　　例如：在32位的HotSpot虚拟机中，如对象未被同步锁锁定的状态下，Mark Word的32个比特存储空间中的25个比特用于存储对象哈希码，4个比特用于存储对象分代年龄，2个比特用于存储锁标志位，1个比特固定为0，在其他状态（轻量级锁定、重量级锁定、GC标记、可偏向）下对象的存储内容如下图所示:

　　64位Mark Word存储内容如下：

1|0类型指针

　　对象指向它的类型元数据的指针，Java虚拟机通过这个指针来确定该对象是哪个类的实例。并不是所有的虚拟机实现都必须在对象数据上保留类型指针，换句话说，查找对象的元数据信息并不一定要经过对象本身。

　　此外，如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据，因为虚拟机可以通过普通Java对象的元数据信息确定Java对象的大小，但是如果数组的长度是不确定的，将无法通过元数据中的信息推断出数组的大小。

 

2|2实例数据（Instance Data）

　　它是对象真正存储的有效信息，即我们在程序代码里面所定义的各种类型的字段内容，无论是从父类继承下来的，还是在子类中定义的字段都必须记录起来。

　　这部分的存储顺序会受到虚拟机分配策略参数（-XX：FieldsAllocationStyle参数）和字段在Java源码中定义顺序的影响。
　　HotSpot虚拟机默认的分配顺序为longs/doubles、ints、shorts/chars、bytes/booleans、oops（Ordinary Object Pointers，OOPs），从以上默认的分配策略中可以看到，相同宽度的字段总是被分配到一起存放，在满足这个前提条件的情况下，在父类中定义的变量会出现在子类之前。如果HotSpot虚拟机的+XX：CompactFields参数值为true（默认就为true），那子类之中较窄的变量也允许插入父类变量的空隙之中，以节省出一点点空间。

 

2|3对象填充

　　不是必须的，也没有特别的含义，仅仅起到占位符的作用。

 

2|4内存布局图解

 

---

 

3|0对象的访问定位

　　JVM是如何通过栈帧中的对象引用访问到其内部的对象实例呢？

　　创建对象自然是为了后续使用该对象，Java程序会通过栈上的reference数据来操作堆上的具体对象。由于reference类型在《Java虚拟机规范》里面只规定了它是一个指向对象的引用，并没有定义这个引用应该通过什么方式去定位、访问到堆中对象的具体位置，所以对象访问方式也是由虚拟机实现而定的，主流的访问方式主要有使用句柄和直接指针两种。

3|1句柄访问

　　句柄访问就是说栈的局部变量表中，记录的对象的引用，然后在堆空间中开辟了一块空间，也就是句柄池。reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自具体的地址信息。

优点：

　　reference中存储稳定句柄地址，对象被移动（垃圾收集时移动对象很普遍）时只会改变句柄中实例数据指针即可，reference本身不需要被修改。

缺点：
　　➹ 需要单独开辟空间存储句柄，有点浪费空间。
　　➹ 访问对象需要先通过引用找到句柄，再通过句柄中的变量找到对象实体，访问效率比较低。

 

3|2直接指针（HotSpot采用）

　　直接指针是局部变量表中的引用，直接指向堆中的实例，在对象实例中有类型指针，指向的是方法区中的对象类型数据。

优点：
　　访问速度更快，它节省了一次指针定位的时间开销，由于对象访问在Java中非常频繁，因此这类开销积少成多也是一项极为可观的执行成本。

 

---

 

4|0直接内存（Direct Memory）

　　不是虚拟机运行时数据区的一部分，也不是《Java虚拟机规范》中定义的内存区域。直接内存是在Java堆外的、直接向系统申请的内存区间。来源于NIO，通过存在堆中的DirectByteBuffer操作Native内存。通常，访问直接内存的速度会优于Java堆，即读写性能高。

　　　　★ 因此出于性能考虑，读写频繁的场合可能会考虑使用直接内存。

　　　　★ Java的NIO库允许Java程序使用直接内存，用于数据缓冲区。

　　使用下列代码，直接分配本地内存空间：

public class BufferTest {
    private static final int BUFFER = 1024 * 1024 * 1024;  // 1GB

    public static void main(String[] args){
        // 直接分配本地内存空间
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);

        Scanner scanner = new Scanner(System.in);
        scanner.next();
　
        // 释放本地内存空间
        byteBuffer = null;
        System.gc();
        scanner.next();
    }
}

 

4|1非直接缓存区

　　原来采用BIO的架构，我们需要从用户态切换成内核态。在读写本地文件时，需要与磁盘交互，需要由用户态切换到内核态，这里需要两份内存存储重复数据，效率低。

 

4|2直接缓冲区

　　使用NIO时，操作系统直接划出的直接缓存区可以被Java代码直接访问，只有一份。NIO适合对大文件的读写操作，直接操作物理磁盘。 

 

4|3使用NIO和BIO复制大文件

package com.ruoli.oom;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;


public class CopyFileOfNio {
    private static final int _100Mb = 1024 * 1024 * 100;

    public static void main(String[] args) {
        long sum = 0;
        String src = "D:\\MyData\\多媒体库\\视频\\Captures\\盗墓笔记.mp4";
        for (int i = 0; i < 3; i++) {
            String dest = "D:\\MyData\\多媒体库\\视频\\Captures\\copy\\盗墓笔记_" + i + ".mp4";
            // 使用传统方式复制文件
            //sum += io(src,dest);  // 215
            // 使用NIO方式复制文件
            sum += directBuffer(src, dest);  // 115
        }
        System.out.println("总花费的时间为：" + sum);
    }

    /**
     * 使用NIO方式
     * @param src
     * @param dest
     * @return
     */
    private static long directBuffer(String src, String dest) {
        long start = System.currentTimeMillis();
        FileChannel inChannel = null;
        FileChannel outChannel = null;
        try {
            inChannel = new FileInputStream(src).getChannel();
            outChannel = new FileOutputStream(dest).getChannel();
            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
            while (inChannel.read(byteBuffer) != -1) {
                //修改为读数据模式
                byteBuffer.flip();
                outChannel.write(byteBuffer);
                //清空
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inChannel != null) {
                try {
                    inChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outChannel != null) {
                try {
                    outChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        return end - start;
    }

    /**
     * 使用传统方式
     * @param src
     * @param dest
     * @return
     */
    private static long io(String src, String dest) {
        long start = System.currentTimeMillis();
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dest);
            byte[] buffer = new byte[_100Mb];
            while (true) {
                int len = fis.read(buffer);
                if (len == -1) {
                    break;
                }
                fos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        return end - start;
    }
}

 

4|4直接内存与OOM

　　直接内存也可能导致OutofMemoryError异常。由于直接内存在Java堆外，因此它的大小不会直接受限于-Xmx指定的最大堆大小，但是系统内存是有限的，Java堆和直接内存的总和依然受限于操作系统能给出的最大内存。

　　直接内存的缺点：

　　　　✘ 分配回收成本较高。

　　　　✘ 不受JVM内存回收管理。

　　直接内存大小可以通过-XX:MaxDirectMemorySize设置，如果不指定，默认与堆的最大值-Xmx参数值一致。

package com.ruoli.oom;

import java.nio.ByteBuffer;
import java.util.ArrayList;

/**
 * @ClassName: DirectOOM
 * @author ruoli
 * 
 * @Description: TODO
 * 
 *    测试本地内存的OOM
 *    java.lang.OutOfMemoryError: Direct buffer memory
 *
 */
public class DirectOOM {
    private static final int BUFFER = 1024 * 1024 * 20; // 20MB
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        int count = 0;
        try {
            while(true){
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
                list.add(byteBuffer);
                count++;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            System.out.println(count);
        }
    }
}

　　输出如下：

 

__EOF__

本文作者：城北有个混子
本文链接：https://www.cnblogs.com/ruoli-0/p/18238807.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！