一个Java对象到底占用多大内存？

在进行 JVM 调优时，我们经常关注 JVM 各个区域大小以及相关参数，从而进行特定的优化，在一次排查内存溢出问题时我不禁想到一个问题，一个 Java 对象到底占用多大内存？下面我们就来分析验证下。

Java 对象内存结构

在 JVM 中，Java 对象都是在堆内存上分配的，想要分析出 Java 对象内存占用，首先要了解 Java 对象内存结构，一个 Java 对象内存占用由三部分组成：

对象头（Header）

实例数据（Instance Data）

对齐填充（Padding）

对象头（Header）

对象头的组成

虚拟机的对象头包括两部分信息，第一部分用于存储

对象自身的运行时数据

hashCode

GC分代年龄

锁状态标志

线程持有的锁

偏向线程ID

偏向时间戳

”Mark Word”

对象的另一部分是

类型指针（kclass）

指针压缩

从 JDK 1.6 update14 开始，64 bit JVM 正式支持了

-XX:+UseCompressedOops

如果

UseCompressedOops

所有对象的 klass 属性
所有对象指针实例的属性
所有对象指针数组的元素（objArray）

由此我们可以计算出对象头大小：

32位虚拟机对象头大小= Mark Word（4B）+ kclass(4B) = 8B
64位虚拟机对象头大小= Mark Word（8B）+ kclass(4B) = 12B

实例数据

一个 Java 对象中的实例数据可能包括两种，一是 8 种基本类型，二是实例数据也是一个对象，说到这里很多人可能有个误区：

基本类型在栈上分配内存？其实并不是，所谓“栈内存保存基本类型以及对象的引用(reference)，堆内存保存对象” 只是一句不严谨的话，实际仔细研究起来，栈内存（更专业的术语叫做堆栈）作为虚拟机作为方法调用和方法执行的数据结构，可能保存五种信息：

局部变量表
操作数栈
动态链接
方法返回地址
附加信息

其中局部变量表中存储了方法中的局部变量，可能为 8 种基本类型或者 reference

也就是说，栈内存中保存的基本类型，都是方法中的局部变量，而如果基本类型作为对象的实例变量，是在堆上分配空间的，此外，如果实例变量被final修饰，则既不在栈也不在堆上分配空间，而是分配到常量池里面。

8 种基本类型和 reference 大小在虚拟机上都是固定的,见下表

对齐填充（Padding）

由于虚拟机内存管理体系要求 Java 对象内存起始地址必须为 8 的整数倍，换句话说，Java 对象大小必须为 8 的整数倍，当对象头+实例数据大小不为 8 的整数倍时，将会使用Padding机制进行填充，譬如， 64 位虚拟机上 new Object() 实际大小为:

Mark Word（8B）+ kclass(4B)[开启指针压缩] = 12B

但由于Padding机制，实际占用空间为： Mark Word（8B）+ kclass(4B)[开启指针压缩]+Padding(4B) = 16B

数组的大小

Java 中数组也是一种对象，数组的大小与普通 Java 对象相比多了数组长度的信息（4B），即一个数组对象大小为 Mark Word（8B）+ kclass(4B)[开启指针压缩] + 数组长度(4B) = 16B

使用Instrumentation计算 Java 对象大小

现在我们已经知道了一个 Java 对象的大小 = 对象头 + 实例数据 + Padding ,现在，我们验证一下计算结果，google 到一个

Instrumentation

Instrumentation

Instrumentation

Instrumentation

本文不涉及

Instrumentation

Instrumentation

getObjectSize()

使用

Instrumentation

Instrumentation

Instrumentation

一 编写一个Instrumentation类作为代理

其中 premain 注入 Instrumentation ，sizeOf 用来计算对象占用空间

ObjectShallowSize.java:

package sizeof;

import java.lang.instrument.Instrumentation;

public class ObjectShallowSize {
private static Instrumentation inst;

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

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

二 打包

在 ObjectShallowSize.java 路径下新建 /META-INF/MANIFEST.MF 指定 Premain-Class 内容为：

Manifest-Version: 1.0
Premain-Class: sizeof.ObjectShallowSize

然后编译，打包

javac -d . ObjectShallowSize.java
jar cvfm java-agent-sizeof.jar META-INF/MANIFEST.MF  .

三 运行

编写一个测试模版类 ObjectSizeTest.java ，使用

java -javaagent:java-agent-sizeof.jar ObjectSizeTest

来运行程序

ObjectSizeTest.java 代码如下:

package sizeof;
public class ObjectSizeTest {

public static void main(String[] args) {
System.out.println(ObjectShallowSize.sizeOf(new ObjectSizeTest));
}
}

ObjectSizeTest 没有实例变量，理论计算

ObjectSizeTest大小 = Mark Word（8B）+ kclass(4B) [开启指针压缩]+Padding(4B) = 16B

为了方便，我们在 IDEA 中验证一下，导入刚才的 ObjectSizeTest 类，指定 JVM 参数如图

运行结果为 16B，和我们猜想一致

接下来我们在模版类中添加几个实例变量验证下

一

package sizeof;

public class ObjectSizeTest {

private int i;

public static void main(String[] args) {
System.out.println(ObjectShallowSize.sizeOf(new ObjectSizeTest()));
}
}

理论值：Mark Word（8B）+ kclass(4B) + i(4B) =

16B

实际值:

16B

二

package sizeof;

public class ObjectSizeTest {

private int i;
private int j;

public static void main(String[] args) {
System.out.println(ObjectShallowSize.sizeOf(new ObjectSizeTest()));
}
}

理论值：Mark Word（8B）+ kclass(4B) + i(4B) + j(4B)+Padding(4B) =

24B

实际值:

24B

三

package sizeof;

public class ObjectSizeTest {

private int i;
private int j;
private String s;
private boolean aBoolean;
private char c;

public static void main(String[] args) {
System.out.println(ObjectShallowSize.sizeOf(new ObjectSizeTest()));
}
}

理论值：Mark Word（8B）+ kclass(4B) + i(4B) + j(4B) + s(4B) + aBoolean(1B) + c(2B) + Paddding(5B) =

32B

实际值:

32B

四

package sizeof;

public class ObjectSizeTest {

private String s; // 4
private int i1; // 4
private byte b1; // 1
private byte b2; // 1
private int i2;// 4
private Object obj; //4
private byte b3;  // 1

public static void main(String[] args) {
System.out.println(ObjectShallowSize.sizeOf(new ObjectSizeTest()));
}
}

理论值：Mark Word（8B）+ kclass(4B) + s(4B) + i1(4B) + b1(1B) + b2(1B) + 2(padding) + i2(4B) + obj(4B)+ b3(1B) + Paddding(7B) =

40B

实际值:

32B

纳尼？这里为什么理论值和实际值不一致？

事实上，HotSpot创建的对象的字段会先按照给定顺序排列一下,默认的顺序如下，从长到短排列，引用排最后: long/double --> int/float --> short/char --> byte/boolean --> Reference

这个顺序可以使用JVM参数:

-XX:FieldsAllocationSylte = 0

按照这种方法我们来重新计算下对象大小

Mark Word（8B）+ kclass(4B) + i1(4B) + i2(4B) + b1(1B) + b2(1B) + b3(1B) + Paddding(1B) + s(4B) + obj(4B) = 32B

与预期值一致。

Java对象实际大小

前面我们计算 Java 对象大小时，对于实例变量为对象的，只计算了其reference的大小，实际应该也将实例变量本身计算在内，我们可以通过反射机制取出 Java 对象中实例变量，递归计算累加出实际大小。 http://yueyemaitian.iteye.com/blog/2033046 已经提供了现成的程序如下，使用fullSizeOf()方法即可计算出 Java 对象实际大小。

import java.lang.instrument.Instrumentation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.Set;

/**
* 对象占用字节大小工具类
* <p>
*
* @author tianmai.fh
* @date 2014-03-18 11:29
*/
public class SizeOfObject {
static Instrumentation inst;

public static void premain(String args, Instrumentation instP) {
inst = instP;
}

/**
* 直接计算当前对象占用空间大小，包括当前类及超类的基本类型实例字段大小、<br></br>
* 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小;<br></br>
* 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小 <br></br>
*
* @param obj
* @return
*/
public static long sizeOf(Object obj) {
return inst.getObjectSize(obj);
}

/**
* 递归计算当前对象占用空间总大小，包括当前类和超类的实例字段大小以及实例字段引用对象大小
*
* @param objP
* @return
* @throws IllegalAccessException
*/
public static long fullSizeOf(Object objP) throws IllegalAccessException {
Set<Object> visited = new HashSet<Object>();
Deque<Object> toBeQueue = new ArrayDeque<Object>();
toBeQueue.add(objP);
long size = 0L;
while (toBeQueue.size() > 0) {
Object obj = toBeQueue.poll();
//sizeOf的时候已经计基本类型和引用的长度，包括数组
size += skipObject(visited, obj) ? 0L : sizeOf(obj);
Class<?> tmpObjClass = obj.getClass();
if (tmpObjClass.isArray()) {
//[I , [F 基本类型名字长度是2
if (tmpObjClass.getName().length() > 2) {
for (int i = 0, len = Array.getLength(obj); i < len; i++) {
Object tmp = Array.get(obj, i);
if (tmp != null) {
//非基本类型需要深度遍历其对象
toBeQueue.add(Array.get(obj, i));
}
}
}
} else {
while (tmpObjClass != null) {
Field[] fields = tmpObjClass.getDeclaredFields();
for (Field field : fields) {
if (Modifier.isStatic(field.getModifiers())   //静态不计
|| field.getType().isPrimitive()) {    //基本类型不重复计
continue;
}

field.setAccessible(true);
Object fieldValue = field.get(obj);
if (fieldValue == null) {
continue;
}
toBeQueue.add(fieldValue);
}
tmpObjClass = tmpObjClass.getSuperclass();
}
}
}
return size;
}

/**
* String.intern的对象不计；计算过的不计，也避免死循环
*
* @param visited
* @param obj
* @return
*/
static boolean skipObject(Set<Object> visited, Object obj) {
if (obj instanceof String && obj == ((String) obj).intern()) {
return true;
}
return visited.contains(obj);
}
}

参考资料：

• 《深入理解Java虚拟机》

Nauyus