精确计算一个Java对象占用的内存大小

最新推荐文章于 2024-09-13 05:53:10 发布
最新推荐文章于 2024-09-13 05:53:10 发布
阅读量743 收藏
点赞数

《java优化占用内存的方法 -- 雪的痕迹》一文中提到：

" java做的系统给人的印象是什么？占内存！说道这句话就会有N多人站出来为java辩护，并举出一堆的性能测试报告来证明这一点。其实从理论上来讲java做的系统并不比其他语言开发出来的系统更占用内存，那么为什么却有这么N多理由来证明它确实占内存呢？两个字，"陋习"。

 

那如何衡量对象占用的内存空间大小呢？有人可能会说简单的使用如下代码： 

System.gc();
Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

然而这样做只能计算出堆中所有实例占用的内存大小，无法做到对一个对象的精确计算，

本人写了一段小代码计算对象的内存占用量，得出的结果和自己的电脑上内存的使用量一样，电脑配置是64位CPU，装32位XP操作系统，32位sun的虚拟机(参数-client)，内存3G，不清楚程序是否通用。

 

算法简述：

1.值类型变量占用大小已知

2.引用类型变量占用大小4字节（还没有在64位JVM下测试过），如Object x = null;  这个x变量在32位jvm中测得占用4字节

3.对象大小与占用空间的关系：occupy = (size + 8 - 1) / 8 * 8;

4.递归的遍历一个对象内的所有成员变量，成员变量的成员变量的占用的内存大小，

 

(目前无法对包含private java.lang.reflect.Constructot类型的成员的对象计算大小，因为无法通过反射获得对象该字段的值)。

import java.lang.reflect.*;
import java.util.*;
 
//一个引用：4字节
//一个Object：8字节
//一个Integer：16字节 == (8 + 4+8-1) / 8 * 8
//一个int：4字节
//长度为0的数组大小：JRo64=24,  Sun32=12
 
//引用大小，如Object = null：                    JRo64=JRo32=4, Sun32=4, Sun64=8
//无成员的对象大小，如new Object();：     JRo32=JRo64=8, Sun32=8, Sun64=16
//new byte[0]:                        JRo32=JRo64=8+8 Sun32=8+4, Sun64=16+8
 
//长度l的byte数组：(l+12+8-1)/8*8
//长度l的char/short数组：(l*2+12+8-1)/8*8 == (l+9)/4*8
//长度l的String：(l+1)/4*8+40
//长度l的int数组：(l*4+12+8-1)/8*8 ==(l+4)/2*8
//长度l的long数组：(l*8+12+8-1)/8*8 == (l+2)*8
public class Occupy {
 
  //这8个方法不写不行，否则occupyof(int x)会自动重载到occupyof(Object o),并且无法在方法中判断
  public static int occupyof(boolean variable) {
    return 1;
  }
 
  public static int occupyof(byte variable) {
    return 1;
  }
 
  public static int occupyof(short variable) {
    return 2;
  }
 
  public static int occupyof(char variable) {
    return 2;
  }
 
  public static int occupyof(int variable) {
    return 4;
  }
 
  public static int occupyof(float variable) {
    return 4;
  }
 
  public static int occupyof(long variable) {
    return 8;
  }
 
  public static int occupyof(double variable) {
    return 8;
  }
 
  public Occupy(byte nullReferenceSize, byte emptyObjectSize, byte emptyArrayVarSize) {
    this.NULL_REFERENCE_SIZE = nullReferenceSize;
    this.EMPTY_OBJECT_SIZE = emptyObjectSize;
    this.EMPTY_ARRAY_VAR_SIZE = emptyArrayVarSize;
  }
 
  public static Occupy forJRockitVM() {
    return new Occupy((byte) 4, (byte) 8, (byte) 8);
  }
 
  public static Occupy forSun32BitsVM() {
    return new Occupy((byte) 4, (byte) 8, (byte) 4);
  }
 
  public static Occupy forSun64BitsVM() {
    return new Occupy((byte) 8, (byte) 16, (byte) 8);
  }
 
  public static Occupy forDetectedVM(){
    return null;
  }
 
  private final byte NULL_REFERENCE_SIZE;
  private final byte EMPTY_OBJECT_SIZE;
  private final byte EMPTY_ARRAY_VAR_SIZE;
 
  private static class ref{
    public ref(Object obj){
      this.obj = obj;
    }
    final Object obj;
    @Override
    public boolean equals(Object obj) {
      return (obj instanceof ref) && ((ref)obj).obj == this.obj;
    }
    @Override
    public int hashCode() {
      return obj.hashCode();
    }
  }
 
  private List dedup = new ArrayList();
  
  public int occupyof(Object object){
    dedup.clear();
    return occupyof0(object);
  }
  private int occupyof0(Object object) {
    if (object == null)
      return 0;
    ref r = new ref(object);
    if(dedup.contains(r))
      return 0;
    dedup.add(r);
    int varSize = 0;//对象中的值类型、引用类型变量大小
    int objSize = 0;//对象中的引用类型指向的对象实例的大小
    for (Class clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
//      System.out.println(clazz);
      if (clazz.isArray()) {//当前对象的数组
        varSize += EMPTY_ARRAY_VAR_SIZE;
        Class<?> componentType = clazz.getComponentType();
        if (componentType.isPrimitive()) {//当前数组是原生类型的数组
          varSize += lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType);
          return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, 0);
        }
        Object[] array = (Object[]) object;
        varSize += NULL_REFERENCE_SIZE * array.length;//当前数组有length个引用，每个占用4字节
        for (Object o : array)
          objSize += occupyof0(o);
        return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, objSize);
      }
      Field[] fields = clazz.getDeclaredFields();
      for (Field field : fields) {
        if (Modifier.isStatic(field.getModifiers()))
          continue;//类成员不计
        //System.out.println(field.getDeclaringClass());
        if(clazz != field.getDeclaringClass())
          continue;
        Class<?> type = field.getType();
        if (type.isPrimitive())
          varSize += sizeofPrimitiveClass(type);
        else {
          varSize += NULL_REFERENCE_SIZE;//一个引用型变量占用4个字节
          try {
            field.setAccessible(true);//可以访问非public类型的变量
              objSize += occupyof0(field.get(object));
          } catch (Exception e) {
            objSize += occupyofConstructor(object, field);
          }
        }
      }
    }
    return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, objSize);
  }
 
  public static int sizeof(boolean variable) {
    return 1;
  }
 
  public static int sizeof(byte variable) {
    return 1;
  }
 
  public static int sizeof(short variable) {
    return 2;
  }
 
  public static int sizeof(char variable) {
    return 2;
  }
 
  public static int sizeof(int variable) {
    return 4;
  }
 
  public static int sizeof(float variable) {
    return 4;
  }
 
  public static int sizeof(long variable) {
    return 8;
  }
 
  public static int sizeof(double variable) {
    return 8;
  }
 
  
  public int sizeof(Object object) {
    if (object == null)
      return 0;
    int size = EMPTY_OBJECT_SIZE;
    Class clazz = object.getClass();
    if (clazz.isArray()) {
      size += EMPTY_ARRAY_VAR_SIZE;//length变量是int型
      Class<?> componentType = clazz.getComponentType();
      if (componentType.isPrimitive())
        return size + lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType);
      Object[] array = (Object[]) object;
      size += 4 * array.length;
      for (Object o : array)
        size += sizeof(o);
      return size;
    }
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
      if (Modifier.isStatic(field.getModifiers()))
        continue;//类成员不计
      Class<?> type = field.getType();
      if (type.isPrimitive())
        size += sizeofPrimitiveClass(type);
      else {
        size += 4;//一个引用型变量占用4个字节
        try {
          field.setAccessible(true);//可以访问非public类型的变量
          size += sizeof(field.get(object));
        } catch (Exception e) {
          size += sizeofConstructor(object, field);
        }
      }
    }
    return size;
  }
 
  private static int occupyofConstructor(Object object, Field field) {
    throw new UnsupportedOperationException("field type Constructor not accessible: " + object.getClass() + " field:" + field);
  }
 
  private static int sizeofConstructor(Object object, Field field) {
    throw new UnsupportedOperationException("field type Constructor not accessible: " + object.getClass() + " field:" + field);
  }
 
  
  private static int occupyOfSize(int size) {
    return (size + 7) / 8 * 8;
  }
 
  private static int occupyOfSize(int selfSize, int varsSize, int objsSize) {
//    System.out.println("self=" + selfSize + " vars=" + varsSize + " objs=" + objsSize);
    return occupyOfSize(selfSize) + occupyOfSize(varsSize) + objsSize;
  }
 
  private static int sizeofPrimitiveClass(Class clazz) {
    return clazz == boolean.class || clazz == byte.class ? 1 : clazz == char.class || clazz == short.class ? 2 : clazz == int.class || clazz == float.class ? 4
        : 8;
  }
 
  private static int lengthOfPrimitiveArray(Object object) {
    Class<?> clazz = object.getClass();
    return clazz == boolean[].class ? ((boolean[]) object).length : clazz == byte[].class ? ((byte[]) object).length
        : clazz == char[].class ? ((char[]) object).length : clazz == short[].class ? ((short[]) object).length
            : clazz == int[].class ? ((int[]) object).length : clazz == float[].class ? ((float[]) object).length
                : clazz == long[].class ? ((long[]) object).length : ((double[]) object).length;
  }
}

转自： http://blog.csdn.net/hoszb/article/details/5846069

如何计算Java对象的内存占用？探索对象内存大小的方法与实现
ByteGlide的博客
08-23 328
然而，Java虚拟机（JVM）中对象的内存布局和分配方式复杂多样，对于精确计算对象的内存占用并不是一件容易的事情。基本数据类型占用的内存大小是固定的，而引用类型的大小与具体的JVM实现有关。使用压缩指针：某些JVM提供了压缩指针的功能，可以减小对象引M提供了压缩指针的功能，可以减小对象引用的内存占用。使用对象池或缓存：对于重复创建的对象，可以使用对象池或缓存来共享对象实例，从而减少对象的创建和销毁开销。减少字段数量和使用更小的数据类型：通过精简对象的字段数量和使用更小的数据类型，可以减少对象的内存占用。
怎样计算一个 Java 对象大小？这儿有几种方法~
Tomcat那些事儿
03-24 872
在计算机发展的早期阶段，硬件的发展速度慢，容量小，所以软件开发人员写起代码里对 byte、bit 都是「斤斤计较」，这才使用写出来的应用能在我们今天看起来那么小的，配置那么低的硬件中运行...
4种方法教你如何查看java对象所占内存大小
u011250186的博客
08-03 3140
4种方法教你如何查看java对象所占内存大小
JAVA对象所占内存大小计算例子
11-14
JAVA对象所占内存大小计算例子,博文地址:http://blog.csdn.net/u012787710/article/details/53164226
你的 Java 对象占用了多少内存
最新发布
周国通的博客
09-13 783
对齐应该是 2 的幂，并且在 64 位架构上不能超过 4 个字节。
如何计算Java对象所占内存的大小
weixin_33882443的博客
05-24 419
摘要 本文以如何计算Java对象占用内存大小为切入点，在讨论计算Java对象占用堆内存大小的方法的基础上，详细讨论了Java对象头格式并结合JDK源码对对象头中的协议字段做了介绍，涉及内存模型、锁原理、分代GC、OOP-Klass模型等内容。最后推荐JDK自带的Hotspot Debug工具——HSDB，来查看对象在内存中的具体存在形式，...
java对象占用内存大小计算方法
linuxstuding
11-15 151
public static void main(String[] args) { Map testMap = new HashMap(); Product p= null; long start = 0; long end = 0; System.gc(); start = Runtime.getRuntime().freeMemory(); ...
Java 中对象占用内存大小计算
嘻哈熊的专栏
07-09 2023
bit：位，比特。信息的最小单位，二进制数中的一个位数 (二进制位)，其值为“0” 或“1”；byte: 字节。计算机文件大小的基本计算单位;原码：正数本身，负数，正数对应的二进制最高位为 1(负)；反码：正数本身，负数，符号位不变，其余各位取反；补码：正数本身，负数：反码 + 10 的反码、补码都为零注意: 计算机处理是以补码形式，我们最终看到的是原码形式例如： 列表 Java 基本类型注意：对于数组 32，默认为 int 型，32B 为 byte 类型，32S 为 short 类型，32L 为 long
一个Java对象占用多大内存
meser88的博客
02-20 1074
我们主要关注 normal object， 这种类型的 Object 的 Markword 一共是 8 个字节（64位），其中 25 位暂时没有使用，31 位存储对象的 hash 值（注意这里存储的 hash 值对根据对象地址算出来的 hash 值，不是重写 hashcode 方法里面的返回值），中间有 1 位没有使用，还有 4 位存储对象的 age（分代回收中对象的年龄，超过 15 晋升入老年代），最后三位表示偏向锁标识和锁标识，主要就是用来区分对象的锁状态（未锁定，偏向锁，轻量级锁，重量级锁）
统计缓存(java对象所占的内存)大小
08-01
本文将深入探讨如何统计缓存（尤其是Java对象）所占的内存大小，以及这对理解程序内存消耗的重要性。 首先，我们要知道Java对象的内存开销主要由三部分组成：对象头、实例数据和对齐填充。对象头包含对象的类型信息...
为什么Java程序占用的内存比实际分配的多
12-22
Java程序在运行过程中占用的内存通常比通过-Xmx和-Xms参数所设定的堆内存大小要多，这是由于Java程序的内存消耗不仅限于堆内存。以下是对各个影响因素的详细解析： 1. **对象（Objects）**：这是Java程序中最基本的...
如何计算Java对象占用了多少空间？
09-02
在Java中没有sizeof运算符，所以没办法知道一个对象到底占用了多大的空间，但是在分配对象的时候会有一些基本的规则，我们根据这些规则大致能判断出来对象大小,需要的朋友可以参考下
计算 java对象 内存占用大小
weixin_42260270的博客
02-20 2231
前言 作为小白，关于Java对象的大小还停留在 8种基本类型和其包装类占用几个字节的 阶段。最近，突然发现Java对象的内存大小似乎不这么简单，就想暂且写点东西，记录一下新知识。 Java对象内存结构 总体上，提到java对象内存大小，主要分为 数组类型和非数组类型 两大类来探究。 就如同下图一样，所有的java对象一般包括 对象头（Header），实例数据(Instance data)，对齐...
聊聊JVM（三）两种计算Java对象大小的方法
热门推荐
ITer_ZC的专栏
12-09 3万+
这篇说说如何计算Java对象大小的方法。之前在聊聊高并发（四）Java对象的表示模型和运行时内存表示 这篇中已经说了Java对象的内存表示模型是Oop-Klass模型。 普通对象的结构如下，按64位机器的长度计算 1. 对象头(_mark)， 8个字节 2. Oop指针，如果是32G内存以下的，默认开启对象指针压缩，4个字节 3. 数据区 4.Padding(内存对齐)，按照8的倍数
【JVM】JAVA内存占用大小计算方法详解
dkz97的博客
02-09 3866
前言 最近在公司需要对导出各种类型的报表进行一个性能优化(主要是防止溢出)，然后要对性能优化的话肯定要先对当前的性能进行排查，然后对于这篇文章的话主要是写个开头，说明一下如何计算JAVA对象的内存占用大小 目录 1.对象占用内存的基本组成结构 2.对象的占用内存计算 3.第三方内存大小计算工具 对象占用内存的基本组成结构 对象内存占用计算 以下面类为例 class People{ int age = 20; String name = "Xiaoming"; } class Person ex
JAVA 计算一个对象占用内存
qq_27242695的博客
11-27 507
JAVA 计算一个对象占用内存 案例：String 对象为例子，计算一个String对象占用内存 1 计算方式 引用pom依赖包jol-core 计算 <dependency> <groupId>org.openjdk.jol</groupId> <artifactId>jol-core</artifactId> <version>0.9</version> </dependency>
计算 jvm中缓存一个对象的大小
09-08
计算 JVM 中缓存一个对象的大小，可以通过以下步骤进行： 1. 首先，确定该对象的类型和结构。不同的类型和结构会占用不同的内存空间。 2. 查看对象的实例变量。实例变量是对象的属性和数据成员，它们在对象中占据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值