`

深入Java对象大小

JavaJVMIT厂商虚拟机HBase 
阅读更多

 

在大规模Java 应用开发中，总会遇到内存泄漏的问题。通常的做法，通过 Profile 工具，分析 Java  Heap ，一般能够发现哪些对象内存占用巨大，而引起的泄漏问题。为了更好地深入了解问题的本质，以及从另外一个角度来分析问题，特写这篇文章。

 

可能不少的读者，并不清楚Java 对象到底占居多少的空间（单位：字节 =8 比特）。文章中会使用 JDK 6 update 7 自带的 Profile 工具 -Java VisualVM 。引入 Profile 工具的目的正是为了分析对象的大小。

 

首先，要区别Java 对象和 Java 类元信息，其中， JVM 把所有的 Java 对象放到 Java Heap 中，而类的元信息是放在方法区的，通俗地说，在 Java 源代码中，定义的字段和方法等变量标示（比如字段名称和类型等）。请注意，元信息所引用的对象还是在 Java Heap 里面。那么，本章主要 针对 的是Java Heap 。

 

       早几天，看到了JavaEye 上面提问 -http://www.iteye.com/problems/45423 。问题的本质，和主题一样，不过它想要通过 Java 程序来计算，貌似有点困难。以前外国一个哥们（ http://www.javaworld.com/javaworld/javatips/jw-javatip130.html ）也写 个 一个程序计算对象大小，它的计算如下：

public class Sizeof

{

    public static void main (String [] args) throws Exception

    {

        // Warm up all classes/methods we will use

        runGC ();

        usedMemory ();

        // Array to keep strong references to allocated objects

        final int count = 100000;

        Object [] objects = new Object [count];        

        long heap1 = 0;

        // Allocate count+1 objects, discard the first one

        for (int i = -1; i < count; ++ i)

        {

            Object object = null;

            // Instantiate your data here and assign it to object

             object = new Object ();

            if (i >= 0)

                objects [i] = object;

            else

            {

                object = null; // Discard the warm up object

                runGC ();

                heap1 = usedMemory (); // Take a before heap snapshot

            }

        }

        runGC ();

        long heap2 = usedMemory (); // Take an after heap snapshot:        

        final int size = Math.round (((float)(heap2 - heap1))/count);

        System.out.println ("'before' heap: " + heap1 +

                            ", 'after' heap: " + heap2);

        System.out.println ("heap delta: " + (heap2 - heap1) +

            ", {" + objects [0].getClass () + "} size = " + size + " bytes");

        for (int i = 0; i < count; ++ i) objects [i] = null;

        objects = null;

    }

    private static void runGC () throws Exception

    {

        // It helps to call Runtime.gc()

        // using several method calls:

        for (int r = 0; r < 4; ++ r) _runGC ();

    }

    private static void _runGC () throws Exception

    {

        long usedMem1 = usedMemory (), usedMem2 = Long.MAX_VALUE;

        for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++ i)

        {

            s_runtime.runFinalization ();

            s_runtime.gc ();

            Thread.currentThread ().yield ();

            

            usedMem2 = usedMem1;

            usedMem1 = usedMemory ();

        }

    }

    private static long usedMemory ()

    {

        return s_runtime.totalMemory () - s_runtime.freeMemory ();

    }

    

    private static final Runtime s_runtime = Runtime.getRuntime ();

} // End of class

( 代码 1)

 

通过改变红色区域，来切换测试对象。先运行出结果，以下结果是在Windows XP x86  ，SUN JDK 1.6.0 update 7 ，并且Console 信息部分被截断：

 

{class java.lang.Object} size = 8 bytes

{class java.lang.Integer} size = 16 bytes

{class java.lang.Long} size = 16 bytes

{class java.lang.Byte} size = 16 bytes

{class [Ljava.lang.Object;} size = 16 bytes //长度为0的Object类型数组

{class [Ljava.lang.Object;} size = 16 bytes //长度为1的Object类型数组

{class [Ljava.lang.Object;} size = 24 bytes //长度为2的Object类型数组

 

现在，这个结论有问题，因为，从Byte、Long、Integer源代码的角度，不可能对象空间大小相同，那么接下来需要借助于Java VisualVM来做了。 在测试之前 ，需要一段辅助程序，帮助执行。实现如下：

 

public   class  MainClass {

/**

 * 启动方法

 *  @param  args

 */

public   static   void  main(String[] args)  throws  Exception {

Object object =  new  Object();

neverStop ();

neverGC (object);

}

private   static   void  neverGC(Object object) {

System. out .println(object);

}

private   static   void  neverStop()  throws  InterruptedException {

Thread. sleep (Long. MAX_VALUE );

}

}

( 代码2 )

这个程序保证对象不会被GC掉，并且不会停止。

首先，在Java VisualVM上面，选择正确的程序进行监控，然后做一个Heap Dump。



 (图1)

Dump之后，点击 Classes ，然后过滤出 java.lang.Object ，如图所示：



 (图2)


 (图3)

 

 

图 3中 过滤出三个结果，暂时不看数组对象，选择java.lang.Object ，然后点击 instances 按钮，或者双击 java.lang.Object 。


 

( 图 4)

结果发现，Object 对象的大小总是 8 个字节。再看看 Integer 、 Long 和 Byte 。 Sizeof 类的计算结果不可信，分析错误原因放一下，后面会提到。先来分析 Integer 、 Long 和 Byte 。从源代码的角度来分析， Integer 包含了一个 int 的 value, 其他的也有对应类型。而知晓， int 占用 4 个字节， long 则是 8 个字节， byte 占用 1 个字节。看图说话：


 

(图5)

 

 (图6)


(图7)

 

 

Integer对象空间大小是 12 字节（见图 5) ， Long 对象空间则是 16 个字节（见图 6 ）， Byte 空间则是 9 个字节（见图 7 ）。那么除去对象自身的状态 value ，得出的结论是，最后“空壳”对象都 8 字节？不能确定，因为还有类（静态）字段没有考虑，这些字段是否属于对象实例的一部分呢？很多书上面再三强调类的字段不属于对象实例，对于这种说法需要保持怀疑的态度？下面做一个“空壳”对象实验，代码如下：

 

/**

 * 和Object一样，没有任何添加对象状态。

 *  @author  mercy

 */

public   class  SameAsObject  extends  Object {

}

( 代码3 )

修改 MainClass程序， new  一个 SameAsObject 对象，重新 Heap Dump，结果图：

 


 

 

 (图8)

 

图8 中表明，证明了“空壳”对象空间大小 8 字节，和 java.lang.Object 类似。目前还不能证明 Integer 的情况，因为 Integer 类的层次是 Integer <- Number <- Object 。虽然 Number 没有对象状态，可是也不能证明出去 value 的 Integer 对象空间大小等于 Object 的。为了证明这一点，再扩展一下 SameAsObject, 使其成为父类，创建一个子类 ExtSameAsObject 。同样的方法，获取大小：

 

 

 (图9)

 

图9 中， ExtSameAsObject 的空间大小还是 8 字。 证明了空壳对象大小等同于java.lang.Object 的。 那么自然地可以推导出java.lang.Double 也是 16 字节（ 8 字节空壳对象 +8 字节的 double 类型 value) 。

 

细心的读者会发现，图8 和 9 中，笔者标记了红色区域，都有 Java frame 的标识。而在MainClass 的 main 方法中，有一句： Object object =  new  ExtSameAsObject(); 这个对象是局部变量。说明什么问题呢？ 两个问题：第一，正因为在方法内部执行，这个语句就是一个 frame,而 frame 是 Java Stack 的组成单位。这个 frame 被压入栈，并且类型是 ExtSameAsObject ，同时带有一个对象的地址 #1 （当然这里不是实际地址，只是一个引用标识）。第二，即使是局部对象，对象仍然分配在 Java Heap 中。

 

既然“空壳”的Integer 对象，占用 8 个字节的大小，那么类的成员就不应该归入对象实例之中。从实验中，我们可以得出结论， 某个类的任何类成员的常量和变量，都不会分配（或计算）到该类的对象实例。

 

回到Sizeof 类，为什么 Sizeof 会计算出问题？虽然 Sizeof 类计算有误，不过它的思想还是几点值得借鉴：

 

第一、 作者深入了了解了Runtime#gc() 方法和 Runtime#runFinalization 方法的语义。这两个方法并不是实时执行，而是建议 JVM 执行，执行与否程序怎么知道呢 ? 在— _runGC 方法中，作者试图通过内存的变化来判断是否 GC （ GC 后，肯定会变化的），确实有道理。

 

第二、 通过N 次，求得平均数，比单次测试要精确很多。

 

第三、 没有开辟其他对象，不影响结果。

 

同时，不过作者忽略了如下情况：

 

第一、 GC不只是针对需要测试的对象，而是整个 JVM 。因此在 GC 的时候，有可能是 JVM 启动后，把其他没有使用的对象给 GC 了，这样造成了使用空间的变大，而 Heap 空间变小。

 

第二、 Runtime#freeMemory()方法，返回的数据是 近视值 ，不一定能够保证正确性。因此在后面的累计、求平均数来带了误差。

 

第三、 使用了Math#round() 方法，又带来了误差。

 

由于Sizeof 的不精确，不能作为测试基准。

 

那么，更多的疑问产生了。前面测试的都是单一对象，那么数组对象是如何分配的？

 

修改程序如下：

 

public   static   void  main(String[] args)  throws  Exception {

//Object object = new ExtSameAsObject();

Object [] object =  new   Object [0];

...

( 代码4 )

 

重新Heap Dump:


 (图10)

 

余下内容，看附件。错误内容已经修正，请下载Fix1文档 。

 

  • 大小: 50.6 KB
  • 大小: 42.8 KB
  • 大小: 64.1 KB
  • 大小: 99.4 KB
  • 大小: 31.8 KB
  • 大小: 32.3 KB
  • 大小: 24.6 KB
  • 大小: 54.9 KB
  • 大小: 22.4 KB
  • 大小: 27 KB
  • 大小: 58.3 KB
  • 大小: 45.3 KB
  • 大小: 27.6 KB
  • 大小: 56.4 KB
  • 大小: 28.1 KB
  • 大小: 11.9 KB
  • 大小: 82.9 KB
分享到：
| Java面向对象设计最佳实践 - 方法设计（二 ...
评论
32 楼 hoszb 2010-08-28  
profile工具，我喜欢JRockit的jrmc，感觉功能比原来的Sun那个jvisualvm好用
31 楼 mercyblitz 2010-08-28  
hoszb 写道
mercyblitz 写道


写得不错，让我萌生了一个想法-递归计算空间大小。


发现这个代码还需要做大改动，有时候多个对象共享一个成员变量，还有时，一个对象循环引用自己:

public class A{
    A a = this;
}


更糟糕的是，刚发现的

不同的JVM，内存管理不一样, 导致一个引用的大小有可能不同，相同长度的数组占用的空间也有可能不同。

(1).32位和64位的JVM有不同

(2).不同厂商的相同位数的JVM也有不同

(3).相同厂商不同版本的JVM，如1.5，1.6的。。。也有可能不同

引用大小：SUN的32位JVM，4字节，SUM的64位JVM，8字节，JRockit的32位/64位JVM，引用都是4字节


另外JVM在server模式下的System.gc()方法难以生效，测试时要在client模式下测



以上这些还是已知的，还有未知的不同。。。。。


嗯，因此Profile工具是必要的，程序写的东西，不确定因素很多。
30 楼 hoszb 2010-08-28  
mercyblitz 写道


写得不错，让我萌生了一个想法-递归计算空间大小。


发现这个代码还需要做大改动，有时候多个对象共享一个成员变量，还有时，一个对象循环引用自己:

public class A{
    A a = this;
}


更糟糕的是，刚发现的

不同的JVM，内存管理不一样, 导致一个引用的大小有可能不同，相同长度的数组占用的空间也有可能不同。

(1).32位和64位的JVM有不同

(2).不同厂商的相同位数的JVM也有不同

(3).相同厂商不同版本的JVM，如1.5，1.6的。。。也有可能不同

引用大小：SUN的32位JVM，4字节，SUM的64位JVM，8字节，JRockit的32位/64位JVM，引用都是4字节


另外JVM在server模式下的System.gc()方法难以生效，测试时要在client模式下测



以上这些还是已知的，还有未知的不同。。。。。
29 楼 mercyblitz 2010-08-28  
kuanchang 写道
这么深入的帖子，竟然是新手帖？？？那些人给的？

这个我认了，大家都是高手！

民主就是这么来的！
28 楼 kuanchang 2010-08-28  
这么深入的帖子，竟然是新手帖？？？那些人给的？
27 楼 mercyblitz 2010-08-28  
hoszb 写道
我研究了一晚上，写了一个精确计算对象占用空间的代码，楼主有空帮我测试一吧下：

这个代码在符合我的电脑（64位CPU，装32位操作系统,32位sun的虚拟机）的内存使用情况。
我电脑内存使用情况是拿gc()后的内存增长量做测试的。 


import java.lang.reflect.*;

//一个引用：4字节
//一个Object：8字节
//一个Integer：16字节 == (8 + 4) / 8 * 8
//一个int：4字节
//长度l的byte数组：(l+19)/8*8
//长度l的char/short数组：(l*2+19)/8*8 == (l+9)/4*8
//长度l的String：(l+1)/4*8+40
//长度l的int数组：(l*4+19)/8*8 ==(l+4)/2*8
//长度l的long数组：(l*8+19)/8*8 == (l+2)*8
public class Occupy {
	//不写不行...
	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 static int occupyof(Object object) {
		if (object == null)
			return 0;
		int size = 8;
		Class clazz = object.getClass();
		if (clazz.isArray()) {
			size = 4;//length变量是int型
			Class<?> componentType = clazz.getComponentType();
			if (componentType.isPrimitive())
				return occupyofSize(size + lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType));
			Object[] array = (Object[]) object;
			size += 4 * array.length;
			for (Object o : array)
				size += occupyof(o);
			return occupyofSize(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 += occupyof(field.get(object));
				} catch (Exception e) {
					size += occupyofConstructor(object, field);
				}
			}
		}
		return occupyofSize(size);
	}

	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 static int sizeof(Object object) {
		if (object == null)
			return 0;
		int size = 8;
		Class clazz = object.getClass();
		if (clazz.isArray()) {
			size = 4;//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 Contructor not accessible: " + object.getClass() + " field:" + field);
	}

	private static int sizeofConstructor(Object object, Field field) {
		throw new UnsupportedOperationException("field type Contructor not accessible: " + object.getClass() + " field:" + field);
	}

	/**
	 * 对象的大小 和 占用空间并不相等，就好象Windows下文件一样(大小为1字节时占用空间4k)
	 * 对象占用空间的增长以8个字节为单位，占用空间=大小对8的无条件进位法，
	 * 即occupy = (size + 8 - 1) / 8 * 8;   例如：
	 * 大小8字节：占用8字节，(new Object()就是占用8字节)
	 * 大小9字节：占用16字节
	 * 大小16字节：占用16字节
	 * 大小17字节：占用24字节
	 * @param size 大小，以字节为单位
	 * @return 占用空间
	 */
	private static int occupyofSize(int size) {
		return (size + 7) / 8 * 8;
	}

	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;
	}
	
	public static void main(String[] args) throws Throwable {
		System.out.println(occupyof(new String("Web.Zhu")));
	}

}


写得不错，让我萌生了一个想法-递归计算空间大小。
26 楼 hoszb 2010-08-28  
我研究了一晚上，写了一个精确计算对象占用空间的代码，楼主有空帮我测试一吧下：

这个代码在符合我的电脑（64位CPU，装32位操作系统,32位sun的虚拟机）的内存使用情况。
我电脑内存使用情况是拿gc()后的内存增长量做测试的。 


import java.lang.reflect.*;

//一个引用：4字节
//一个Object：8字节
//一个Integer：16字节 == (8 + 4 + 7) / 8 * 8
//一个int：4字节
//长度l的byte数组：(l+19)/8*8
//长度l的char/short数组：(l*2+19)/8*8 == (l+9)/4*8
//长度l的String：(l+1)/4*8+40
//长度l的int数组：(l*4+19)/8*8 ==(l+4)/2*8
//长度l的long数组：(l*8+19)/8*8 == (l+2)*8
public class Occupy {
	//不写不行...
	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 static int occupyof(Object object) {
		if (object == null)
			return 0;
		int size = 8;//对象本身8字节
		Class clazz = object.getClass();
		if (clazz.isArray()) {
			size += 4;//length变量是int型
			Class<?> componentType = clazz.getComponentType();
			if (componentType.isPrimitive())
				return occupyofSize(size + lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType));
			Object[] array = (Object[]) object;
			size += 4 * array.length;
			for (Object o : array)
				size += occupyof(o);
			return occupyofSize(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 += occupyof(field.get(object));
				} catch (Exception e) {
					size += occupyofConstructor(object, field);
				}
			}
		}
		return occupyofSize(size);
	}

	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 static int sizeof(Object object) {
		if (object == null)
			return 0;
		int size = 8;
		Class clazz = object.getClass();
		if (clazz.isArray()) {
			size = 4;//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 Contructor not accessible: " + object.getClass() + " field:" + field);
	}

	private static int sizeofConstructor(Object object, Field field) {
		throw new UnsupportedOperationException("field type Contructor not accessible: " + object.getClass() + " field:" + field);
	}

	/**
	 * 对象的大小 和 占用空间并不相等，就好象Windows下文件一样(大小为1字节时占用空间4k)
	 * 对象占用空间的增长以8个字节为单位，占用空间=大小对8的无条件进位法，
	 * 即occupy = (size + 8 - 1) / 8 * 8;   例如：
	 * 大小8字节：占用8字节，(new Object()就是占用8字节)
	 * 大小9字节：占用16字节
	 * 大小16字节：占用16字节
	 * 大小17字节：占用24字节
	 * @param size 大小，以字节为单位
	 * @return 占用空间
	 */
	private static int occupyofSize(int size) {
		return (size + 7) / 8 * 8;
	}

	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;
	}
	
	public static void main(String[] args) throws Throwable {
		System.out.println(occupyof(new String("Web.Zhu")));
	}

}
25 楼 aswang 2010-08-19  
楼主钻研的很深入，值得学习！
24 楼 likeblood 2010-07-22  
个人以为 由于32为操作系统的原因 必须4字节为一个单元 因为只能是4的倍数 不够的也要补齐 因此 5字节的也是8字节 1字节的是4字节

64位的话 就是8字节一单元了
23 楼 zgz888 2010-07-15  
支持一下，有空详细看看
22 楼 kingwood2005 2010-07-15  
mark

好文章，写的不错
21 楼 zhao103804 2010-07-14  
amazeur 写道
zhao103804 写道
写的不错，我们项目中内存泄露都没有这样精密的计算过，研究对象的大小还没深入到这块，看来要想LZ多多学习了


看来使用的时候要多注意了。


确实，我们项目中解决的办法就是加些限制条件
比如说从数据库中查询几万条数据放到list里面
但是又不知道那个对象到底能装多少，所有只有加限制条件，一次少装点了。
20 楼 kongxx 2010-07-14  
收下，慢慢学习。
19 楼 mercyblitz 2010-07-13  
RednaxelaFX 写道
well……有有同学想自己计算HotSpot里Java对象的布局的话，请参考HotSpot自身所使用的逻辑：
hotspot/src/share/vm/classfile/classFileParser.cpp
找这个方法：
ClassFileParser::parseClassFile()，看2833行开始： 
// Field size and offset computation

对象布局的计算就在里面，包括instanceKlass自身的布局（包含有Java类的静态变量）和Java对象实例的布局都在这里算。


谢谢，尽管我没有过（最近也在研究JVM实现），但是我比较偏好HotSpot的实现。不过我打算再写一篇计算篇，通过反向推到出来。

18 楼 RednaxelaFX 2010-07-13  
well……有同学想自己计算HotSpot里Java对象的布局的话，请参考HotSpot自身所使用的逻辑：
hotspot/src/share/vm/classfile/classFileParser.cpp
找这个方法：
ClassFileParser::parseClassFile()，看2833行开始： 
// Field size and offset computation

对象布局的计算就在里面，包括instanceKlass自身的布局（包含有Java类的静态变量）和Java对象实例的布局都在这里算。
17 楼 RednaxelaFX 2010-07-13  
其实在32位HotSpot里java.lang.Integer和java.lang.Long的大小就是一样的啊……
原因是32位HotSpot的对象分配是8字节对齐的。当对象自身所需数据占不足8字节的倍数的时候就会在一些位置加上padding。“一些位置”一般是整个对象的末尾，也可能是在中间。

HotSpot是按成员类型来计算对象布局的。可以读一下这篇，讲得还不错：Java Objects Memory Structure
（看不到的话请自行想办法翻……）
这帖讲的内容适用于32位HotSpot。其它JVM则有各自不同的对象布局方式。例如说早期的Sun JVM（后来叫Classic VM）采用的对象布局就跟HotSpot的完全不同，而像SableVM采用的对象布局则相当有特色。JVM规范并没有对对象布局做定义——JVM实现可以用自己喜欢的方式来做。

要靠谱的Java对象大小数据，可以参考这帖使用JVMTI来获取：Again about determining size of Java object
VisualVM也是通过JVMTI来获取对象大小、数量等的信息。

以前我也发过一帖是拿32位HotSpot的对象布局来玩的，[标题党] 跑得好好的C#程序咋移植为Java就不够内存用了呢？——忽悠一把
16 楼 mercyblitz 2010-07-13  
beneo 写道
mercyblitz 写道
beneo 写道
java 对象的大小跟 虚拟机有关系，你自己只能估算，不可能准确。

如果你只是问JVM中一个 new object的大小，其实我也不知道


可以计算的，只是在x86和x64上面有不同而已，不然Profile工具就是失去了意义。

从JVM实现的角度，统一了对象大小。


我没说清楚

你这个是用jprofile计算出来的，如果你那IBM VM看的话，可能就不一样。再次不同的VM版本，对象的大小也不一样。

我们在日常使用过程中，我自己只能估算一下，开多少数组，耗费多少内存。那究竟包含数组的对象耗费多少heap，你是不能计算出来的，除非拿jprofile等工具去实际测。


对于不同的JVM的实现，这个没有关系，最多是多测试而已。
15 楼 beneo 2010-07-13  
mercyblitz 写道
beneo 写道
java 对象的大小跟 虚拟机有关系，你自己只能估算，不可能准确。

如果你只是问JVM中一个 new object的大小，其实我也不知道


可以计算的，只是在x86和x64上面有不同而已，不然Profile工具就是失去了意义。

从JVM实现的角度，统一了对象大小。


我没说清楚

你这个是用jprofile计算出来的，如果你那IBM VM看的话，可能就不一样。再次不同的VM版本，对象的大小也不一样。

我们在日常使用过程中，我自己只能估算一下，开多少数组，耗费多少内存。那究竟包含数组的对象耗费多少heap，你是不能计算出来的，除非拿jprofile等工具去实际测。
14 楼 mercyblitz 2010-07-13  
beneo 写道
java 对象的大小跟 虚拟机有关系，你自己只能估算，不可能准确。

如果你只是问JVM中一个 new object的大小，其实我也不知道


可以计算的，只是在x86和x64上面有不同而已，不然Profile工具就是失去了意义。

从JVM实现的角度，统一了对象大小。
13 楼 beneo 2010-07-13  
java 对象的大小跟 虚拟机有关系，你自己只能估算，不可能准确。

如果你只是问JVM中一个 new object的大小，其实我也不知道
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    计算java对象的大小的方法

    本文将深入探讨如何计算Java对象的大小，以及这个知识点在实际开发中的应用。 首先，Java对象的大小不仅仅包括其字段的大小，还包括对象头（object header）的大小，对于HotSpot虚拟机，它包含了对齐填充、Mark ...

    JAVA对象所占内存大小计算例子

    本文将深入探讨如何计算Java对象所占内存，并通过提供的代码示例进行详细解析。 首先，我们需要理解Java对象内存占用的基本原理。每个Java对象都由三部分组成：对象头（Object Header）、实例数据（Instance Data）...

    计算一个Java对象占用字节数的方法

    本篇文章将深入探讨如何计算Java对象占用的内存字节数，以及影响这一数值的因素。 首先，Java对象在堆内存中由四个部分组成：对象头（A）、基本类型域（B）、引用类型域（C）和填充物（D）。 **对象头（A）**： ...

    统计缓存(java对象所占的内存)大小

    本文将深入探讨如何统计缓存（尤其是Java对象）所占的内存大小，以及这对理解程序内存消耗的重要性。 首先，我们要知道Java对象的内存开销主要由三部分组成：对象头、实例数据和对齐填充。对象头包含对象的类型信息...

    深入Java对象及元素的存储区域

    ### 深入Java对象及元素的存储区域 在Java平台进行软件开发的过程中，一个显著的特点是对象的创建是在程序运行时动态发生的。这也就意味着，直到程序执行时才能最终确定对象应该存放在哪个内存区域。不同的存储区域...

    测试java对象占用内存大小的例子

    例如，`sun.misc.Unsafe`类（虽然非标准，但广泛使用）提供了访问内存的能力，包括获取对象大小。然而，需要注意的是，这个类在Java 9及以后的版本中被弃用，并且在某些JRE中可能不可用。 `SizeOfObject.java`可能...

    Java对象池实现源码

    本篇文章将深入探讨Java对象池的实现原理，以及如何借鉴"Jakarta Commons Pool"组件来设计一个轻量级的对象池。 一、对象池的基本概念 对象池的基本工作流程包括以下几个步骤： 1. 初始化：预创建一定数量的对象并...

    java-sizeof-0.0.4:一个查看java对象占用内存大小

    本文将深入探讨Java中的对象内存占用，以及如何使用"java-sizeof-0.0.4"工具来查看Java对象在内存中的大小。 在Java中，内存主要分为堆内存（Heap）和栈内存（Stack）。对象通常存储在堆内存中，而基本类型的变量和...

    java对象创建过程

    本文将详细阐述Java对象的创建过程，帮助读者深入理解Java基础。 #### 一、类加载机制 在Java中，对象是由类来创建的。因此，在创建任何对象之前，Java虚拟机（JVM）必须先找到对应的类文件（`.class` 文件），并...

    深入Java虚拟机(原书第2版).pdf【附光盘内容】

    《深入Java虚拟机（原书第2版）》，原书名《Inside the Java Virtual Machine,Second Edition》，作者：【美】Bill Venners，翻译：曹晓钢、蒋靖，出版社：机械工业出版社，ISBN：7111128052，出版日期：2003 年 9 ...

    Java对象内存布局 - 小分析

    本篇文章将深入探讨Java对象在JVM内存中的布局，帮助我们理解JVM是如何存储和管理对象的。 首先，我们要知道JVM内存主要分为以下几个区域： 1. **堆内存（Heap）**：这是Java对象的主要存储区域，所有通过`new`...

    深入JAVA虚拟机第二版 Bill Venners著 曹晓钢 蒋靖译

    《深入JAVA虚拟机第二版》是由Bill Venners撰写，并由曹晓钢和蒋靖翻译的中文书籍。这本书是Java开发者必备的经典读物，它详细地解析了Java虚拟机（JVM）的工作原理，帮助读者深入理解Java程序的运行机制。尽管描述...

    JAVA对象以及数据的工具类

    本篇文章将深入探讨Java中的对象、基础类型以及数据处理相关的工具类。 首先，让我们关注Java中的基础类型。Java有八种原始数据类型：byte、short、int、long、float、double、char和boolean。为了方便处理这些类型...

    深入理解java对象，包括对象创建和内存分配

    总的来说，理解Java对象的创建、内存分配和JVM的工作机制对于编写高效、健壮的Java代码至关重要。这涉及到堆内存管理、对象生命周期、垃圾收集以及各种JVM优化策略。开发者应时刻关注这些细节，以便在解决性能问题时...

    深入java虚拟机 中文版 pdf

    《深入Java虚拟机》这本书是IT领域中关于Java虚拟机(JVM)的深度解析之作，主要聚焦于JVM的工作原理、内部结构以及优化技巧。Java虚拟机作为Java语言的核心组件，其性能直接影响到Java应用程序的运行效率。因此，对...

    优化Java堆大小的5个技巧

    ### 优化Java堆大小的五个技巧详解 #### 一、JVM：理解基本原理与内存管理 ##### **1.1 JVM内存模型** JVM内存管理是Java开发人员必须掌握的基本概念之一，它不仅关系到应用的性能，还直接影响到系统的稳定性和...

    java中的栈（深层了解java虚拟机对对象的内存分布）

    在Java编程语言中，理解栈(stack)和堆(heap)的概念及其工作原理对于深入掌握Java虚拟机(JVM)如何管理内存至关重要。栈和堆都是在RAM中用于存储数据的关键区域，但在功能、使用场景和管理机制上存在显著差异。 #### ...

    关于java对象池的例子代码

    Java对象池是一种优化资源管理的技术，它通过复用已经创建并初始化过的对象，避免了频繁地创建和销毁对象带来的性能开销。在Java中，对象池通常用于数据库连接、线程、Socket等昂贵资源的管理。下面我们将深入探讨...

    Java内存使用系列一Java对象的内存占用Java开发J

    这个“Java内存使用系列一Java对象的内存占用”主题旨在深入探讨Java对象在内存中的表现，以及如何有效地管理这些资源。Java开发人员需要理解内存分配、垃圾回收机制以及如何避免内存泄漏，以确保程序的高效运行。 ...

    深入Java虚拟机(原书第二版清晰版).

    《深入Java虚拟机(原书第二版清晰版)》这本书是为那些已经学习了Java编程语言，希望通过深入理解Java虚拟机（JVM）来进一步提升自己技术能力的Java程序员所准备的。本书详细介绍了JVM的内部工作机制，包括但不限于...

Magicbox
Global site tag (gtag.js) - Google Analytics