référence - Quelle est la consommation de mémoire d'un objet en Java?




reference java definition (8)

L'espace mémoire consommé par un objet avec 100 attributs est-il le même que celui de 100 objets, avec un attribut chacun?

Non.

Quelle quantité de mémoire est allouée à un objet?

  • La surcharge est de 8 octets sur 32 bits, 12 octets sur 64 bits; puis arrondi à un multiple de 4 octets (32 bits) ou de 8 octets (64 bits).

Combien d'espace supplémentaire est utilisé lors de l'ajout d'un attribut?

  • Les attributs vont de 1 octet (char / booléen) à 8 octets (long / double), mais les références sont soit 4 octets soit 8 octets selon qu'il s'agit de 32bit ou de 64bit, mais que -Xmx soit <32Gb ou> = 32Gb: Les JVM 64 bits typiques ont une optimisation appelée "-UseCompressedOops" qui compresse les références à 4 octets si le tas est inférieur à 32Go.

L'espace mémoire consommé par un objet avec 100 attributs est-il le même que celui de 100 objets, avec un attribut chacun?

Quelle quantité de mémoire est allouée à un objet?
Combien d'espace supplémentaire est utilisé lors de l'ajout d'un attribut?



Chaque objet a une certaine surcharge pour son moniteur associé et les informations de type, ainsi que les champs eux-mêmes. Au-delà de cela, les champs peuvent être étendus à peu près, mais la JVM le juge approprié (je crois) - mais comme indiqué dans une autre réponse , au moins certaines machines JVM seront assez serrées. Considérons une classe comme celle-ci:

public class SingleByte
{
    private byte b;
}

contre

public class OneHundredBytes
{
    private byte b00, b01, ..., b99;
}

Sur une machine SingleByte 32 bits, je m'attendrais à ce que 100 instances de SingleByte prennent 1200 octets (8 octets de surcharge + 4 octets pour le champ en raison du remplissage / alignement). Je m'attendais à ce qu'une instance de OneHundredBytes prenne 108 octets - la surcharge, puis 100 octets, emballés. OneHundredBytes , il peut certainement varier selon la JVM - une implémentation peut décider de ne pas OneHundredBytes les champs dans OneHundredBytes , ce qui l'amène à prendre 408 octets (= 8 bytes overhead + 4 * 100 alignés / padded bytes). Sur une JVM 64 bits, le surcoût peut également être plus important (pas sûr).

EDIT: Voir le commentaire ci-dessous; HotSpot apparemment pads à 8 octets frontières au lieu de 32, de sorte que chaque instance de SingleByte prendrait 16 octets.

De toute façon, le "grand objet unique" sera au moins aussi efficace que de multiples petits objets - pour des cas simples comme celui-ci.



La mémoire totale utilisée / libre d'un programme peut être obtenue dans le programme via

java.lang.Runtime.getRuntime();

L'exécution a plusieurs méthode qui se rapporte à la mémoire. L'exemple de codage suivant illustre son utilisation.

package test;

 import java.util.ArrayList;
 import java.util.List;

 public class PerformanceTest {
     private static final long MEGABYTE = 1024L * 1024L;

     public static long bytesToMegabytes(long bytes) {
         return bytes / MEGABYTE;
     }

     public static void main(String[] args) {
         // I assume you will know how to create a object Person yourself...
         List < Person > list = new ArrayList < Person > ();
         for (int i = 0; i <= 100000; i++) {
             list.add(new Person("Jim", "Knopf"));
         }
         // Get the Java runtime
         Runtime runtime = Runtime.getRuntime();
         // Run the garbage collector
         runtime.gc();
         // Calculate the used memory
         long memory = runtime.totalMemory() - runtime.freeMemory();
         System.out.println("Used memory is bytes: " + memory);
         System.out.println("Used memory is megabytes: " + bytesToMegabytes(memory));
     }
 }

La question sera très large.

Cela dépend de la variable de classe ou vous pouvez appeler en tant qu'utilisation de mémoire d'états dans Java.

Il a également besoin de mémoire supplémentaire pour les en-têtes et le référencement.

La mémoire de tas utilisée par un objet Java inclut

  • mémoire pour les champs primitifs, en fonction de leur taille (voir ci-dessous pour les tailles de types primitifs);

  • mémoire pour les champs de référence (4 octets chacun);

  • un en-tête d'objet, constitué de quelques octets d'informations "d'entretien";

Les objets dans Java nécessitent également des informations "d'entretien", telles que l'enregistrement de la classe, de l'ID et des indicateurs d'état d'un objet, comme si l'objet est actuellement accessible, actuellement verrouillé par synchronisation, etc.

La taille de l'en-tête de l'objet Java varie sur jvm 32 et 64 bits.

Bien que ce sont les principaux consommateurs de mémoire jvm nécessite également des champs supplémentaires parfois comme pour l'alignement du code, etc

Tailles des types primitifs

booléen et byte - 1

char et court - 2

int & float - 4

long et double - 8


Non, 100 petits objets ont besoin de plus d'informations (mémoire) qu'un gros.


Non, l'enregistrement d'un objet prend aussi un peu de mémoire. 100 objets avec 1 attribut prendront plus de mémoire.





footprint