android - java中使用MAT是shallow size 单位是什么

Question

java中shallow size 单位是什么

Answer 1

Si vous souhaitez expliquer clairement la taille peu profonde, vous devez mentionner la taille conservée.
taille peu profonde : Indique la taille occupée par son propre objet.
taille conservée : la taille conservée du propre objet + l'objet de référence.

Empruntons d'abord une image, qui peut représenter plus clairement la relation de calcul entre eux.

Taille peu profonde de B = B ;

Taille retenue de B = taille peu profonde B + taille retenue C + taille retenue D ;

Avant de donner un exemple, vous devez d'abord comprendre le stockage des objets JAVA dans le tas Prenons comme exemple la machine virtuelle JVM 32 bits :
Les objets JAVA sont composés de 3 parties dans le tas :

1. En-tête de l'objet
   L'en-tête de l'objet contient deux parties de données
   Une : les données d'exécution. La JVM 32 bits est de 32 bits, soit 4 octets. Le 64 bits est de 8 octets.
   2 : Type de pointeur.

Les

2. Données d'instance
   sont les données qui stockent les variables d'instance. Les types de variables comprennent deux types de base de variables et de variables de référence.
   Ne parlons pas de la taille des octets occupés par les variables de type de base. Nous stockons les pointeurs dans des variables de référence.

3. Remplissage des données
   L'espace de stockage de l'objet est un multiple entier de 8 octets. Si l'en-tête de l'objet + les données d'instance sont inférieurs à un multiple entier de 8 octets, il sera rempli.

En parlant de taille de type de référence, une référence occupe 4 octets dans une machine virtuelle 32 bits. Si la compression du pointeur n'est pas activée dans une machine virtuelle 64 bits, une référence occupe 8 octets.

Nous expliquerons ci-dessous à partir d'exemples :

public class TestObjSize {
    private int a = 1;
    private boolean b = true;
    private TestObjSize testObjSize;
    
    public static void main(String[] args) {
        Object object = new Object();
        TestObjSize test = new TestObjSize();//这个new出来的对象记为obj1
        test.testObjSize = new TestObjSize();//这个new出来的对象记为obj2
        
        System.out.println(object.hashCode());
        System.out.println(test.hashCode());
        
        try {
            Thread.sleep(3000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Parce que la taille peu profonde n'a rien à voir avec le fait que la variable d'instance ait une référence, nous analysons d'abord la taille peu profonde de **TestObjSize,
taille peu profonde = 4 octets (en-tête d'objet) + 4 octets (pointeur de type) + 4 octets (int a) + 1byte(boolean b) + 4byte(TestObjSize reference) = 17;**
17 n'est pas un multiple entier de 8, il y aura donc 7 octets de données de remplissage La taille finale peu profonde de l'instance. objet de type TestObjSize = 24;

D'après l'exemple, nous voyons que le testObjSize de l'objet obj2 = null,
la taille retenue d'obj2 = la taille peu profonde d'obj2 = 24 ;
Le testObjSize de l'objet obj1 est obj2, donc la taille retenue d'obj1 = la taille peu profonde d'obj1 taille + taille conservée de obj2 = 48 ;

Attachez un tas à la fin !

S'il y a des erreurs, veuillez me le dire.