对象的创建过程包括以下几个步骤：申请内存空间、赋予默认值、设置初始值。在这个过程中，可能会发生指令重排，导致对象处于半初始化状态。这也是为什么在dcl（双重检查锁定）单例模式中需要使用volatile关键字的原因，因为new操作可能会出现问题。

存储器的层次结构如图所示：

硬件层的数据一致性协议有很多种，其中Intel使用的是MESI协议。

现代CPU的数据一致性是通过缓存锁（如MESI等）和总线锁来实现的。读取缓存是以cache line为基本单位，目前是64字节。如果同一缓存行的两个不同数据被两个不同CPU锁定，会产生互相影响的伪共享问题。使用缓存行的对齐可以提高效率，如disruptor框架所利用的。

乱序问题（读）：CPU为了提高效率，如果没有直接依赖关系，会在一条指令执行的过程中（读数据慢100倍）同时执行另一条指令。写操作也可以进行合并，放在WCBuffer（4个位置）中执行。

案例：

package com.mashibing.juc.c_029_WriteCombining;
public final class WriteCombining {
    private static final int ITERATIONS = Integer.MAX_VALUE;
    private static final int ITEMS = 1;
    // ...
}

为了保证特定情况下不发生乱序，JVM使用内存屏障来确保有序性。硬件层面上的实现不一定依赖硬件级别的内存屏障，还可以依赖硬件级别的lock指令。

硬件CPU内存屏障包括：

• sfence：在sfence指令前的写操作必须在sfence指令后的写操作前完成。
• lfence：在lfence指令前的读操作必须在lfence指令后的读操作前完成。
• mfence：在mfence指令前的读写操作必须在mfence指令后的读写操作前完成。

JVM级别如何规范（JSR133）：

• LoadLoad屏障：对于语句Load1; LoadLoad; Load2，确保在Load2及后续读取操作访问数据前，Load1要读取的数据被读取完毕。
• StoreStore屏障：对于语句Store1; StoreStore; Store2，确保在Store2及后续写入操作执行前，Store1的写入操作对其它处理器可见。
• LoadStore屏障：对于语句Load1; LoadStore; Store2，确保在Store2及后续写入操作被刷出前，Load1要读取的数据被读取完毕。
• StoreLoad屏障：对于语句Store1; StoreLoad; Load2，确保在Load2及后续所有读取操作执行前，Store1的写入对所有处理器可见。

volatile的实现细节：

1. 字节码层面：ACC_VOLATILE
2. JVM层面：Volatile内存区的读写都加屏障
   • StoreStoreBarrier
   • volatile 写操作
   • StoreLoadBarrier
   • LoadLoadBarrier
   • volatile 读操作
   • LoadStoreBarrier
3. OS和硬件层面：使用lock指令实现（如在Windows上）或MESI协议。

synchronized的实现细节：

1. 字节码层面：ACC_SYNCHRONIZED，monitorenter和monitorexit（两个）
2. JVM层面：C++调用了操作系统提供的同步机制
3. OS和硬件层面：在X86上使用lock cmpxchg指令

对象的创建过程：

1. class loading

2. class linking（verification, preparation, resolution）

3. class initializing

4. 申请对象内存

5. 成员变量赋默认值

6. 调用构造方法<init></init>

   成员变量顺序赋初始值

   执行构造方法语句

   易企秀

   易企秀，一体化创意设计营销平台。超100万模板1键套用3分钟制作，随时随地完成创意设计营销。

   下载

对象在内存的存储布局：

首先查看自己虚拟机的配置：java -XX:+PrintCommandLinesFlags -version

红色的参数就是内存布局

对象的内容（对象的内存布局也可以这么说）：

普通对象：

1. 对象头markword（8字节）
2. ClassPointer指针（-XX:+UseCompressedClassPointers为4字节，不开启为8字节）
3. 实例数据引用类型（-XX:+UseCompressedOops为4字节，不开启为8字节，Oops = Ordinary Object Pointers）
4. Padding对齐（8的倍数）

数组对象：

1. 对象头markword（8字节）
2. ClassPointer指针（-XX:+UseCompressedClassPointers为4字节，不开启为8字节）
3. 数组长度（4字节）
4. 数组数据
5. 对齐（8的倍数）

首先一个class load到内存的时候有一个agent来截获或修改，需要自己实现它（premain方法），相当于代理。

实验：

1. 新建项目ObjectSize（1.8）
2. 创建文件ObjectSizeAgent

package com.mashibing.jvm.agent;
import java.lang.instrument.Instrumentation;
<p>public class ObjectSizeAgent {
private static Instrumentation inst;</p><pre class="brush:php;toolbar:false;"><code>public static void premain(String agentArgs, Instrumentation _inst) {
    inst = _inst;
}

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

}

3. 在src目录下创建META-INF/MANIFEST.MF

<code>Manifest-Version: 1.0
Created-By: mashibing.com
Premain-Class: com.mashibing.jvm.agent.ObjectSizeAgent</code>

注意Premain-Class这行必须是新的一行（回车 + 换行），确认IDEA不能有任何错误提示。

4. 打包jar文件
5. 在需要使用该AgentJar的项目中引入该Jar包（project structure - project settings - library 添加该jar包）
6. 运行时需要该AgentJar的类，加入参数：

<code>-javaagent:C:\work\ijprojects\ObjectSize\out\artifacts\ObjectSize_jar\ObjectSize.jar</code>

7. 如何使用该类：

package com.mashibing.jvm.c3_jmm;</p><p>import com.mashibing.jvm.agent.ObjectSizeAgent;</p><p>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()));
}&
lt;/p><pre class="brush:php;toolbar:false;"><code>private static class P {
    // 8 _markword
    // 4 _oop指针
    int id;         // 4
    String name;    // 4
    int age;        // 4
    byte b1;        // 1
    byte b2;        // 1
    Object o;       // 4
    byte b3;        // 1
}

}

Object 16字节

Int 16字节

• -XX:+UseCompressedClassPointers -XX:+UseCompressedOops 这两个是分开的
• Oops = ordinary object pointers

Hotspot开启内存压缩的规则（64位机）：

1. 4G以下，直接砍掉高32位
2. 4G - 32G，默认开启内存压缩ClassPointers Oops (ordinary object pointers)
3. 32G，压缩无效，使用64位 内存并不是越大越好（^-^）

对象头具体包含什么：

具体看对象的状态

当一个对象计算过identityHashCode之后，不能进入偏向锁状态。