Quelle est la consommation de la mémoire d'un objet en Java?

Mindprod souligne que ce n'est pas une question simple à répondre:

Une JVM est libre pour stocker des données comme il se plaît à l'interne, big ou little endian, avec n'importe quelle quantité de rembourrage ou des frais généraux, si les primitives doivent se comporter comme s'ils avaient le officiel tailles.

Par exemple, la JVM ou compilateur natif peut décider de stocker une boolean[] en 64 bits de long morceaux comme un BitSet. Il n'a pas à vous dire, tant que le programme donne les mêmes réponses.

• Il peut allouer des Objets sur la pile.
• Il peut optimiser certaines variables ou les appels de méthode totalement en dehors de l'existence en les remplaçant par des constantes.
• Il pourrait version des méthodes ou des boucles, c'est à dire compiler les deux versions d'une méthode, chacun optimisé pour une situation donnée, puis de décider à l'avant dont une à l'appel.

Puis, bien sûr, le matériel et l'OS ont multicouche caches, sur puce-cache, cache SRAM, DRAM cache, RAM ordinaire travaillant ensemble et de stockage de sauvegarde sur disque. Vos données peuvent être dupliqué à chaque niveau de cache. Toute cette complexité signifie que vous ne pouvez très grossièrement prédire la consommation de RAM.

Méthodes de mesure

Vous pouvez utiliser Instrumentation.getObjectSize() pour obtenir une estimation de stockage consommé par un objet.

De visualiser l' réelle disposition de l'objet, de la taille et de références, vous pouvez utiliser le JOL (Java Disposition de l'Objet) de l'outil.

Objet des en-têtes et les références de l'Objet

Dans un cadre moderne 64-bit JDK, un objet a un 12-octets d'en-tête, rembourré, à un multiple de 8 octets, de sorte que la taille minimale des objets est de 16 octets. Pour 32-bit Jvm, la surcharge est de 8 octets, collier pour un multiple de 4 octets. (À partir de Dmitry Spikhalskiy réponse, Jayen réponse, et JavaWorld.)

Généralement, les références sont de 4 octets sur les plates-formes 32 bits ou sur les plateformes 64 bits jusqu'à -Xmx32G; et de 8 octets au-dessus de 32 go (-Xmx32G). (Voir comprimé références de l'objet.)

Comme un résultat, une JVM 64 bits nécessitent habituellement de 30 à 50% plus d'espace de tas. (Dois-je utiliser un 32 ou un 64 bits JVM?, 2012, JDK 1.7)

Coffret types, les tableaux et les chaînes de

Boîte wrappers ont une surcharge par rapport à des types primitifs (à partir de JavaWorld):

• Integer: Le 16 octets résultat est un peu moins bonne que ce que j'attendais, car un int valeur peut s'adapter à seulement 4 octets supplémentaires. À l'aide d'un Integer me coûte de 300% de la charge de la mémoire par rapport à quand je peux stocker la valeur d'un type primitif

• Long: 16 octets également: Clairement, réel la taille de l'objet sur le tas est soumis à de faibles niveaux d'alignement de la mémoire fait par un particulier JVM pour un type de PROCESSEUR. Il ressemble à un Long est de 8 octets de l'Objet de frais généraux, plus 8 octets de plus que pour la réelle valeur de type long. En revanche, Integer avait un solde non utilisé de 4 octets trou, probablement parce que la JVM-je utiliser les forces de l'alignement des objets sur un octet de 8 limite de mot.

Autres conteneurs sont trop coûteux:

• Tableaux multidimensionnels: il propose une autre surprise.
  
  Les développeurs utilisent couramment des constructions comme les int[dim1][dim2] numérique et le calcul scientifique.

  Dans un int[dim1][dim2] occurrence de array, tous imbriqués int[dim2] tableau est un Object dans son propre droit. Chacun ajoute l'habituel tableau de 16 octets de surcharge. Lorsque je n'ai pas besoin d'un triangulaire ou en drapeau de tableau, qui représente pur frais généraux. L'incidence augmente lorsque les dimensions du tableau diffèrent grandement.

  Par exemple, un int[128][2] instance prend de 3 600 octets. Par rapport à de la de 1 040 octets un int[256] exemple utilise (qui a la même capacité), de 3 600 octets représentent un 246 pour cent de frais généraux. Dans le cas extrême de byte[256][1], le facteur de traitement est de près de 19! Comparez le C/C++ situation dans laquelle la même syntaxe ne pas ajouter de surcharge de stockage.

• String: un String's de la mémoire pistes de croissance interne char de la matrice de la croissance. Cependant, la String classe ajoute un autre 24 octets de surcharge.

  Pour un non vide String de taille de 10 caractères ou moins, l'ajout de la surcharge de coût par rapport à la capacité de charge utile (2 octets pour chaque caractère plus 4 octets pour la longueur), varie de 100 à 400 pour cent.

Alignement

Considérer cette exemple d'objet:

class X {                      //8 bytes for reference to the class definition
   int a;                      //4 bytes
   byte b;                     //1 byte
   Integer c = new Integer();  //4 bytes for a reference
}

D'un naïf somme suggère qu'une instance de X utiliserait 17 octets. Toutefois, en raison de l'alignement (également appelé de remplissage), la JVM alloue de la mémoire, en multiple de 8 octets, donc au lieu de 17 octets qu'il serait d'allouer 24 octets.

Chaque objet a une certaine surcharge pour ses associés de surveiller et d'informations de type, ainsi que les champs eux-mêmes. Au-delà, les champs peuvent être énoncés assez bien cependant la JVM voit ajustement (je crois) - mais comme montré dans une autre réponse, au moins certains Jvm pack assez étroitement. Considérons une classe comme ceci:

public class SingleByte
{
    private byte b;
}

vs

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

Sur une JVM 32 bits, je m'attends à 100 instances de SingleByte de prendre 1200 octets (8 octets de surcharge + 4 octets pour le champ en raison de rembourrage/alignement). Je m'attends à une instance de OneHundredBytes de prendre 108 octets - les frais généraux, et de 100 octets, paniers. Il peut certainement varier en fonction de la JVM si - une mise en œuvre peut décider de ne pas emballer les champs de OneHundredBytes, conduisant à la prise de 408 octets (= 8 octets + 4 * 100 aligné rembourré en octets). Sur une JVM 64 bits la surcharge pourrait bien être plus grand aussi (pas sûr).

EDIT: Voir le commentaire ci-dessous; apparemment HotSpot plaquettes de 8 limites d'octets au lieu de 32, de sorte que chaque instance de SingleByte prendrait 16 octets.

De toute façon, le "seul objet" sera au moins aussi efficace que de multiples petits objets - pour les cas simples comme ça.

Il semble que chaque objet a une surcharge de 16 octets sur les systèmes 32 bits (et de 24 octets sur les systèmes 64 bits).

http://algs4.cs.princeton.edu/14analysis/ est une bonne source d'information. Un exemple parmi de nombreux bons est la suivante.

http://www.cs.virginia.edu/kim/publicity/pldi09tutorials/memory-efficient-java-tutorial.pdf est également très instructif, par exemple:

Au total /libres de la mémoire d'un programme peuvent être obtenus dans le programme via

java.lang.Runtime.getRuntime();

L'exécution a plusieurs méthode qui se rapporte à la mémoire. Le codage suivant l'exemple de démontrer 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 l'appeler comme les états de l'utilisation de la mémoire en java.

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

Le segment de mémoire utilisée par un objet Java comprend

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

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

• un objet en-tête, composé de quelques octets de "ménage" de l'information;

Objets en java nécessite également de "ménage" de l'information, telles que l'enregistrement d'un objet de la classe, de l'identité et le statut des indicateurs tels que si l'objet est joignable, actuellement à la synchronisation verrouillé etc.

Objet Java-tête de taille varie sur 32 bits et 64 bits de la jvm.

Bien que ces sont les principaux consommateurs de mémoire de la jvm exige également d'autres domaines, parfois, comme pour l'alignement du code de l'e.t.c.

Tailles de types primitifs

boolean & byte -- 1

char & court -- 2

int & float -- 4

long & double -- 8

non, 100 petits objets a besoin de plus d'informations (de mémoire) que dans une grande.