JVM_06对象的实例化与内存布局以及直接内存

---

1. 对象的实例化

1.1 创建对象的方式

• new
  1. 最常见的方式；
  2. 变形1：xxx的静态方法；
  3. 变形2：xxbuilder，xxfactory的静态方法；
• class的newInstance()：反射的方式，只能调用空参的构造器；
• Constructor的newInstance(xxx)：反射的方式，可以调用空参的，有参的构造器，对权限没有要求；
• 使用clone()：不调用任何构造器，当前类需要实现Cloneable接口，实现clone()；
• 使用反序列化：从文件中，网络中获取一个文件的二进制流；
• 第三方库：Objenesis

1.2 创建对象的步骤

1. 判断对象对应的类是否已经加载，链接，初始化；

2. 为对象分配内存；

    如果内存规整则使用指针碰撞；
    如果内存不规整虚拟机需要维护一个列表，并采用空闲列表法；
   

3. 处理并发安全问题

    采用CAS配上失败重试保证更新的原子性；
    每个线程预先分配一份TLAB；
   

4. 初始化分配到的空间——所有的属性设置默认值，保证对象实例字段再不赋值时可以直接使用；

5. 设置对象的对象头；

6. 执行init方法进行初始化；

• 判断对象的类是否加载，链接，初始化：虚拟机遇到一条new指令，首先去检查这个指令的参数，能否在MeytaSpace的常量池中定位到一个类的符号引用，并且检查这个符号引用所代表的类是否已经被加载，链接，初始化（即判断类元信息是否存在）；如果没有，那么在双亲委派机制下使用当前的类加载器以ClassLoader+包名+类名为Key进行查找对应的.class我呢间，如果没有找到对应的文件，则抛出ClassNotFoundException异常，如果找到，则进行类加载，并生成对应的Class类对象；

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

  • 如果内存是规整的，则使用指针碰撞：指针碰撞的意思是所有使用过的内存在一边，没有使用过的内存在另一边，中间放着一个指针作为分界点的指示器；分配内存时就仅仅是把指针向着空闲区域那边移动一段与对象大小相等的区域罢了；如果若垃圾收集器选择的是Serial，PerNew这种基于压缩算法的，虚拟机将会采用这种分配方式，一般使用带有整理（compact）过程的收集器时，将会使用指针碰撞；
  • 如果内存不规整，虚拟机需要维护一个列表，并使用空闲列表进行空间的分配：这时，已使用的内存区域和没有被使用的内存区域交织在一起，虚拟机就必须维护一个用以记录空闲内存地址的空闲列表，在进行内存分配的时候虚拟机便会在空闲列表中找到一块足够大的空间划分给对象实例，并更新列表上的内容，这种分配方式被称为“空闲列表”；
  • 说明：选择哪种分配方式是由Java堆是否规整决定的，而Java堆是否规整又取决于垃圾收集器是否带有压缩整理的功能；
  • 给对象的属性赋值的操作：1. 属性的默认初始化；2. 显示初始化；3. 代码块中初始化； 4. 构造器中初始化；

• 处理并发安全问题：在分配内存空间时，另外一个问题是保证new对象时线程的安全性；因为创建对象是一个非常频繁的操作，虚拟机必须解决相关的并发问题；虚拟机采用了以下两种方式解决并发问题：

  1. CAS（Compare And Swap）失败重试，区域枷锁：保证指针更新操作的原子性；
  2. TLAB把内存分配的动作按照线程划分在不同的空间之中进行，即每一个线程在Java堆中预先分配一小块内存，称为本地线程内存缓冲区（TLAB），虚拟机是否使用TLAB可以通过参数-XX:+/-UseTLAB来设定；

• 初始化分配到的空间：内存分配结束，虚拟机将分配到的内存都初始化为零值（不包括对象头），这一步保证了对象的实例字段在Java代码中可以不用复制就可以直接使用，程序能访问到这些字段的数据类型所对应的零值；

• 设置对象的对象头：将对象的所属类（即类的元数据信息），对象的HashCode以及对象的GC信息，锁信息等数据存储在对象的对象头之中，这个过程的具体设置方式取决于JVM是如何实现的；

• 执行init方法进行初始化：在Java程序的视角来看，初始化才正式开始，初始化成员变量，执行实例化代码块，调用类的构造方法，并把堆内对象的首地址赋值给引用变量；因此一般来说（由字节码中是否跟随有invokespecial指令所决定），new指令之后就是执行方法，按照程序员的意愿进行初始化，这样一个真正可用的对象才算是完全创建出来；

• 代码实例：

/**
 * 测试对象实例化的过程
 * 1. 加载类元信息
 * 2. 为对象分配内存
 * 3. 处理并发问题
 * 4. 属性的默认初始化(零值初始化)
 * 5. 设置对象头的信息
 * 6.属性的显示初始化，代码块中初始化，构造器中初始化
 * 
 * 给对象的属性赋值的操作：
 * 1. 属性的默认初始化
 * 2. 显示初始化/代码块中初始化
 * 3. 构造器中初始化
 * 
 */
public class Customer{
    
    

    int id = 1001;
    String name;
    Account acct;

    {
    
    
        name = "匿名客户";
    }
    
    public Customer() {
    
    
        acct = new Account();
    }

}

class Account{
    
    

}

2. 对象的内存布局

对象头（Header）

• 对象头包含两部分（运行时元数据，类型指针）

• 运行时元数据

  • 哈希值（HashCode）
  • GC分代年龄
  • 锁状态标识
  • 线程持有的锁
  • 偏向线程ID
  • 偏向时间戳

• 类型指针：指向元数据的InstanceKlass，确定该对象所属的类型；

• 说明：如果是数组还需要记录数组的长度；

实例数据（Instance Data）

说明：它是对象真正存储的有效信息，包括程序代码中定义的各种类型的字段（包括从父类继承下来的和本身拥有的字段）；对应的规则为：

• 相同宽度的字段总是被分配在一起；
• 父类中定义的字段会出现在子类之前；
• 如果CompactFields参数为true（默认为true），子类的窄变量可能会插入到父类的空隙；

对其填充

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

小结

3. 对象的访问定位

JVM栈帧中的reference可以通过栈帧中的对象引用访问到其内部的对象实例（reference可以起到定位的作用）

对象的访问方式主要有两种：

• 句柄访问
  
• 直接指针（HotSpot采用的方式）
  

4. 直接内存

• 直接内存并不是虚拟机运行时数据区的一部分，也不是《Java虚拟机规范》中定义的内存区域；
• 直接内存是Java堆外的，直接向系统申请的内存区间；

/**
 *  IO                  NIO (New IO / Non-Blocking IO)
 *  byte[] / char[]     Buffer
 *  Stream              Channel
 *
 * 查看直接内存的占用与释放
 */
public class BufferTest {
    
    
    private static final int BUFFER = 1024 * 1024 * 1024;//1GB

    public static void main(String[] args){
    
    
        //直接分配本地内存空间
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
        System.out.println("直接内存分配完毕，请求指示！");

        Scanner scanner = new Scanner(System.in);
        scanner.next();

        System.out.println("直接内存开始释放！");
        byteBuffer = null;
        System.gc();
        scanner.next();
    }
}

• 来源于NIO，通过存在于堆中的DirectByteBuffer操作Native内存；

读写文件需要与磁盘进行交互，需要由用户态切换到内核态；
在内核态时需要内存执行如上图所示的操作，使用IO时需要
两份内存存储重复数据，效率极低；

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

• 通常访问直接内存的速度会优于Java堆，即读写性能高；因此出于性能考虑，对于读写频繁的操作可能就会考虑直接内存；Java的NIO库允许Java程序使用直接内存，用于数据缓冲。但是直接内存也可能会导致OOM；

/**
 * 本地内存的OOM:  OutOfMemoryError: Direct buffer memory
 */
public class BufferTest2 {
    
    
    private static final int BUFFER = 1024 * 1024 * 20;//20MB

    public static void main(String[] args) {
    
    
        ArrayList<ByteBuffer> 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);
        }
    }
}

• 由于直接内存在Java堆外，因此它的大小不会直接受限于-Xmx指定的最大堆空间的大小，但是系统内存的大小是有限的，Java堆和直接内存的总和还是会受限于操作系统所能提供的最大内存的大小；缺点是分配回收的成本极高且不受JVM内存回收管理；
• 直接内存的大小可以通过参数MaxDirectMemorySize设置，如果不指定的话默认是堆的最大值-Xmx参数值保持一致；
• 简单理解java process memory = java heap + native memory