JAVA对象结构

     

如图所示，运行的程序通过运行栈中的指针找到堆中的对象。而对象再通过类型数据数据指针，找到类型数据（就是Class），然后与实例数据(运行时的对象数据)结合成对象。不管 new 多少个 Class AA, AA对像的类型数据只会在方法区中存一份，而对象实例数据而会对一对一的增加。而我们通常指的对象结构(大小)指的是堆中的实例结构(大小)

1.对象=对象头+对象体+填充   对象头=Marrk Word + 指向类数据元的指针（图2中指向方法区的）
2.Marrk Word 在32系统中占 32bit（25 bit 哈希码+4bit 的对象分代年龄+2bit锁标志位+1bit 0）,64位系统中占 64bit
3.reference（指针） 在32位系统 或者 指针压缩 上每个占用4bytes,在64位系统上每个占用8bytes。
4.因此在32位系统中 对象头 = 32bit+4byte =8byte.  64 位系统中 = 64bit + 8byte=16byte ,  开启压缩的 64位系统中  = 64bit+4byte=12byte
5.数组对象和普通对象的区别是需要用一个字段(int4)来保存数组的长度
6.因此在32位系统中 对象头 = 32bit+4byte+4byte =12byte.  64 位系统中 = 64bit + 8byte+4byte=20byte ,  开启压缩的 64位系统中  = 64bit+4byte+4byte=16byte
7.对象体（实例数据）则是  类中成员变量  8大基本类型+reference 的总合 
8.又因为VM的管理规则对象必须是 8byte的整数倍
9.(对象头 + 实例数据 + padding） % 8等于0且0 <= padding < 8 ，padding 为填充

注：Marrk Word的具体用法 隐式锁:synchronized

计算一对象的大小的方法

1.使用网上的javaagent(Instrumentation)不利于项目迁移,然后发现自己可以模拟一个.

2.自己模拟写个

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Set;

/**
 * 
 * Primitive bytes 
 * boolean    1 
 * byte       1 
 * short      2 
 * char       2 
 * int        4
 * float      4 
 * long       8 
 * double     8 
 * reference 在32位系统 或者 指针压缩 上每个占用4bytes,在64位系统上每个占用8bytes。
 * 
 * Java在64bit模式下开启指针压缩，比32bit模式下，头部会大4byte,如果没有开启指针压缩，头部会大8byte
 * 对象头: 
 *    64位:
 *        对象头:16,开启 UseCompressedOops 为12 
 *    32位：
 *        对象头:8 
 * 数组对象和普通对象的区别是需要用一个字段(int4)来保存数组的长度
 *      32 例: char[] 8(对象头)+4(int) 
 *      64 例 : char[] 16(对象头)+4(int)=20 启用压缩模式   12(对象头)+4(int)=16
 *      
 * 对象大小计算方式: (对象头 + 实例数据 + padding） % 8等于0且0 <= padding < 8
 * 
 * 本类使用条件为: 
 *      1.64位jdk 
 *      2.使用指针压缩 (本人使用jdk1.8默认启用，添加些参数-XX:+UseCompressedOops反尔关闭了此选项,其它没试过)
 * 
 * 如有其它情况可修改
 * 
 * @see PRIMITIVE_REFERENCE_SIZE
 * @see PRIMITIVE_HEAD_SIZE
 * @see PRIMITIVE_ARRAY_HEAD_SIZE
 * @author mrlzy
 */
public class MemorySupport {

	public final static int PRIMITIVE_BOOLEAN_SIZE = 1;
	public final static int PRIMITIVE_BYTE_SIZE = 1;
	public final static int PRIMITIVE_SHORT_SIZE = 2;
	public final static int PRIMITIVE_CHAR_SIZE = 2;
	public final static int PRIMITIVE_INT_SIZE = 4;
	public final static int PRIMITIVE_FLOAT_SIZE = 4;
	public final static int PRIMITIVE_LONG_SIZE = 8;
	public final static int PRIMITIVE_DOUBLE_SIZE = 8;

	public static int PRIMITIVE_REFERENCE_SIZE = 4;
	public static int PRIMITIVE_HEAD_SIZE = 12;
	public static int PRIMITIVE_ARRAY_HEAD_SIZE = 16;
	
	
	
	public static long sizeOf(Object obj) throws Exception{
		return sizeOf(obj,true,new HashSet<Object>());
	}

	private static long sizeOf(Object obj,boolean unInArray,Set<Object> set) throws  Exception {
		long result = 0l;
		Class<?> clazz = obj.getClass();
		set.add(obj);
		if(clazz.isArray()){
			result+=PRIMITIVE_ARRAY_HEAD_SIZE;
			int length = Array.getLength(obj);
			for (int i = 0; i < length; i++) {
				Object item=Array.get(obj, i);
				result+=sizeOfPrimitive(item==null?null:item.getClass());
			    if(item!=null&&!isPrimitive(item.getClass())&&!set.contains(item)){
					result+=sizeOf(Array.get(obj, i),false,set);
			    }
			}
			result+=(8-result%8)%8;//把本对象补全
		}else{
			result+=unInArray?PRIMITIVE_HEAD_SIZE:0;//数据对象中的成员就不用加头了
			Field[]  fields= getAllDeclaredFields(clazz);
			long sum=0l;
			for (int i = 0; i < fields.length; i++) {
				if (Modifier.isStatic(fields[i].getModifiers()))
					  continue;
				   Field field=fields[i];
				   field.setAccessible(true);
				   Object item=field.get(obj);
				   result+=sizeOfPrimitive(field.getType());
				   if(!isPrimitive(field.getType())&&!set.contains(item)){
					   sum+=item==null?0:sizeOf(item,true,set);
				   }
			}
			result+=unInArray?(8-result%8)%8:0;//把本对象补全
			result+=sum;//加入引用所包涵的对象
		}
		return result;
	}

	
	public static Field[]   getAllDeclaredFields(Class<?> clz){
		Field[] fs=clz.getDeclaredFields();
		if(clz.getSuperclass()!=null){
			Field[] fs1=  getAllDeclaredFields(clz.getSuperclass());
			Field[] c= new Field[fs.length+fs1.length];  
			System.arraycopy(fs, 0, c, 0, fs.length);  
			System.arraycopy(fs1, 0, c, fs.length, fs1.length); 
			return c;
		}
		return fs;
	}
	
	private static boolean isPrimitive(Class<?> clz){
		return clz == boolean.class||clz==java.lang.Boolean.class||
			   clz == byte.class||clz==java.lang.Byte.class||
			   clz == char.class||clz==java.lang.Character.class||
			   clz == short.class||clz== java.lang.Short.class||
			   clz == int.class||clz==java.lang.Integer.class||
			   clz == float.class||clz==java.lang.Float.class||
			   clz == long.class||clz==java.lang.Long.class||
			   clz == double.class||clz==java.lang.Double.class;
	}
	
	private static long sizeOfPrimitive(Class<?> clz) {
		
		if (clz == boolean.class||clz==java.lang.Boolean.class)
			return PRIMITIVE_BOOLEAN_SIZE;

		if (clz == boolean.class||clz==java.lang.Byte.class)
			return PRIMITIVE_BYTE_SIZE;

		if (clz == char.class||clz==java.lang.Character.class)
			return PRIMITIVE_CHAR_SIZE;

		if (clz == short.class||clz== java.lang.Short.class)
			return PRIMITIVE_SHORT_SIZE;
		
		if (clz == int.class||clz==java.lang.Integer.class)
			return PRIMITIVE_INT_SIZE;
		
		if (clz == float.class||clz==java.lang.Float.class)
			return PRIMITIVE_FLOAT_SIZE;
		
		if (clz == long.class||clz==java.lang.Long.class)
			return PRIMITIVE_LONG_SIZE;
		
		if (clz == double.class||clz==java.lang.Double.class)
			return PRIMITIVE_DOUBLE_SIZE;
		
		return PRIMITIVE_REFERENCE_SIZE;
	}

}