Une brève analyse de la taille des objets Java

Récemment, j'ai eu un caprice et je me suis soudain intéressé à la taille de la mémoire des objets Java. Je suis allé collecter des informations sur Internet et j'espère que vous pourrez m'aider. .
Si : vous pouvez calculer la taille mémoire occupée par le nouvel objet String ("abc") dans la JVM (taille compressée 48B, taille non compressée 64B dans JDK7 64 bits), alors vous pouvez le terminer ici~

---

Disposition de la mémoire des objets Java : en-tête d'objet (Header), données d'instance (Instance Data) et remplissage d'alignement (Padding) .
L'en-tête de l'objet de la machine virtuelle comprend deux parties d'informations. La première partie est utilisée pour stocker les données d'exécution de l'objet lui-même , telles que le hashCode, l'âge de génération GC, l'indicateur d'état de verrouillage, le verrouillage. détenu par le fil et le biais. ID du fil, horodatage du biais, etc. La longueur de cette partie des données est respectivement de 4B et 8B dans les machines virtuelles 32 bits et 64 bits (la compression du pointeur n'est pas activée). Elle est officiellement appelée "Mark Word".
L'autre partie de l'objet est le pointeur de type (klass) , qui est le pointeur de l'objet vers ses métadonnées de classe. La machine virtuelle utilise ce pointeur pour déterminer à quelle classe l'objet est une instance. de. De plus, si l'objet est un tableau Java, il doit y avoir une donnée dans l'en-tête de l'objet pour enregistrer la longueur du tableau, car la machine virtuelle peut déterminer la taille de l'objet Java grâce aux informations de métadonnées des objets Java ordinaires. , mais à partir des métadonnées du tableau. Mais impossible de déterminer la taille du tableau.
L'en-tête de l'objet occupe 8B sur les systèmes 32 bits et 16B sur les systèmes 64 bits. Qu'il s'agisse d'un système 32 bits ou d'un système 64 bits, les objets sont alignés sur 8 octets. Lorsque Java active la compression du pointeur en mode 64 bits, l'en-tête sera 4 B plus grand qu'en mode 32 bits (la zone de marquage est décalée de 8 B et la zone kclass est compressée si la compression du pointeur n'est pas activée). l'en-tête sera 8B plus grand (mark et kclass sont compressés). , en d'autres termes,
L'alignement de HotSpot est un alignement sur 8 octets : (remplissage des données de l'instance d'en-tête d'objet)%8 est égal à 0 et 0< =remplissage<8. Les instructions suivantes sont basées sur HotSpot.

---

Comme mentionné dans la référence 2, java.lang.instrument.Instrumentation fourni après JDK5 fournit une API riche pour suivre divers aspects de la structure et mesurer la taille des objets. Cependant, cette chose nécessite l'utilisation d'un agent Java. Quant à l'agent et à l'instrumentation, je ne les expliquerai pas ici, j'expliquerai seulement comment les utiliser.
Ce cours est fourni dans la référence 3. Je pense personnellement qu'il est très pratique. Le code est présenté en annexe 1 ci-dessous (le code est relativement long, je le mettrai donc simplement à la fin de l'article) :
Ce code peut être copié directement, puis emballé dans un package jar (nommé agent.jar. S'il n'est pas empaqueté avec succès, vous pouvez directement télécharger le package empaqueté par le blogueur. Faites attention à l'ajout d'une ligne dans META-). INF/MANIFEST.MF :

Premain-Class: com.zzh.size.MySizeOf （注意"："后面的空格，否则会报错：invalid header field.）

Par exemple, le code est le suivant (le système du blogueur est en 64 bits et utilise le JDK7 64 bits) :

import com.zzh.size.MySizeOf;public class ObjectSize
{    public static void  main(String args[])
    {
        System.out.println(MySizeOf.sizeOf(new Object()));
    }
}

Ensuite, compiler et exécuter, les étapes sont les suivantes :

1. Compiler (agent.jar est placé dans le répertoire courant) : javac -classpath agent.jar ObjectSize.java

2. Exécuter : java -javaagent:agent.jar ObjectSize (résultat de sortie : 16. Quant à l'analyse de ce résultat, nous y reviendrons plus tard)

JDK6 introduit le paramètre -XX : UseCompressedOops. Ce paramètre sera automatiquement activé par défaut dans la mémoire 32 G. La compression du pointeur peut être désactivée en ajoutant -XX:-UseCompressedOops aux paramètres d'exécution.
Utilisez l'instrumentation pour tester la taille d'un objet juste pour exprimer la taille d'un objet de manière plus vivante. En fait, lorsqu'un objet est créé, sa taille peut être calculée manuellement. La pratique du cas de code est utilisée pour prouver la rationalité et l'exactitude. de connaissances théoriques, l'algorithme spécifique est reflété dans le cas de code ci-dessous.

Supplément : L'utilisation de la mémoire de type primitif est la suivante :

Primitive Type	Memory Required(bytes)
boolean	1
byte	1
short	2
char	2
int	4
float	4
long	8
double	8

 引用类型在32位系统上每个占用4B, 在64位系统上每个占用8B。

---

案例分析
 扯了这么多犊子，估计看的玄乎玄乎的，来几段代码案例来实践一下。

案例1：上面的new Object()的大小为16B，这里再重申一下，博主测试机是64位的JDK7，如无特殊说明，默认开启指针压缩。

new Object()的大小=对象头12B(8Bmak区，4Bkclass区)+padding的4B=16B

案例2：

    static class A{        int a;
    }    static class B{        int a;        int b;
    }    public static void  main(String args[])
    {
        System.out.println(MySizeOf.sizeOf(new Integer(1)));
        System.out.println(MySizeOf.sizeOf(new A()));
        System.out.println(MySizeOf.sizeOf(new B()));
    }

输出结果：

（指针压缩） 16    16    24
（指针未压缩）24    24    24

分析1（指针压缩）：

new Integer(1)的大小=12B对象头+4B的实例数据+0B的填充=16Bnew 
A()的大小=12B对象头+4B的实例数据+0B的填充=16B
new B()的大小=12B对象头+2*4B的实例数据=20B，填充之后=24B

分析2（指针未压缩）：

new Integer(1)的大小=16B对象头+4B的实例数据+4B的填充=24B
new A()的大小=16B对象头+4B的实例数据+4B的填充=24B
new B()的大小=16B对象头+2*4B的实例数据+0B的填充=24B

案例3

System.out.println(MySizeOf.sizeOf(new int[2]));
System.out.println(MySizeOf.sizeOf(new int[3]));
System.out.println(MySizeOf.sizeOf(new char[2]));
System.out.println(MySizeOf.sizeOf(new char[3]));

输出结果：

（指针压缩） 24    32    24    24
（指针未压缩） 32    40    32    32

分析1（指针压缩）：

new int[2]的大小=12B对象头+压缩情况下数组比普通对象多4B来存放长度+2*4B的int实例大小=24B
new int[3]的大小=12B对象头+4B长度+3*4B的int实例大小=28B，填充4B =32B
new char[2]的大小=12B对象头+4B长度+2*2B的实例大小=20B，填充4B=24B
new char[3]的大小=12B对象头+4B长度+3*2B的实例大小+2B填充=24B
（PS:new char[5]的大小=32B）

分析2（指针未压缩）：

new int[2]的大小=16B对象头+未压缩情况下数组比普通对象多8B来存放长度+2*4B实例大小=32B
new int[3]的大小=16B+8B+3*4B+4B填充=40B
new char[2]的大小=16B+8B+2*2B+4B填充=32B
new char[2]的大小=16B+8B+3*2B+2B填充=32B
（PS:new char[5]的大小为40B）

案例4（sizeOf只计算本体对象大小，fullSizeOf计算本体对象大小和引用的大小，具体可以翻阅附录1的代码）.

System.out.println(MySizeOf.sizeOf(new String("a")));
System.out.println(MySizeOf.fullSizeOf(new String("a")));
System.out.println(MySizeOf.fullSizeOf(new String("aaaaa")));

输出结果：

（指针压缩）24    48    56    
（指针未压缩）32    64   72

分析1（指针压缩）：

翻看String（JDK7）的源码可以知道，
String有这几个成员变量：（static变量属于类，不属于实例，所以声明为static的不计入对象的大小）
private final char value[];
private int hash;
private transient int hash32 = 0;

MySizeOf.sizeOf(new String("a"))的大小=12B对象头+2*4B(成员变量hash和hash32)+4B(压缩的value指针)=24B
MySizeOf.fullSizeOf(new 
String("a"))的大小=12B对象头+2*4B(成员变量hash和hash32)+4B指针+
（value数组的大小=12B对象头+4B数组长度+1*2B实例大小+6B填充=24B）=12B+8B+4B+24B=48B
(PS： new String("aa")，new String("aaa")，new String("aaaa")的fullSizeOf大小都为48B)
MySizeOf.fullSizeOf(new String("aaaaa"))的大小=12B+2*4B+4B+(12B+4B+5*2B+6B填充)=24B+32B=56B

分析2（指针未压缩）

MySizeOf.sizeOf(new String("a"))的大小=16B+2*4B+8B(位压缩的指针大小) =32B
MySizeOf.fullSizeOf(new String("a"))的大小=16B对象头+2*4B(成员变量hash和hash32)+8B指针+（value数组的大小=16B对象头+8B数组长度+1*2B实例大小+6B填充=32B）=32B+32B=64B
(PS： new String("aa")，new String("aaa")，new String("aaaa")的fullSizeOf大小都为64B)
MySizeOf.fullSizeOf(new String("aaaaa"))的大小=16B+2*4B+8B+(16B+8B+5*2B+6B填充)=32B+40B=72B

 这些计算结果只会少不会多，因为在代码运行过程中，一些对象的头部会伸展，mark区域会引用一些外部的空间（轻量级锁，偏向锁，这里不展开），所以官方给出的说明也是，最少会占用多少字节，绝对不会说只占用多少字节。

如果是32位的JDK，可以算一下或者运行一下上面各个案例的结果。

 看来上面的这些我们来手动计算下new String()的大小：
1. 指针压缩的情况

12B对象头+2*4B实例变量+4B指针+（12B对象头+4B数组长度大小+0B实例大小）=24B+16B=40B

1. 指针未压缩的情况

16B+2*4B+8B指针+（16B+8B数组长度大小+0B）=32B+24B=56B

 所以一个空的String对象最少也要占用40B的大小，所以大家在以后应该编码过程中要稍微注意下。其实也并不要太在意，相信能从文章开头看到这里的同学敲的代码也数以万计了，不在意这些也并没有什么不妥之处，只不过如果如果你了解了的话对于提升自己的逼格以及代码优化水平有很大的帮助，比如：能用基本类型的最好别用其包装类。

附：agent.jar包源码

package com.zzh.size;import java.lang.instrument.Instrumentation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.Set;
public class MySizeOf{
     static Instrumentation inst;  

        public static void premain(String args, Instrumentation instP) {  
            inst = instP;  
        }  

        /** 
         * 直接计算当前对象占用空间大小，包括当前类及超类的基本类型实例字段大小、<br></br> 
         * 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小;<br></br> 
         * 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小 <br></br> 
         * 
         * @param obj 
         * @return 
         */  
        public static long sizeOf(Object obj) {  
            return inst.getObjectSize(obj);  
        }  

        /** 
         * 递归计算当前对象占用空间总大小，包括当前类和超类的实例字段大小以及实例字段引用对象大小 
         * 
         * @param objP 
         * @return 
         * @throws IllegalAccessException 
         */  
        public static long fullSizeOf(Object objP) throws IllegalAccessException {  
            Set<Object> visited = new HashSet<Object>();  
            Deque<Object> toBeQueue = new ArrayDeque<>();  
            toBeQueue.add(objP);  
            long size = 0L;  
            while (toBeQueue.size() > 0) {  
                Object obj = toBeQueue.poll();  
                //sizeOf的时候已经计基本类型和引用的长度，包括数组  
                size += skipObject(visited, obj) ? 0L : sizeOf(obj);  
                Class<?> tmpObjClass = obj.getClass();  
                if (tmpObjClass.isArray()) {  
                    //[I , [F 基本类型名字长度是2  
                    if (tmpObjClass.getName().length() > 2) {  
  
  for (int i = 0, len = Array.getLength(obj); i < len; i++) {  
                            Object tmp = Array.get(obj, i);  
                            if (tmp != null) {  
                                //非基本类型需要深度遍历其对象  
                                toBeQueue.add(Array.get(obj, i));  
                            }  
                        }  
                    }  
                } else {  
                    while (tmpObjClass != null) {  
                        Field[] fields = tmpObjClass.getDeclaredFields();  
                        for (Field field : fields) {  
      
       if (Modifier.isStatic(field.getModifiers())   //静态不计  
                                    || field.getType().isPrimitive()) {    //基本类型不重复计  
                                continue;  
                            }  

                            field.setAccessible(true);  
                            Object fieldValue = field.get(obj);  
                            if (fieldValue == null) {  
                                continue;  
                            }  
                            toBeQueue.add(fieldValue);  
                        }  
                        tmpObjClass = tmpObjClass.getSuperclass();  
                    }  
                }  
            }  
            return size;  
        }  

        /** 
         * String.intern的对象不计；计算过的不计，也避免死循环 
         * 
         * @param visited 
         * @param obj 
         * @return 
         */  
        static boolean skipObject(Set<Object> visited, Object obj) {  
            if (obj instanceof String && obj == ((String) obj).intern()) {  
                return true;  
            }  
            return visited.contains(obj);  
        }  
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!