/**
 * 研究new出的對象大小
 * -Xms1m -Xmx1m -XX:+PrintGCDetails
 */
public class TestObjectSize {
    int i = 0;
    @Test
    public void testObjectSize() {
        List<Object> list = new ArrayList<>();
        try {
            while (true) {
                list.add(new Object());
                i++;
            }
        } catch (Exception e) {
            System.out.println(i);
            e.printStackTrace();
        }finally {
            System.out.println(i);
        }
    }
}
運行結果：
14053
java.lang.OutOfMemoryError: Java heap space

/**
 * This class provides services needed to instrument Java
 * programming language code.
 * Instrumentation is the addition of byte-codes to methods for the
 * purpose of gathering data to be utilized by tools.
 * Since the changes are purely additive, these tools do not modify
 * application state or behavior.
 * Examples of such benign tools include monitoring agents, profilers,
 * coverage analyzers, and event loggers.
 *
 * <P>
 * There are two ways to obtain an instance of the
 * <code>Instrumentation</code> interface:
 *
 * <ol>
 *   <li><p> When a JVM is launched in a way that indicates an agent
 *     class. In that case an <code>Instrumentation</code> instance
 *     is passed to the <code>premain</code> method of the agent class.
 *     </p></li>
 *   <li><p> When a JVM provides a mechanism to start agents sometime
 *     after the JVM is launched. In that case an <code>Instrumentation</code>
 *     instance is passed to the <code>agentmain</code> method of the
 *     agent code. </p> </li>
 * </ol>
 * <p>
 * These mechanisms are described in the
 * {@linkplain java.lang.instrument package specification}.
 * <p>
 * Once an agent acquires an <code>Instrumentation</code> instance,
 * the agent may call methods on the instance at any time.
 *
 * @since   1.5
 */

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 MySizeOf {
    static Instrumentation inst;
    public static void premain(String agentArgs, Instrumentation instP) {
        inst = instP;
    }
    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);
    }
}

public class TestSize {
    public static void main(String []args) {
        System.out.println("一個Interger對象大小為："+MySizeOf.sizeOf(new Integer(1)));
        System.out.println("一個String對象大小為："+MySizeOf.sizeOf(new String("a")));
        System.out.println("一個String對象大小（關閉指針壓縮）為："+MySizeOf.fullSizeOf(new String("a")));
        System.out.println("一個char對象大小為："+MySizeOf.sizeOf(new char[1]));
        System.out.println("一個ArrayList對象大小為："+MySizeOf.sizeOf(new ArrayList<>()));
        System.out.println("一個Object對象大小為："+MySizeOf.sizeOf(new Object()));
        System.out.println("一個Long對象大小為："+MySizeOf.sizeOf(new Long(10000000000L)));
    }
}

// step1，編譯TestSize.java，并將agent.jar包中的Instrumentation的實例引入ClassPath，這樣執(zhí)行TestSize.java時才能引用Instrumentation實例。
javac -classpath agent.jar TestSize.java
//step2,執(zhí)行TestSize，使用-javaagent:agent.jar,意思是使用agent.jar作為代理，用到agent技術
java -javaagent:agent.jar TestSize  

public class MySizeOf {
    static Instrumentation inst;
    public static void premain(String agentArgs, Instrumentation instP) {
        inst = instP;
    }
    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);
    }
    /**
     * 遞歸計算當前對象占用空間總大小，包括當前類和超類的實例字段大小以及實例字段引用對象大小
     */
    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 (obj == ((String) obj).intern()) {
                return true;
            }
        }
        return (obj == null) || visited.containsKey(obj);
    }
    private static long internalSizeOf(Object obj, Stack<Object> stack, Map<Object, Object> visited) {
        if (skipObject(obj, visited)) {//跳過常量池對象、跳過已經(jīng)訪問過的對象
            return 0;
        }
        visited.put(obj, null);//將當前對象放入棧中
        long result = 0;
        result += sizeOf(obj);
        Class <?>clazz = obj.getClass();
        if (clazz.isArray()) {//如果數(shù)組
            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;
        }
        return getNodeSize(clazz , result , obj , stack);
    }
    //這個方法獲取非數(shù)組對象自身的大小，并且可以向父類進行向上搜索
    private static long getNodeSize(Class <?>clazz , long result , Object obj , Stack<Object> stack) {
        while (clazz != null) {
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                if (!Modifier.isStatic(field.getModifiers())) {//這里拋開靜態(tài)屬性
                    if (field.getType().isPrimitive()) {//這里拋開基本關鍵字（因為基本關鍵字在調用java默認提供的方法就已經(jīng)計算過了）
                        continue;
                    }else {
                        field.setAccessible(true);
                        try {
                            Object objectToAdd = field.get(obj);
                            if (objectToAdd != null) {
                                stack.add(objectToAdd);//將對象放入棧中，一遍彈出后繼續(xù)檢索
                            }
                        } catch (IllegalAccessException ex) {
                            assert false;
                        }
                    }
                }
            }
            clazz = clazz.getSuperclass();//找父類class，直到?jīng)]有父類
        }
        return result;
    }
}

public final class VolatileLong {
        /**
         * 大小計算:
         *  long 8 字節(jié)
         * [1]java對象頭: 32位 :8 byte 64位:12 byte
         * 所以總共: 6 個填充 * 8 byte + 8 (value) + 8 (對象頭) = 64 byte
         *  還有采用如下方式的
         *  long p1, p2, p3, p4, p5, p6, p7; // cache line padding  -> 7 *8 = 56 字節(jié)
         *  long value;  ->  8 字節(jié)
         *  long p8, p9, p10, p11, p12, p13, p14; // cache line padding -> 7*8 = 56 字節(jié)
         *
         *  java.util.concurrent.Exchanger.Slot<V>
         *          // Improve likelihood of isolation on <= 64 byte cache lines
         *  long q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe;  15 * 8
         *  不知道為啥是這樣實現(xiàn):因為父類還有一個Long值 所以總的來說已經(jīng)超過128了
         *
         */
        public volatile long value = 0L;
        public long p1, p2, p3, p4, p5, p6; // comment out
        //objectsize = 6*8 + 8 + 4 =
}