#对象内存布局深度解析

public class MarkWordDemo {
    public static void main(String[] args) {
        Object obj = new Object();
        
        // Object 对象在没有偏向锁/轻量级锁的情况下：
        // Mark Word 存储：对象哈希码(25位) + GC年龄(4位) + 锁标志位(4位) + 偏向锁标志(1位)
        
        // 当对象被用作锁对象时，Mark Word 会根据锁状态发生变化
        synchronized (obj) {
            // 进入同步块，Mark Word 可能变成轻量级锁或偏向锁
        }
    }
}

public class ClassPointerDemo {
    public static void main(String[] args) {
        User user = new User();
        
        // user 对象的 Class Pointer 指向 User.class 元数据
        // JVM 通过这个指针确定 user 是 User 类的实例
        
        System.out.println(user.getClass());  // class User
    }
}

public class FieldAlignment {
    // 父类
    String name;      // 引用类型
    int id;           // int
    
    public static void main(String[] args) {
        // 实际内存布局（开启压缩指针）：
        // 对象头：12 字节
        // id (int): 4 字节
        // name (引用): 4 字节（如果是对象引用）
        // 对齐填充：0-3 字节，确保总大小是 8 的倍数
    }
}

public class BadFieldOrder {
    // 错误排列：窄类型在前，导致大量对齐填充
    boolean flag1;
    boolean flag2;
    boolean flag3;
    long id;      // 前面 3 个 boolean 需要 3 字节，long 需要对齐到 8
    // 对齐填充 5 字节
    
    // 实际占用：(3 + 5) + 8 = 16 字节的填充
}

public class GoodFieldOrder {
    // 正确排列：宽类型在前
    long id;          // 8 字节
    boolean flag1;    // 1 字节
    boolean flag2;    // 1 字节
    boolean flag3;    // 1 字节
    // 对齐填充：1 字节
    // 总共：12 字节
    
    // 相比错误排列节省了 4 字节
}

public class PaddingDemo {
    public static void main(String[] args) {
        // 开启压缩指针时：
        // new Object() 占用 16 字节
        // 对象头：12 字节
        // 对齐填充：4 字节
        // 总共：16 字节
        
        Object obj = new Object();
        
        // new Integer(0) 占用多少？
        // 对象头：12 字节
        // int value：4 字节
        // 对齐填充：0 字节（12 + 4 = 16）
        // 总共：16 字节
    }
}

public class ArrayLayoutDemo {
    public static void main(String[] args) {
        // int[] 数组的内存布局（开启压缩指针）：
        // 对象头：12 字节
        // 数组长度：4 字节
        // 元素：n * 4 字节
        // 对齐填充：确保总大小是 8 的倍数
        
        int[] arr = new int[10];
        // 大小：12 + 4 + 40 = 56 字节
    }
}

public class BadCache {
    // 使用 ArrayList 存储数百万个 Point 对象
    private List<Point> cache = new ArrayList<>();
    
    public void addPoints() {
        for (int i = 0; i < 1_000_000; i++) {
            // Point 类有两个 int 字段
            // 每个 Point 对象：12(头) + 4 + 4 + 4(对齐) = 24 字节
            // 100万个 Point：24MB
            cache.add(new Point(i, i));
        }
    }
}

class Point {
    int x;
    int y;
}

public class GoodCache {
    // 方案1：使用基本类型数组
    private int[] xCoords;
    private int[] yCoords;
    
    // 方案2：使用压缩数据类
    // 如果对象大小是 8 的倍数，可以节省对齐填充
    class Point {
        long xy;  // 将两个 int 合并为一个 long
        // 8 字节，无对齐填充
        
        public int getX() {
            return (int) (xy & 0xFFFFFFFFL);
        }
        
        public int getY() {
            return (int) (xy >> 32);
        }
    }
}

import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.vm.VM;

public class JolDemo {
    public static void main(String[] args) {
        System.out.println(VM.current().details());
        System.out.println(ClassLayout.parseInstance(new Object()).toPrintable());
        System.out.println(ClassLayout.parseInstance(new int[0]).toPrintable());
    }
}