本文單個對象占用記憶體大小計算的思路（Shallow size)，主要基于ehcache源碼了解。

一、使用Instrumentation特性

主體思路

利用java.lang.instrument.Instrumentation getObjectSize函數，可以實時測量對象大小。

本思路關鍵在于通過Java agent得到Instrumentation對象即可，如下Java agent主要代碼：

public class SizeOfAgent {
    private static volatile Instrumentation instrumentation;
    public static void premain(String options, Instrumentation inst) {
        instrumentation = inst;
        registerSystemProperty();
    }

    public static void agentmain(String options, Instrumentation inst) {
        instrumentation = inst;
        registerSystemProperty();
    }

    public static Instrumentation getInstrumentation() {
        return instrumentation;
    }
    private SizeOfAgent() {
    }

    private static void registerSystemProperty() {
        System.getProperties().put("agent.instrumentation", instrumentation);        
    }
}

如何加載Agent

通過Jvm啟動參數加載agent的方式就不介紹了，但是想要作為第三方jar提供的話，使用方一般懶得去設定JVM參數。比較有意思的嘗試是程式自己如何attach agent到自己程式。

步驟：

1、準備VirtualMachine Class和 attach、detach、loadAgent Method；

2、得到本程序PID；

3、VirtualMachine對象attach， loadAgent agent.jar，VirtualMachine detach；

僞代碼：

1、得到VirtualMachine相關

static {
        Method attach = null;
        Method detach = null;
        Method loadAgent = null;
        try {
            Class<?> virtualMachineClass = getVirtualMachineClass();
            attach = virtualMachineClass.getMethod("attach", String.class);
            detach = virtualMachineClass.getMethod("detach");
            loadAgent = virtualMachineClass.getMethod("loadAgent", String.class);
        } catch (Throwable e) {
        }
        VIRTUAL_MACHINE_ATTACH = attach;
        VIRTUAL_MACHINE_DETACH = detach;
        VIRTUAL_MACHINE_LOAD_AGENT = loadAgent;
    }

2、嘗試通過MXBean得到本程序PID

String name = ManagementFactory.getRuntimeMXBean().getName();
String pid = name.substring(0, name.indexOf('@'));

3、Attach Agent

// 主要是上面的SizeOfAgent Class
File agent = getAgentFile();
Object vm = VIRTUAL_MACHINE_ATTACH.invoke(null, pid);
VIRTUAL_MACHINE_LOAD_AGENT.invoke(vm, agent.getAbsolutePath());
VIRTUAL_MACHINE_DETACH.invoke(vm);

4、通過SystemProperties或者SizeOfAgent來拿到Instrumentation對象

static boolean agentIsAvailable() {
    try {
        if (instrumentation == null) {
            instrumentation = (Instrumentation)System.getProperties().get("agent.instrumentation");
        }
        if (instrumentation == null) {
            Class sizeOfAgentClass = ClassLoader.getSystemClassLoader().loadClass("SizeOfAgent");
            Method getInstrumentationMethod = sizeOfAgentClass.getMethod("getInstrumentation");
            instrumentation = (Instrumentation)getInstrumentationMethod.invoke(sizeOfAgentClass);
        }
        return instrumentation != null;
    } catch (Throwable e) {
        return false;
    }
}

二、通過UnSafe特性計算記憶體偏移

基本思路是：利用UnSafe的objectFieldOffset功能得到對象相對最大的偏移，然後處理記憶體補齊就是對象占用記憶體。

數組類型計算

利用arrayBaseOffset和arrayIndexScale函數計算偏移。

Class<?> klazz = obj.getClass();
int base = UNSAFE.arrayBaseOffset(klazz);
int scale = UNSAFE.arrayIndexScale(klazz);
long size = base + (scale * Array.getLength(obj));
size += CURRENT_JVM_INFORMATION.getFieldOffsetAdjustment();
if ((size % CURRENT_JVM_INFORMATION.getObjectAlignment()) != 0) {
    size += CURRENT_JVM_INFORMATION.getObjectAlignment() - (size % CURRENT_JVM_INFORMATION.getObjectAlignment());
}
return Math.max(CURRENT_JVM_INFORMATION.getMinimumObjectSize(), size);

複合類型

利用UnSafe的objectFieldOffset函數計算偏移。

這裡從本Class開始計算然後才是ParentClass，并且一旦存在屬性停止向上；原因是因為Class儲存順序由父到子，子類最大偏移即為整個Class最大偏移。

for (Class<?> klazz = obj.getClass(); klazz != null; klazz = klazz.getSuperclass()) {
    long lastFieldOffset = -1;
    for (Field f : klazz.getDeclaredFields()) {
        if (!Modifier.isStatic(f.getModifiers())) {
            lastFieldOffset = Math.max(lastFieldOffset, UNSAFE.objectFieldOffset(f));
        }
    }
    if (lastFieldOffset > 0) {
        lastFieldOffset += CURRENT_JVM_INFORMATION.getFieldOffsetAdjustment();
        lastFieldOffset += 1;
        if ((lastFieldOffset % CURRENT_JVM_INFORMATION.getObjectAlignment()) != 0) {
            lastFieldOffset += CURRENT_JVM_INFORMATION.getObjectAlignment() -
                               (lastFieldOffset % CURRENT_JVM_INFORMATION.getObjectAlignment());
        }
        return Math.max(CURRENT_JVM_INFORMATION.getMinimumObjectSize(), lastFieldOffset);
    }
}

long size = CURRENT_JVM_INFORMATION.getObjectHeaderSize();
if ((size % CURRENT_JVM_INFORMATION.getObjectAlignment()) != 0) {
    size += CURRENT_JVM_INFORMATION.getObjectAlignment() - (size % CURRENT_JVM_INFORMATION.getObjectAlignment());
}
return Math.max(CURRENT_JVM_INFORMATION.getMinimumObjectSize(), size);

三、利用反射根據計算記憶體占用

基本思路是：得到對象以及父類繼承屬性，然後按照屬性類型得到占用記憶體大小然後“疊加”，同時還包括對象頭、執行個體資料、對齊填充、壓縮指針等。

數組類型計算

得到對象頭，makrword、klass指針、array length 。

得到數組長度然後疊加。

然後計算補齊。

僞代碼：

long size = CURRENT_JVM_INFORMATION.getObjectHeaderSize() + INT.getSize();
int length = Array.getLength(obj);
if (length != 0) {
    Class<?> arrayElementClazz = obj.getClass().getComponentType();
    if (arrayElementClazz.isPrimitive()) {
        size += length * PrimitiveType.forType(arrayElementClazz).getSize();
    } else {
        size += length * PrimitiveType.getReferenceSize();
    }
}
if ((size % CURRENT_JVM_INFORMATION.getObjectAlignment()) != 0) {
    size += CURRENT_JVM_INFORMATION.getObjectAlignment() - (size % CURRENT_JVM_INFORMATION.getObjectAlignment());
}

複合對象

得到本類以及父類所有定義的屬性（getDeclaredFields）。

考慮到單個類内部會進行重排和優化，首先計算每個類中各種類型屬性的數量，而不是按照定義順序依次疊加。

除了對象整體需要按8位元組對齊外，每個成員變量都盡量使本身的大小在記憶體中盡量對齊。比如 int 按 4 位對齊，long 按 8 位對齊。

類屬性按照如下優先級進行排列：長整型和雙精度類型；整型和浮點型；字元和短整型；位元組類型和布爾類型，最後是引用類型。這些屬性都按照各自的機關對齊。

優先按照規則一和二處理父類中的成員，接着才是子類的成員。

當父類中最後一個成員和子類第一個成員的間隔如果不夠4個位元組的話，就必須擴充到4個位元組的基本機關。

如果子類第一個成員是一個雙精度或者長整型，并且父類并沒有用完8個位元組，JVM會破壞規則2，按照整形（int），短整型（short），位元組型（byte），引用類型（reference）的順序，向未填滿的空間填充。

對象級别計算頭（makrword、klass指針）和填充。

僞代碼：

得到所有涉及的類

// 初始化對象頭大小
long size = CURRENT_JVM_INFORMATION.getObjectHeaderSize();
// 得到整個繼承結果上的Class
Stack<Class<?>> classStack = new Stack<Class<?>>();
for (Class<?> klazz = aClass; klazz != null; klazz = klazz.getSuperclass()) {
    classStack.push(klazz);
}

疊代按照規則計算屬性記憶體大小

// 從上往下處理。
Class<?> klazz = classStack.pop();
// 疊代單個類中定義屬性
Field f : klazz.getDeclaredFields()
    // 靜态忽略
    if (Modifier.isStatic(f.getModifiers())) {
        continue;
    }
    // 帶個按照類型計量
    if (f.getType().isPrimitive()) {
        switch (PrimitiveType.forType(f.getType())) {
            case BOOLEAN:
            case BYTE:
                bytes++;
                break;
            // SHORT,CHAR,INT,FLOAT,DOUBLE,LONG等依次case疊加
            default:
                throw new AssertionError();
        }
    } else {
        oops++;
    }
    if (doubles > 0 && (size % PrimitiveType.LONG.getSize()) != 0) {
        long length = PrimitiveType.LONG.getSize() - (size % PrimitiveType.LONG.getSize());
        size += PrimitiveType.LONG.getSize() - (size % PrimitiveType.LONG.getSize());

        while (length >= PrimitiveType.INT.getSize() && words > 0) {
            length -= PrimitiveType.INT.getSize();
            words--;
        }
        while (length >= PrimitiveType.SHORT.getSize() && shorts > 0) {
            length -= PrimitiveType.SHORT.getSize();
            shorts--;
        }
        while (length >= PrimitiveType.BYTE.getSize() && bytes > 0) {
            length -= PrimitiveType.BYTE.getSize();
            bytes--;
        }
        while (length >= PrimitiveType.getReferenceSize() && oops > 0) {
            length -= PrimitiveType.getReferenceSize();
            oops--;
        }
    }
    size += PrimitiveType.DOUBLE.getSize() * doubles;
    size += PrimitiveType.INT.getSize() * words;
    size += PrimitiveType.SHORT.getSize() * shorts;
    size += PrimitiveType.BYTE.getSize() * bytes;

    if (oops > 0) {
        if ((size % PrimitiveType.getReferenceSize()) != 0) {
            size += PrimitiveType.getReferenceSize() - (size % PrimitiveType.getReferenceSize());
        }
        size += oops * PrimitiveType.getReferenceSize();
    }

    if ((doubles + words + shorts + bytes + oops) > 0 && (size % PrimitiveType.getReferenceSize()) != 0) {
        size += PrimitiveType.getReferenceSize() - (size % PrimitiveType.getReferenceSize());
    }

整個類級别補齊

if ((size % CURRENT_JVM_INFORMATION.getObjectAlignment()) != 0) {
    size += CURRENT_JVM_INFORMATION.getObjectAlignment() - (size % CURRENT_JVM_INFORMATION.getObjectAlignment());
}

Java 單個對象占用記憶體大小的計算思路

一、使用Instrumentation特性

主體思路

如何加載Agent

二、通過UnSafe特性計算記憶體偏移

數組類型計算

複合類型

三、利用反射根據計算記憶體占用

數組類型計算

複合對象

繼續閱讀

微信登入的麻煩事就因為微信占用記憶體太大，解除安裝後重新登入--賬号密碼都記得1.登入後要求用舊手機掃描二維碼,我一直用這手機

手機難言三大痛：臃腫的系統固件、時不時自啟動的軟體程序、不可解除安裝的自帶軟體，于是手機運作越來越慢，動不動就卡頓[淚奔]從

華為自帶的手機管家無損壓縮功能真的很好用，幫你高效清理手機占用記憶體空間，省出多餘容量！越來越愛華為，越來越愛鴻蒙，哈哈😄

現在這應用動不動就好幾個G搞得現在手機都沒有記憶體了，存儲的視訊照片都沒有一個應用占用記憶體大，廠商就不能簡化app臃腫嗎？

手機記憶體不夠用怎麼辦？微信占用記憶體比較多，可能不是你手機記憶體不夠，而是你微信設定問題。打開微信選擇“設定”，“通用”，“

Java-檢視運作時對象占用記憶體

還真有人冒險把手裡的iPhone14更新到iOS17了，已經整理的這些bug，看看你還敢更新嗎～1.短信驗證碼，不能自動

悟空IM正式開源啦，零依賴，不需要部署redis，不需要部署AMQ，不需要部署db，一條指令輕松部署。完全開源，100%

好家夥！現在256GB的手機記憶體也不夠用了[允悲]，微信妥妥占了43.6GB。話說我的微信占用記憶體都比有些人的手機記憶體大

手機一定要關閉這三個危險開關。手機千萬不要打開這三個危險的開關，如果是打開的話不僅僅會影響到手機流量，還會偷偷的扣話費，

記憶體對齊,占用記憶體,結構體

輕松兩步清理抖音垃圾檔案，讓手機更加流暢。如果你的手機出現卡頓或記憶體不足的問題，不妨試試這個方法。這個方法非常簡單，兩步

【不忘初心美化版】[太陽谷]Windows101909(18363.2274)X64[精簡版](2023.7.12)最終

大家好，我是洛克楠楠。今天想和大家分享一下我使用蘋果14Pro拍攝視訊的感受。最近我在做中視訊創作，目标是沖擊1萬7的播

為什麼同樣是安卓系統，國内的就是不如國外流暢？首先，國外大部分都是原生安卓系統，功能精簡，占用記憶體空間也少，比如米UI1

微信内測“小綠書”卻網友在吐槽微信占用記憶體太大