jvm两种方式获取对象所占用的内存

ゞ浴缸里的玫瑰 2022-05-30 11:37 218阅读 0赞

在开发过程中，我们有时需要来获取某个对象的大小，以方便我们参考，来决定开发的技术方案。jvm中提供了两种方式来获取一个对象的大小。

## 通过Instrumentation来计算对象的大小 ##

*  编写计算代码：

package com.java.basic;
    
    import java.lang.instrument.Instrumentation;
    import java.lang.reflect.Array;
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    import java.util.IdentityHashMap;
    import java.util.Map;
    import java.util.Stack;
    
    public class SizeOfAgent {   
        private static Instrumentation inst;  
    
        /** initializes agent */  
        public static void premain(String agentArgs, Instrumentation instP)   
        {  
            inst = instP;  
        }  
    
        /** * Returns object size without member sub-objects. * @param o object to get size of * @return object size */  
        public static long sizeOf(Object o)   
        {  
            if(inst == null)   
            {  
                throw new IllegalStateException("Can not access instrumentation environment.\n" +  
                                "Please check if jar file containing SizeOfAgent class is \n" +  
                                "specified in the java's \"-javaagent\" command line argument.");  
            }  
            return inst.getObjectSize(o);  
        }  
    
        /** * Calculates full size of object iterating over * its hierarchy graph. * @param obj object to calculate size of * @return object size */  
        public static long fullSizeOf(Object obj)   
        {  
            Map<Object, Object> visited = new IdentityHashMap<Object, Object>();  
            Stack<Object> stack = new Stack<Object>();  
    
            long result = internalSizeOf(obj, stack, visited);  
            while (!stack.isEmpty())   
            {  
                result += internalSizeOf(stack.pop(), stack, visited);  
            }  
            visited.clear();  
            return result;  
        }                 
    
        private static boolean skipObject(Object obj, Map<Object, Object> visited)   
        {  
            if (obj instanceof String) {
       //这个if是bug，应当去掉--teasp 
                // skip interned string 
                if (obj == ((String) obj).intern()) {  
                    return true;  
                }  
            }  
            return (obj == null) || visited.containsKey(obj);  
        }  
    
        @SuppressWarnings("rawtypes")  
        private static long internalSizeOf(Object obj, Stack<Object> stack, Map<Object, Object> visited)   
        {  
            if (skipObject(obj, visited))  
            {  
                return 0;  
            }  
            visited.put(obj, null);  
    
            long result = 0;  
            // get size of object + primitive variables + member pointers 
            result += SizeOfAgent.sizeOf(obj);  
    
            // process all array elements 
            Class clazz = obj.getClass();  
            if (clazz.isArray())   
            {  
                if(clazz.getName().length() != 2)   
                {
       // skip primitive type array 
                    int length =  Array.getLength(obj);  
                    for (int i = 0; i < length; i++)   
                    {  
                        stack.add(Array.get(obj, i));  
                    }   
                }         
                return result;  
            }  
    
            // process all fields of the object 
            while (clazz != null)   
            {  
                Field[] fields = clazz.getDeclaredFields();  
                for (int i = 0; i < fields.length; i++)   
                {  
                    if (!Modifier.isStatic(fields[i].getModifiers()))   
                    {  
                        if (fields[i].getType().isPrimitive())   
                        {  
                            continue; // skip primitive fields 
                        }   
                        else   
                        {  
                            fields[i].setAccessible(true);  
                            try   
                            {  
                                // objects to be estimated are put to stack 
                                Object objectToAdd = fields[i].get(obj);  
                                if (objectToAdd != null)   
                                {                          
                                    stack.add(objectToAdd);  
                                }  
                            }   
                            catch (IllegalAccessException ex)   
                            {   
                                assert false;   
                            }  
                        }  
                    }  
                }  
                clazz = clazz.getSuperclass();  
            }  
            return result;  
        }  
    }

其中sizeof方法仅仅获取的是当前对象的大小，而该对象的如果存在对其他对象的引用，则不在计算范围以内，而fullsizeof则会计算整体的大小。

*  将该java文件进行编译，并打成jar包

com.java.basic.SizeOfAgent .java
    jar cvf sizeOfAgent.jar com/java.basic/SizeOfAgent .class

*  修改META-INF/MANIFEST.MF文件内容

Premain-Class: com.java.basic.SizeOfAgent
    Boot-Class-Path: 
    Can-Redefine-Classes: false

注意：每个冒号后面都有一个空格，且最后一行会有一个换行

*  将该jar包导入项目
 *  添加启动参数：-javaagent:E:sizeOfAgent.jar  
    我这边是将该jar包放在e盘，这里填写绝对路径。

这样我们就可以通过调用该类中的sizeOf方法或者fullSizeOf方法即可。

## 使用Unsafe类来获取对象大小 ##

unsafe对象可以获取到一个对象中各个属性的内存指针的偏移量，可以利用其来计算一个对象的大小。

import java.lang.reflect.Array;
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.IdentityHashMap;
    import java.util.List;
    import java.util.Map;
    
    import sun.misc.Unsafe;
    
    public class ClassIntrospector { 
    
        private static final Unsafe unsafe;
        /** Size of any Object reference */
        private static final int objectRefSize;
        static {
            try {
                Field field = Unsafe.class.getDeclaredField("theUnsafe");
                field.setAccessible(true);
                unsafe = (Unsafe) field.get(null);
    
                objectRefSize = unsafe.arrayIndexScale(Object[].class);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    
        public int getObjectRefSize() {
            return objectRefSize;
        }
    
        /** Sizes of all primitive values */
        private static final Map<Class, Integer> primitiveSizes;
    
        static {
            primitiveSizes = new HashMap<Class, Integer>(10);
            primitiveSizes.put(byte.class, 1);
            primitiveSizes.put(char.class, 2);
            primitiveSizes.put(int.class, 4);
            primitiveSizes.put(long.class, 8);
            primitiveSizes.put(float.class, 4);
            primitiveSizes.put(double.class, 8);
            primitiveSizes.put(boolean.class, 1);
        }
    
        /** * Get object information for any Java object. Do not pass primitives to * this method because they will boxed and the information you will get will * be related to a boxed version of your value. * * @param obj * Object to introspect * @return Object info * @throws IllegalAccessException */
        public ObjectInfo introspect(final Object obj)
                throws IllegalAccessException {
            try {
                return introspect(obj, null);
            } finally { // clean visited cache before returning in order to make
                        // this object reusable
                m_visited.clear();
            }
        }
    
        // we need to keep track of already visited objects in order to support
        // cycles in the object graphs
        private IdentityHashMap<Object, Boolean> m_visited = new IdentityHashMap<Object, Boolean>(
                100);
    
        private ObjectInfo introspect(final Object obj, final Field fld)
                throws IllegalAccessException {
            // use Field type only if the field contains null. In this case we will
            // at least know what's expected to be
            // stored in this field. Otherwise, if a field has interface type, we
            // won't see what's really stored in it.
            // Besides, we should be careful about primitives, because they are
            // passed as boxed values in this method
            // (first arg is object) - for them we should still rely on the field
            // type.
            boolean isPrimitive = fld != null && fld.getType().isPrimitive();
            boolean isRecursive = false; // will be set to true if we have already
                                            // seen this object
            if (!isPrimitive) {
                if (m_visited.containsKey(obj))
                    isRecursive = true;
                m_visited.put(obj, true);
            }
    
            final Class type = (fld == null || (obj != null && !isPrimitive)) ? obj
                    .getClass() : fld.getType();
            int arraySize = 0;
            int baseOffset = 0;
            int indexScale = 0;
            if (type.isArray() && obj != null) {
                baseOffset = unsafe.arrayBaseOffset(type);
                indexScale = unsafe.arrayIndexScale(type);
                arraySize = baseOffset + indexScale * Array.getLength(obj);
            }
    
            final ObjectInfo root;
            if (fld == null) {
                root = new ObjectInfo("", type.getCanonicalName(), getContents(obj,
                        type), 0, getShallowSize(type), arraySize, baseOffset,
                        indexScale);
            } else {
                final int offset = (int) unsafe.objectFieldOffset(fld);
                root = new ObjectInfo(fld.getName(), type.getCanonicalName(),
                        getContents(obj, type), offset, getShallowSize(type),
                        arraySize, baseOffset, indexScale);
            }
    
            if (!isRecursive && obj != null) {
                if (isObjectArray(type)) {
                    // introspect object arrays
                    final Object[] ar = (Object[]) obj;
                    for (final Object item : ar)
                        if (item != null)
                            root.addChild(introspect(item, null));
                } else {
                    for (final Field field : getAllFields(type)) {
                        if ((field.getModifiers() & Modifier.STATIC) != 0) {
                            continue;
                        }
                        field.setAccessible(true);
                        root.addChild(introspect(field.get(obj), field));
                    }
                }
            }
    
            root.sort(); // sort by offset
            return root;
        }
    
        // get all fields for this class, including all superclasses fields
        private static List<Field> getAllFields(final Class type) {
            if (type.isPrimitive())
                return Collections.emptyList();
            Class cur = type;
            final List<Field> res = new ArrayList<Field>(10);
            while (true) {
                Collections.addAll(res, cur.getDeclaredFields());
                if (cur == Object.class)
                    break;
                cur = cur.getSuperclass();
            }
            return res;
        }
    
        // check if it is an array of objects. I suspect there must be a more
        // API-friendly way to make this check.
        private static boolean isObjectArray(final Class type) {
            if (!type.isArray())
                return false;
            if (type == byte[].class || type == boolean[].class
                    || type == char[].class || type == short[].class
                    || type == int[].class || type == long[].class
                    || type == float[].class || type == double[].class)
                return false;
            return true;
        }
    
        // advanced toString logic
        private static String getContents(final Object val, final Class type) {
            if (val == null)
                return "null";
            if (type.isArray()) {
                if (type == byte[].class)
                    return Arrays.toString((byte[]) val);
                else if (type == boolean[].class)
                    return Arrays.toString((boolean[]) val);
                else if (type == char[].class)
                    return Arrays.toString((char[]) val);
                else if (type == short[].class)
                    return Arrays.toString((short[]) val);
                else if (type == int[].class)
                    return Arrays.toString((int[]) val);
                else if (type == long[].class)
                    return Arrays.toString((long[]) val);
                else if (type == float[].class)
                    return Arrays.toString((float[]) val);
                else if (type == double[].class)
                    return Arrays.toString((double[]) val);
                else
                    return Arrays.toString((Object[]) val);
            }
            return val.toString();
        }
    
        // obtain a shallow size of a field of given class (primitive or object
        // reference size)
        private static int getShallowSize(final Class type) {
            if (type.isPrimitive()) {
                final Integer res = primitiveSizes.get(type);
                return res != null ? res : 0;
            } else
                return objectRefSize;
        }
    
        static class ObjectInfo { 
            /** Field name */
            public final String name;
            /** Field type name */
            public final String type;
            /** Field data formatted as string */
            public final String contents;
            /** Field offset from the start of parent object */
            public final int offset;
            /** Memory occupied by this field */
            public final int length;
            /** Offset of the first cell in the array */
            public final int arrayBase;
            /** Size of a cell in the array */
            public final int arrayElementSize;
            /** Memory occupied by underlying array (shallow), if this is array type */
            public final int arraySize;
            /** This object fields */
            public final List<ObjectInfo> children;
    
            public ObjectInfo(String name, String type, String contents,
                    int offset, int length, int arraySize, int arrayBase,
                    int arrayElementSize) {
                this.name = name;
                this.type = type;
                this.contents = contents;
                this.offset = offset;
                this.length = length;
                this.arraySize = arraySize;
                this.arrayBase = arrayBase;
                this.arrayElementSize = arrayElementSize;
                children = new ArrayList<ObjectInfo>(1);
            }
    
            public void addChild(final ObjectInfo info) {
                if (info != null)
                    children.add(info);
            }
    
            /** * Get the full amount of memory occupied by a given object. This value * may be slightly less than an actual value because we don't worry * about memory alignment - possible padding after the last object * field. * * The result is equal to the last field offset + last field length + * all array sizes + all child objects deep sizes * * @return Deep object size */
            public long getDeepSize() {
                // return length + arraySize + getUnderlyingSize( arraySize != 0 );
                return addPaddingSize(arraySize + getUnderlyingSize(arraySize != 0));
            }
    
            long size = 0;
    
            private long getUnderlyingSize(final boolean isArray) {
                // long size = 0;
                for (final ObjectInfo child : children)
                    size += child.arraySize
                            + child.getUnderlyingSize(child.arraySize != 0);
                if (!isArray && !children.isEmpty()) {
                    int tempSize = children.get(children.size() - 1).offset
                            + children.get(children.size() - 1).length;
                    size += addPaddingSize(tempSize);
                }
    
                return size;
            }
    
            private static final class OffsetComparator implements
                    Comparator<ObjectInfo> {
                @Override
                public int compare(final ObjectInfo o1, final ObjectInfo o2) {
                    return o1.offset - o2.offset; // safe because offsets are small
                                                    // non-negative numbers
                }
            }
    
            // sort all children by their offset
            public void sort() {
                Collections.sort(children, new OffsetComparator());
            }
    
            @Override
            public String toString() {
                final StringBuilder sb = new StringBuilder();
                toStringHelper(sb, 0);
                return sb.toString();
            }
    
            private void toStringHelper(final StringBuilder sb, final int depth) {
                depth(sb, depth).append("name=").append(name).append(", type=")
                        .append(type).append(", contents=").append(contents)
                        .append(", offset=").append(offset).append(", length=")
                        .append(length);
                if (arraySize > 0) {
                    sb.append(", arrayBase=").append(arrayBase);
                    sb.append(", arrayElemSize=").append(arrayElementSize);
                    sb.append(", arraySize=").append(arraySize);
                }
                for (final ObjectInfo child : children) {
                    sb.append('\n');
                    child.toStringHelper(sb, depth + 1);
                }
            }
    
            private StringBuilder depth(final StringBuilder sb, final int depth) {
                for (int i = 0; i < depth; ++i)
                    sb.append("\t");
                return sb;
            }
    
            private long addPaddingSize(long size) {
                if (size % 8 != 0) {
                    return (size / 8 + 1) * 8;
                }
                return size;
            }
    
        }

当我们需要计算一个对象大小时，我们只需要获取ClassIntrospector实例，并调用其introspect方法，参数为需要计算大小的对象，就可以获取到ObjectInfo对象，这个对象中就包含了要计算的对象的各项信息(名字，类型，属性的偏移量等)，想要获取对象的大小，我们只需要调用OjbectInfo的getDeepSiz即可。  
ClassIntrospector中还定义了一个方法getObjectRefSize，这个方法的作用是获取当前虚拟机对象引用指针所占的空间，如果机器的内存在32G以下，则会默认开启指针压缩，占4个字节，否则占8个，可以使用参数-XX:-UseCompressedOops进行指针压缩

## 下面我们进行一个简单的验证： ##

首先我们先定义一个对象：

public class Person {
    
        private String name;
        private int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }

测试代码：

public static void main(String[] args) throws Exception {
            Person person = new Person();
            System.out.println(SizeOfAgent.fullSizeOf(person));
            ClassIntrospector cIntrospector = new ClassIntrospector();
            ObjectInfo oInfo = cIntrospector.introspect(person);
            System.out.println(oInfo.getDeepSize());
    }

运行结果：

24
    24

两种方法的运行结果一致，我们进行对象的手动计算，计算公式：  
mark头（8字节）+oop指针(4字节)+对象属性  
以person对象为例：  
mark头（8字节）+oop指针(4字节)+name(String类型引用4字节)+age(int类型引用4字节)=20  
jvm会对一个对象进行内存对齐，是的对象的大小为8的倍数，所以最终结果为24。

当然这两种计算方式都是对对象的一个大概计算，当一个对象引用String类型时，其实是有常量池的存在的，所以计算出来的只我们只能做个参考即可。