文章目录

前言
一、排序规范
- 1、happens-before原则
- 2、找文档位置
二、对象创建的过程（后面回答的就是这几个问题）
- 1、一线互联网企业面试题：关于对象
- 2、对象创建过程
三、对象在内存中的存储布局
- 1、1.8版本虚拟机配置
- 2、对象的内存布局
- - a、普通对象
  - b、数组对象
四、对象的大小
- 1、自定义 javaAgent查看对象大小
- 2、测试代码
- 3、解析4.2的测试代码结果
五、对象头MarkWord具体包括什么
- 1、概述
- 2、MarkWord 的 64 位
- 3、一些问题
- 4、synchronized 参考资料
六、对象怎么定位？
- 1. 句柄池
- 2、直接指针
- 3、比较
七、对象如何分配

前言

一、排序规范

java language Specification 中去找，去官网找到下图中去下载PDF。
这是java语言的一个要求，和JVM无关系。具体的由JVM去实现

1、happens-before原则

hanppens-before原则（JVM规定重排序必须遵守的规则）JLS17.4.5

程序次序规则：同一个线程内，按照代码出现的顺序，前面的代码先行于后面的代码，准确的说是控制流顺序，因为要考虑到分支和循环结构。
管程锁定规则：一个unlock操作先行发生于后面（时间上）对同一个锁的lock操作。
volatile变量规则：对一个volatile变量的写操作先行发生于后面（时间上）对这个变量的读操作。
线程启动规则：Thread的start( )方法先行发生于这个线程的每一个操作。
线程终止规则：线程的所有操作都先行于此线程的终止检测。可以通过Thread.join( ) 方法结束、Thread.isAlive( )的返回值等手段检测线程的终止。
线程中断规则：对线程interrupt( )方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupt( )方法检测线程是否中断
对象终结规则：一个对象的初始化完成先行于发生它的finalize()方法的开始。
传递性：如果操作A先行于操作B，操作B先行于操作C，那么操作A先行于操作C
as if serial
不管如何重排序，单线程执行结果不会改变

2、找文档位置

链接在此：https://docs.oracle.com/javase/specs/index.html

下图就是文中所在的内容：Happens-before 原则。

二、对象创建的过程（后面回答的就是这几个问题）

1、一线互联网企业面试题：关于对象

请解释一下对象的创建过程？
对象在内存中的存储布局？
对象头具体包括什么？
对象怎么定位？
- https://blog.csdn.net/clover_lily/article/details/80095580
对象怎么分配？ • GC相关内容
Object o = new Object在内存中占用多少字节？

2、对象创建过程

对象的创建过程

class loading
class linking (verification, preparation, resolution)
class initializing
申请对象内存
成员变量赋默认值
调用构造方法<init>
1. 成员变量顺序赋初始值
2. 执行构造方法语句

三、对象在内存中的存储布局

1、1.8版本虚拟机配置

java -XX:PrintCommandLineFlags -version：
XX:PrintCommandLineFlags：打印命令行的参数。
在显示version（版本）时，打印出命令行所自带的参数配置。如下图所示：
虚拟机启动时，自带的参数就显现出来了：
1. -XX:InitialHeapSize=132582976
  初始化堆大小
2. -XX:MaxHeapSize=2121327616
  堆最大值
3. -XX:+PrintCommandLineFlags
  当前参数
4. -XX:+UseCompressedClassPointers
  与对象头有关系，对象头指向下面的class的指针，默认是8字节，加上这个命令行就变成了 4字节。
5. -XX:+UseCompressedOops
  与对象内存布局有关系
  下面这两个与GC有关系，后面讲
6. -XX:-UseLargePagesIndividualAllocation
7. -XX:+UseParallelGC

2、对象的内存布局

对象的内存布局来讲，分为两种：

普通对象
数组对象

a、普通对象

对象头：markword 8个字节
ClassPointer指针：使用 -XX:+UseCompressedClassPointers 压缩后为4字节（默认开启），不开启为8字节，（一个对象，new出之后，这个对象属于哪个class，这里有个指针指向class的对象，）
实例数据（成员变量）
1. 引用类型：-XX:+UseCompressedOops 为4字节不开启为8字节
  Oops： Ordinary Object Pointers
Padding对齐，8的倍数。（比如算出来15个字节，但是64的机器，一块读64个字节，对齐为8的倍数。）

b、数组对象

对象头：markword 8
ClassPointer指针同上
数组长度：4字节（比普通对象多了这个）
数组数据
对齐 8的倍数

四、对象的大小

java 有一个agent的机制。

1、自定义 javaAgent查看对象大小

新建项目ObjectSize （1.8）

创建文件ObjectSizeAgent

package com.mashibing.jvm.agent;

import java.lang.instrument.Instrumentation;

public class ObjectSizeAgent {
    private static Instrumentation inst;

    public static void premain(String agentArgs, Instrumentation _inst) {
        inst = _inst;
    }

    public static long sizeOf(Object o) {
        return inst.getObjectSize(o);
    }
}

src目录下创建META-INF/MANIFEST.MF
```
Premain-Class: com.mashibing.jvm.agent.ObjectSizeAgent
```
注意Premain-Class这行必须是新的一行（回车 + 换行），确认idea不能有任何错误提示
打包jar文件（自行百度吧）
在需要使用该Agent Jar的项目中引入该Jar包，project structure - project settings - library 添加该jar包
运行时需要该Agent Jar的类，加入参数：-javaagent:C:\work\ijprojects\ObjectSize\out\artifacts\ObjectSize_jar\ObjectSize.jar（也就是在下面测试的程序中加上这个命令）

2、测试代码

package com.mashibing.jvm.c3_jmm;

import com.mashibing.jvm.agent.ObjectSizeAgent;

public class T03_SizeOfAnObject {
    public static void main(String[] args) {
        System.out.println(ObjectSizeAgent.sizeOf(new Object()));
        System.out.println(ObjectSizeAgent.sizeOf(new int[] {}));
        System.out.println(ObjectSizeAgent.sizeOf(new P()));
    }

    //一个Object占多少个字节
    // -XX:+UseCompressedClassPointers -XX:+UseCompressedOops
    // Oops = ordinary object pointers
    private static class P {
                        //8 _markword
                        //4 _class pointer
        int id;         //4
        String name;    //4
        int age;        //4

        byte b1;        //1
        byte b2;        //1

        Object o;       //4
        byte b3;        //1

    }
}

3、解析4.2的测试代码结果

默认带压缩测试：-XX:+UseCompressedClassPointers
1. new Object：为16个字节，对象头为8字节，ClassPointer 按说为8字节，但是使用了压缩命令 -XX:+UseCompressedClassPointers（默认的）所以为4字节，但是还有个padding对齐，为8的倍数，所以在加4个字节，就为8的倍数了，就是 8+4+4 = 16个字节。
2. new int[] {}：为16个字节，对象头8字节，ClassPointer 压缩后 4字节，数组长度为4字节，还未存数据，所以就是8+4+4=16个字节。
去掉压缩进行测试，ClassPointer 不压缩，在程序执行时加参数：-XX:-UseCompressedClassPointers ，就是将+号变成了-号即可。
1. 然后 new Object 还是 16（去掉了padding的4，ClassPointer 变成8）。
2. new int[]{} 变成了 24字节（对象头8+ClassPointer8+数组长度4 +还有padding对齐4=就是24了），
测试自己创建的对象，就是代码中的对象P（这里带压缩测试的）
1. MarkWord 对象头 8字节
2. ClassPointer指针 4字节
3. int id，为4字节
4. String name，按正常来说是8字节，但是这里是4字节，因为虚拟机默认的命令行有一个 -XX:+UseCompressedOops ，oops=ordinary object pointers，就是一般对象指针。连起来就是一般对象指针的压缩，这里就变成了 4字节（可以看出 class 对象普通对象是分开的）
  - -XX:-UseCompressedClassPointers：对象头指向 class的对象
  - -XX:+UseCompressedOops：成员变量的指针
5. byte 为 1字节
6. Object 为 4字节
7. 总结：加上对齐 32个字节。