<think>我们讨论的是
Java中如何计算一个Object对象的大小。根据之前的引用，有几种方法可以做到这一点：
1. 使用sun.misc.Unsafe类（不推荐，因为它是内部API，且在不同JVM中可能不同）
2. 使用Instrumentation API（通过
javaagent）
3. 使用第三方库如JOL（
Java Object Layout）
4. 使用Elasticsearch的RamUsageEstimator（也是基于Unsafe，但封装得更好）
由于用户特别提到了Object对象，我们考虑一个最简单的对象，即空对象（new Object()）的大小。
在32位JVM上，对象头通常占8字节（如果开启压缩指针则不同），而在64位JVM上，对象头通常占12字节（开启压缩指针）或16字节（未开启压缩指针）。此外，由于对齐填充，实际占用的空间会是8的倍数。
下面详细介绍几种方法：
### 方法1: 使用Instrumentation API
步骤：
1. 编写一个
Java代理（
javaagent），在premain方法中获取Instrumentation实例。
2. 使用Instrumentation.getObjectSize()方法计算对象大小。
示例代码：
```
java
import
java.lang.instrument.Instrumentation;
public class ObjectSizeAgent {
private static volatile Instrumentation instrumentation;
public static void premain(String args, Instrumentation inst) {
instrumentation = inst;
}
public static long getObjectSize(Object obj) {
if (instrumentation == null) {
throw new IllegalStateException("Agent not initialized");
}
return instrumentation.getObjectSize(obj);
}
}
```
然后在MANIFEST.MF中指定Premain-Class。使用时：
```
java
public class Main {
public static void main(String[] args) {
Object obj = new Object();
long size = ObjectSizeAgent.getObjectSize(obj);
System.out.println("Object size: " + size + " bytes");
}
}
```
注意：需要以
javaagent方式运行程序。
### 方法2: 使用JOL（
Java Object Layout）工具
JOL是OpenJDK提供的一个工具，可以分析对象的内存布局。
添加Maven依赖：
```xml
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.16</version>
</dependency>
```
使用示例：
```
java
import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.vm.VM;
public class JOLExample {
public static void main(String[] args) {
// 打印JVM的详细信息
System.out.println(VM.current().details());
// 分析Object对象
Object obj = new Object();
String layout = ClassLayout.parseInstance(obj).toPrintable();
System.out.println(layout);
}
}
```
输出会显示对象头、实例数据（对于Object对象没有实例数据）、对齐填充。最后会给出总大小。
### 方法3: 使用RamUsageEstimator（来自Elasticsearch）
该工具在elasticsearch-common库中。
添加Maven依赖：
```xml
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>7.17.0</version> <!-- 使用合适版本 -->
</dependency>
```
使用示例：
```
java
import org.elasticsearch.common.breaker.CircuitBreaker;
import org.elasticsearch.common.breaker.NoopCircuitBreaker;
import org.elasticsearch.common.settings.Setting;
import org.elasticsearch.common.util.
PageCacheRecycler;
import org.elasticsearch.indices.breaker.NoneCircuitBreakerService;
import org.elasticsearch.monitor.jvm.JvmInfo;
import org.elasticsearch.monitor.jvm.JvmStats;
import org.elasticsearch.common.memory.MemoryManager;
import org.elasticsearch.common.unit.ByteSizeValue;
public class SizeExample {
public static void main(String[] args) {
// 初始化（这里可能需要一些上下文，但RamUsageEstimator有静态方法）
// 实际上，RamUsageEstimator是org.elasticsearch.common.breaker包中的一个类吗？
// 其实常用的是org.apache.lucene.util.RamUsageEstimator（Lucene中的）
// 由于Elasticsearch使用了Lucene，所以我们可以直接使用Lucene的RamUsageEstimator。
// 添加Lucene依赖：
// <dependency>
// <groupId>org.apache.lucene</groupId>
// <artifactId>lucene-core</artifactId>
// <version>8.11.1</version>
// </dependency>
}
}
```
使用Lucene的RamUsageEstimator：
```
java
import org.apache.lucene.util.RamUsageEstimator;
public class SizeExample {
public static void main(String[] args) {
Object obj = new Object();
long size = RamUsageEstimator.sizeOf(obj);
System.out.println("Object size: " + size + " bytes");
// 或者使用humanSizeOf
System.out.println(RamUsageEstimator.humanSizeOf(obj));
}
}
```
注意：RamUsageEstimator.sizeOf()会计算对象本身以及它所引用的所有对象（即整个对象图），如果你只想计算对象本身（浅大小），则使用`shallowSizeOf`。
### 总结
- 对于单个简单对象（如Object），以上方法都能给出大小（通常是16字节在64位JVM开启压缩指针的情况下，因为对象头12字节+对齐填充4字节）。
- 使用JOL可以更详细地看到内存布局，而使用RamUsageEstimator则更简单。
选择哪种方法取决于你的需求：
- 如果只需要数字，使用RamUsageEstimator（Lucene）很方便。
- 如果要分析内存布局，使用JOL。
### 注意事项
- 使用Unsafe的方式已经不推荐，因为它是内部API，且随着
Java版本变化。
- 对象大小的计算受到JVM实现和运行参数（如是否开启压缩指针）的影响。
§§相关问题§§
1. 为什么在64位JVM上，一个空Object对象占用16字节？
2. 如何关闭压缩指针？关闭后对象大小会怎样变化？
3. 如何计算一个包含多个字段的对象的大小？
4. 数组对象的大小如何计算？
</think>### 如何计算
Java 中 Object 对象的大小
计算
Java 对象的内存占用需要考虑 **对象头、实例数据和内存对齐** 三部分。以下是四种专业计算方法：
#### 1. 使用 JOL 工具（推荐）
```
java
// 添加 Maven 依赖
// <dependency>
// <groupId>org.openjdk.jol</groupId>
// <artifactId>jol-core</artifactId>
// <version>0.17</version>
// </dependency>
import org.openjdk.jol.info.ClassLayout;
public class Main {
public static void main(String[] args) {
Object obj = new Object();
// 打印对象内存布局
System.out.println(ClassLayout.parseInstance(obj).toPrintable());
}
}
```
输出示例：
```
java.lang.Object object internals:
OFF SZ TYPE DESCRIPTION VALUE
0 8 (object header: mark) 0x0000000000000001 (non-biasable; age: 0)
8 4 (object header: class) 0xf80001e5
12 4 (object alignment gap)
Instance size: 16 bytes
```
**说明**：
- 对象头占 12 字节（Mark Word 8B + Klass Pointer 4B）
- 对齐填充 4 字节
- **总大小：16 字节**（64 位 JVM 开启压缩指针）[^2]
---
#### 2. 使用 Instrumentation API
```
java
// 需通过
javaagent 启动
import
java.lang.instrument.Instrumentation;
public class SizeAgent {
private static Instrumentation inst;
public static void premain(String args, Instrumentation inst) {
SizeAgent.inst = inst;
}
public static long sizeOf(Object obj) {
return inst.getObjectSize(obj);
}
}
// 调用示例
public class Main {
public static void main(String[] args) {
Object obj = new Object();
System.out.println("Size: " + SizeAgent.sizeOf(obj) + " bytes");
}
}
```
**注意事项**：
- 需在 MANIFEST.MF 中添加 `Premain-Class: SizeAgent`
- 仅计算**浅层大小**（不包含引用对象）[^2]
---
#### 3. 使用 Unsafe（仅限调试）
```
java
import sun.misc.Unsafe;
public class UnsafeSize {
static final Unsafe UNSAFE = Unsafe.getUnsafe();
public static long sizeOf(Object o) {
return UNSAFE.getAddress(
UNSAFE.getInt(o, 8L) + 12L // 绕过对象头
);
}
}
```
**风险**：
- 内部 API，可能随 JDK 版本失效
- 需要 `--add-opens
java.base/jdk.internal.misc=ALL-UNNAMED`
---
#### 4. 使用 Elasticsearch 工具类
```
java
// 添加依赖
// <dependency>
// <groupId>org.elasticsearch</groupId>
// <artifactId>elasticsearch</artifactId>
// <version>8.11.0</version>
// </dependency>
import org.elasticsearch.common.ram.RamUsageEstimator;
public class Main {
public static void main(String[] args) {
Object obj = new Object();
// 计算对象自身大小
System.out.println(RamUsageEstimator.shallowSizeOf(obj)); // 16
// 格式化输出
System.out.println(RamUsageEstimator.humanSizeOf(obj)); // 16 bytes
}
}
```
---
### 对象大小组成原理
1. **对象头**（Header）：
- Mark Word（8 字节）：哈希码、GC 信息、锁状态
- Klass Pointer（4/8 字节）：指向类元数据的指针
2. **实例数据**（Instance Data）：
- 基本类型：`int`=4B, `long`=8B, `boolean`=1B 等
- 对象引用：4B（压缩指针）或 8B
3. **对齐填充**（Padding）：
- 确保对象大小为 8 字节的倍数（64 位 JVM）
对于空对象：
$$ \text{对象大小} = \text{对象头} + \text{对齐填充} = 12B + 4B = 16B $$
---
### 影响因素
| 配置项 | 对象头大小 | 典型值 |
|--------------------|------------|--------|
| 64位 JVM + 压缩指针 | 12B | ✅ 默认 |
| 64位 JVM 无压缩指针 | 16B | |
| 32位 JVM | 8B | |
> 💡 验证命令：`
java -XX:+PrintFlagsFinal -version | grep UseCompressedOops`
本文深入解析了大数据组件PageCacheRecycler的源代码，阐述了其在内存管理中的作用。PageCacheRecycler通过高效分配和回收页面缓存，优化性能和内存利用率，对大数据应用至关重要。
订阅专栏 解锁全文
扫一扫
500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
