当我们在谈论内存时，我们在谈论什么

内存是什么？

基础： Java内存结构

JVM内存分区

Java 对象的内存结构

public class Int {public int val;}




    

议题： 如何计算一个对象占用的内存大小？

实验： 对象的实际内存布局

class Pojo {  public int a;  public String b;  public int c;  public boolean d;  private long e; // e设置为私有的，后面讲解为什么  public Object f;  Pojo() { e = 1024L;}}

使用 jol 工具查看其内存布局如下：

 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE      0    12                    (object header)                           N/A     12     4                int Pojo.a                                    N/A     16     8               long Pojo.e                                    N/A     24     4                int Pojo.c                                    N/A     28     1            boolean Pojo.d                                    N/A     29     3                    (alignment/padding gap)     32     4   java.lang.String Pojo.b                                    N/A     36     4   java.lang.Object Pojo.f

                                N/A

这里由于我的本地环境开启了对象头压缩，因此对象头所占用的大小为（4+8）=12字节。从这个内存布局表上不难看出，成员变量在实际分配内存时，并不是按照声明的顺序来储存的，此外在变量 d 之后，还出现了一块用于对齐内存的 padding gap ，这说明计算对象实际数据所占用的内存大小时，并不是简单的求和就可以的。

考虑到这些细节问题，我们需要一些更有力的工具来帮助我们精确的计算。

Unsafe & 变量偏移地址

在上面的内存布局表中，可以看到 OFFSET 一列，这便是对应变量的偏移地址，如果你了解 C/C++ 中的指针，那这个概念就很好理解，它其实是告诉了 CPU 要从什么位置取出对应的数据。举个例子，假设 Pojo 类的一个对象p存放在以 0x0010 开始的内存空间中，我们需要获取它的成员变量 b ，由于其偏移地址是 32（转换成十六进制为20），占用大小是 4 ，那么实际储存变量b的内存空间就是 0 x0030 ~ 0x0033 ，根据这个 CPU 就可以很容易地获取到变量了。

实际上在反射中，正是通过这样的方式来获取指定属性值的，具体实现上则需要借助强大的 Unsafe 工具。Unsafe 在 Java 的世界中可谓是一个“神龙不见首”的存在，借助它你可以操作系统底层，实现许多不可意思的操作（比如修改变量的可见性，分配和回收堆外内存等），用起来简直像在写 C++ 。 不过也正因为其功能的强大性，随意使用极有可能引发程序崩溃，因此官方不建议在除系统实现（如反射等）以外的场景使用，网上也很难找到Unsafe的详细使用指南（一些参考资料），当然这并不影响我们揭开它的神秘面纱，接下来就看看如何通过变量偏移地址来获取一个变量。

@Testpublic void testUnsafe() throws Exception {  Class> unsafeClass = null;  Unsafe unsafe = null;  try {    unsafeClass = Class.forName("sun.misc.Unsafe");    final Field unsafeField = unsafeClass.getDeclaredField("theUnsafe");    unsafeField.setAccessible(true);    unsafe = (Unsafe) unsafeField.get(null);  } catch (Exception e) {    // Ignore.  }  Pojo p = new Pojo();  Field f = Pojo.class.getDeclaredField("e");  long eOffset = unsafe.objectFieldOffset(f); // eOffset = 16  if (eOffset > 0L) {    long eVal = unsafe.getLong(p, eOffset);    System.out.println(eVal); // 1024  }}

出于安全起见，一般情况下在正常的代码中是无法直接获取 Unsafe 的实例的，这里我们通过反射的方式hack了一把来拿到 unsafe 实例。接着通过调用 objectFieldOffset 方法获取到成员变量 e 的地址偏移为 16（和 jol 中的结果一致），最终我们通过 getLong() 方法，传入 e 的地址偏移量，便获取到了 e 的值。可以看到尽管 Pojo 类中 e 是一个私有属性，通过这种方法依然是可以获取到它的值的。

有了 objectFieldOffset 这个工具，我们就可以通过代码精确的计算一个对象在内存中所占用的空间大小了，代码如下（参考自 apache luence ）

计算 shallowSize

public long shallowSizeOf(Object o) {Clazz> c = o.getClass(); // 对应的类// 初始大小：对象头  long shallowInstanceSize = NUM_BYTES_OBJECT_HEADER;




    
for (Class> c = clazz; c != null; c = c.getSuperclass()) {// 需要循环获取对象所继承的所有类以遍历其包含的所有成员变量final Field[] fields = c.getDeclaredFields();for (final Field f : fields) {// 注意，f的遍历顺序是按照声明顺序，而不是实际储存顺序if (!Modifier.isStatic(f.getModifiers())) {// 静态变量不用考虑final Class> type = f.getType();// 成员变量占用的空间，如果是基本类型(int,long等)，直接是其所占空间，否则就是当前JRE环境下引用的大小final int fsize = type.isPrimitive() ? primitiveSizes.get(type) : NUM_BYTES_OBJECT_REF;// 通过unsafe方法获取当前变量的偏移地址，并加上成员变量的大小，得到最终成员变量的偏移地址结束值（注意不是开始值）final long offsetPlusSize =          ((Number) objectFieldOffsetMethod.invoke(theUnsafe, f)).longValue() + fsize;// 因为储存顺序和遍历顺序不一致，所以不能直接相加，直接取最大值即可，最终循环结束完得到的一定是最后一个成员变量的偏移地址结束值，也就是所有成员变量的总大小        shallowInstanceSize = Math.max(shallowInstanceSize, offsetPlusSize);      }    }  }// 最后进行内存对齐，NUM_BYTES_OBJECT_ALIGNMENT是需要对齐的位数（一般是8）  shallowInstanceSize += (long) NUM_BYTES_OBJECT_ALIGNMENT - 1L;return shallowInstanceSize - (shallowInstanceSize % NUM_BYTES_OBJECT_ALIGNMENT);}

基础： JVM GC

可回收对象的标记

• 方法中局部变量区中的对象引用

• Java 操作栈中对象引用

• 常量池中的对象引用

• 本地方法栈中的对象引用

• 类的 Class 对象

垃圾收集算法

对象分代

• 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例；

• 加载该类的 ClassLoader 已经被回收；

• 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

• GC 时间：由于 GC 是 STW 的，所以在 GC 时间内整个应用是处于暂停状态的。

• GC 频率：单位时间内 GC 发生的次数。