En Java, ce qui est la meilleure façon de déterminer la taille d'un objet?

Y a quelques années Javaworld avait un article sur la détermination de la taille de composite et potentiellement imbriquée des objets Java, ils se sont contentés de marcher à travers la création d'un sizeof() mise en œuvre en Java. L'approche s'appuie essentiellement sur d'autres travaux où les gens expérimentalement identifié la taille de primitives et typique des objets Java et ensuite d'appliquer ces connaissances à une méthode récursive de promenades d'un objet graphique compte de la taille totale.

Il va toujours être un peu moins précis qu'un natif C mise en œuvre simplement parce que de ce qui se passe derrière les coulisses d'une classe, mais il devrait être un bon indicateur.

À l'inverse, un projet sur SourceForge dûment appelé sizeof qui offre un Java5 bibliothèque avec un sizeof() de la mise en œuvre.

P. S. Ne pas utiliser la sérialisation approche, il n'y a pas de corrélation entre la taille d'un objet sérialisé et la quantité de mémoire qu'elle consomme quand live.

Tout d'abord "la taille d'un objet" n'est pas un concept défini dans Java. Vous pourrait signifier que l'objet lui-même, avec ses membres, l'Objet et tous les objets qu'il désigne (le graphique de référence). Vous pourriez dire la taille de la mémoire ou de la taille sur le disque. Et la JVM est autorisé à optimiser des choses comme des Chaînes de caractères.

Donc la seule possibilité est de demander à la JVM, avec un bon profiler (j'utilise YourKit), qui n'est probablement pas ce que vous voulez.

Cependant, à partir de la description ci-dessus, il sonne comme chaque ligne sera autonome et ne pas avoir une grande dépendance de l'arbre, de sorte que la méthode de sérialisation sera probablement une bonne approximation sur la plupart des machines virtuelles. La façon la plus simple de le faire est comme suit:

 Serializable ser;
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 ObjectOutputStream oos = new ObjectOutputStream(baos);
 oos.writeObject(ser);
 oos.close();
 return baos.size();

N'oubliez pas que si vous avez des objets avec des références communes cette ne donner le résultat correct, et la taille de la sérialisation pas toujours à la hauteur de la taille en mémoire, mais c'est une bonne approximation. Le code sera un peu plus efficace si vous utilisez le ByteArrayOutputStream une taille raisonnable de la valeur.

En arrière quand j'ai travaillé sur Twitter, j'ai écrit un utilitaire de calcul de la profondeur la taille de l'objet. Il prend en compte différents modèles de mémoire (32 bits, compressé oups, 64-bit), le rembourrage, la sous-classe de rembourrage, fonctionne correctement sur la circulaire de structures de données et des tableaux. Vous pouvez simplement compiler celui-ci .fichier java; il n'a pas de dépendances externes:

https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/objectsize/ObjectSizeCalculator.java

Vous avez à marcher objets à l'aide de la réflexion. Veillez à ce que vous faites:

• Juste l'allocation d'un objet a une surcharge dans la JVM. Le montant varie en fonction de la JVM de sorte que vous pourriez faire de cette valeur d'un paramètre. De faire au moins une constante (8 octets?) et pour tout ce qui alloué.
• Juste parce que byte est théoriquement 1 octet ne signifie pas qu'il suffit d'un seul dans la mémoire.
• Il y aura des boucles dans les références de l'objet, de sorte que vous aurez besoin de garder un HashMap ou somesuch de l'objet est égale à la comparaison pour éliminer les boucles infinies.

@jodonnell: j'aime la simplicité de votre solution, mais de nombreux objets ne sont pas Sérialisables (donc, ce serait jeter une exception), les champs peuvent être transitoires, et les objets peuvent remplacer les méthodes standard.

La java.lang.instrument.Instrumentation classe fournit un bon moyen pour obtenir la taille d'un Objet Java, mais il nécessite de définir une premain et exécuter votre programme avec java agent. C'est très ennuyeux quand vous n'avez pas besoin de tout agent et ensuite vous devez fournir un mannequin Pot de l'agent à votre demande.

Donc j'ai une solution de rechange à l'aide de la Unsafe classe à partir de la sun.misc. Donc, en considérant les objets de tas d'alignement en fonction de l'architecture du processeur et de calcul de la durée maximale du champ de décalage, vous pouvez mesurer la taille d'un Objet Java. Dans l'exemple ci-dessous, j'utilise une classe auxiliaire UtilUnsafe pour obtenir une référence à la sun.misc.Unsafe objet.

private static final int NR_BITS = Integer.valueOf(System.getProperty("sun.arch.data.model"));
private static final int BYTE = 8;
private static final int WORD = NR_BITS/BYTE;
private static final int MIN_SIZE = 16; 
public static int sizeOf(Class src){
//
//Get the instance fields of src class
//
List<Field> instanceFields = new LinkedList<Field>();
do{
if(src == Object.class) return MIN_SIZE;
for (Field f : src.getDeclaredFields()) {
if((f.getModifiers() & Modifier.STATIC) == 0){
instanceFields.add(f);
}
}
src = src.getSuperclass();
}while(instanceFields.isEmpty());
//
//Get the field with the maximum offset
// 
long maxOffset = 0;
for (Field f : instanceFields) {
long offset = UtilUnsafe.UNSAFE.objectFieldOffset(f);
if(offset > maxOffset) maxOffset = offset; 
}
return  (((int)maxOffset/WORD) + 1)*WORD; 
}
class UtilUnsafe {
public static final sun.misc.Unsafe UNSAFE;
static {
Object theUnsafe = null;
Exception exception = null;
try {
Class<?> uc = Class.forName("sun.misc.Unsafe");
Field f = uc.getDeclaredField("theUnsafe");
f.setAccessible(true);
theUnsafe = f.get(uc);
} catch (Exception e) { exception = e; }
UNSAFE = (sun.misc.Unsafe) theUnsafe;
if (UNSAFE == null) throw new Error("Could not obtain access to sun.misc.Unsafe", exception);
}
private UtilUnsafe() { }
}

Ici est un utilitaire que j'ai faite à l'aide de certains des exemples liés à la poignée 32-bit, 64-bit et 64-bits compressés de la programmation orientée objet. Il utilise sun.misc.Unsafe.

Il utilise Unsafe.addressSize() pour obtenir la taille d'un pointeur natif et Unsafe.arrayIndexScale( Object[].class ) pour la taille de Java de référence.

Il utilise le champ décalage d'une catégorie connue de travailler sur la base de la taille d'un objet.

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.IdentityHashMap;
import java.util.Stack;
import sun.misc.Unsafe;
/** Usage: 
* MemoryUtil.sizeOf( object )
* MemoryUtil.deepSizeOf( object )
* MemoryUtil.ADDRESS_MODE
*/
public class MemoryUtil
{
private MemoryUtil()
{
}
public static enum AddressMode
{
/** Unknown address mode. Size calculations may be unreliable. */
UNKNOWN,
/** 32-bit address mode using 32-bit references. */
MEM_32BIT,
/** 64-bit address mode using 64-bit references. */
MEM_64BIT,
/** 64-bit address mode using 32-bit compressed references. */
MEM_64BIT_COMPRESSED_OOPS
}
/** The detected runtime address mode. */
public static final AddressMode ADDRESS_MODE;
private static final Unsafe UNSAFE;
private static final long ADDRESS_SIZE; //The size in bytes of a native pointer: 4 for 32 bit, 8 for 64 bit
private static final long REFERENCE_SIZE; //The size of a Java reference: 4 for 32 bit, 4 for 64 bit compressed oops, 8 for 64 bit
private static final long OBJECT_BASE_SIZE; //The minimum size of an Object: 8 for 32 bit, 12 for 64 bit compressed oops, 16 for 64 bit
private static final long OBJECT_ALIGNMENT = 8;
/** Use the offset of a known field to determine the minimum size of an object. */
private static final Object HELPER_OBJECT = new Object() { byte b; };
static
{
try
{
//Use reflection to get a reference to the 'Unsafe' object.
Field f = Unsafe.class.getDeclaredField( "theUnsafe" );
f.setAccessible( true );
UNSAFE = (Unsafe) f.get( null );
OBJECT_BASE_SIZE = UNSAFE.objectFieldOffset( HELPER_OBJECT.getClass().getDeclaredField( "b" ) );
ADDRESS_SIZE = UNSAFE.addressSize();
REFERENCE_SIZE = UNSAFE.arrayIndexScale( Object[].class );
if( ADDRESS_SIZE == 4 )
{
ADDRESS_MODE = AddressMode.MEM_32BIT;
}
else if( ADDRESS_SIZE == 8 && REFERENCE_SIZE == 8 )
{
ADDRESS_MODE = AddressMode.MEM_64BIT;
}
else if( ADDRESS_SIZE == 8 && REFERENCE_SIZE == 4 )
{
ADDRESS_MODE = AddressMode.MEM_64BIT_COMPRESSED_OOPS;
}
else
{
ADDRESS_MODE = AddressMode.UNKNOWN;
}
}
catch( Exception e )
{
throw new Error( e );
}
}
/** Return the size of the object excluding any referenced objects. */
public static long shallowSizeOf( final Object object )
{
Class<?> objectClass = object.getClass();
if( objectClass.isArray() )
{
//Array size is base offset + length * element size
long size = UNSAFE.arrayBaseOffset( objectClass )
+ UNSAFE.arrayIndexScale( objectClass ) * Array.getLength( object );
return padSize( size );
}
else
{
//Object size is the largest field offset padded out to 8 bytes
long size = OBJECT_BASE_SIZE;
do
{
for( Field field : objectClass.getDeclaredFields() )
{
if( (field.getModifiers() & Modifier.STATIC) == 0 )
{
long offset = UNSAFE.objectFieldOffset( field );
if( offset >= size )
{
size = offset + 1; //Field size is between 1 and PAD_SIZE bytes. Padding will round up to padding size.
}
}
}
objectClass = objectClass.getSuperclass();
}
while( objectClass != null );
return padSize( size );
}
}
private static final long padSize( final long size )
{
return (size + (OBJECT_ALIGNMENT - 1)) & ~(OBJECT_ALIGNMENT - 1);
}
/** Return the size of the object including any referenced objects. */
public static long deepSizeOf( final Object object )
{
IdentityHashMap<Object,Object> visited = new IdentityHashMap<Object,Object>();
Stack<Object> stack = new Stack<Object>();
if( object != null ) stack.push( object );
long size = 0;
while( !stack.isEmpty() )
{
size += internalSizeOf( stack.pop(), stack, visited );
}
return size;
}
private static long internalSizeOf( final Object object, final Stack<Object> stack, final IdentityHashMap<Object,Object> visited )
{
//Scan for object references and add to stack
Class<?> c = object.getClass();
if( c.isArray() && !c.getComponentType().isPrimitive() )
{
//Add unseen array elements to stack
for( int i = Array.getLength( object ) - 1; i >= 0; i-- )
{
Object val = Array.get( object, i );
if( val != null && visited.put( val, val ) == null )
{
stack.add( val );
}
}
}
else
{
//Add unseen object references to the stack
for( ; c != null; c = c.getSuperclass() )
{
for( Field field : c.getDeclaredFields() )
{
if( (field.getModifiers() & Modifier.STATIC) == 0 
&& !field.getType().isPrimitive() )
{
field.setAccessible( true );
try
{
Object val = field.get( object );
if( val != null && visited.put( val, val ) == null )
{
stack.add( val );
}
}
catch( IllegalArgumentException e )
{
throw new RuntimeException( e );
}
catch( IllegalAccessException e )
{
throw new RuntimeException( e );
}
}
}
}
}
return shallowSizeOf( object );
}
}

Il n'y a pas un appel de méthode, si c'est ce que vous me demandez. Avec un peu de recherche, je suppose que vous pourriez écrire votre propre. Un cas particulier est fixe de taille moyenne dérivée à partir du nombre de références et de valeurs primitives plus d'instance tenue de la comptabilité de données. Vous pouvez tout simplement marcher sur le graphe d'objets. Le moins varié les types de ligne, le plus facile.

Si c'est trop lent ou tout simplement plus d'ennuis que cela vaut la peine, il y a toujours de la bonne vieille ligne de comptage de règle-de-pouce.

Suffit d'utiliser java visual VM.

Il a tout ce dont vous avez besoin pour le profil et le débogage des problèmes de mémoire.

Il dispose également d'un OQL (Object Query Language) console qui permet de faire beaucoup de choses utiles, dont un sizeof(o)

Vous pouvez générer un dump du tas (avec jmap, par exemple), puis d'analyser la sortie de trouver l'objet tailles. C'est une solution hors ligne, mais vous pouvez examiner profonde et peu profonde tailles, etc.

Cette réponse n'est pas liée à la taille de l'Objet, mais quand vous êtes en utilisant un tableau pour contenir les objets; la quantité de mémoire de la taille, il va allouer pour l'objet.

Donc des tableaux, une liste ou une carte de tous ceux de la collection ne sera pas aller afin de stocker des objets vraiment (uniquement au moment de primitives, véritable objet de la taille de la mémoire est nécessaire), il va stocker uniquement les références de ces objets.

Maintenant la Used heap memory = sizeOfObj + sizeOfRef (* 4 bytes) in collection

• (4/8 octets) dépend (32/64 bits) système d'exploitation

PRIMITIVES

int   [] intArray    = new int   [1]; will require 4 bytes.
long  [] longArray   = new long  [1]; will require 8 bytes.

OBJETS

Object[] objectArray = new Object[1]; will require 4 bytes. The object can be any user defined Object.
Long  [] longArray   = new Long  [1]; will require 4 bytes.

Je veux dire tous les objets de RÉFÉRENCE avec 4 octets de mémoire. Il est peut-être la Chaîne de référence OU Double référence de l'objet, Mais cela dépend de la création d'un objet de la mémoire nécessaire varie.

e.g) Si je créer un objet pour le dessous de la classe ReferenceMemoryTest alors 4 + 4 + 4 = 12 octets de mémoire sera créé. La mémoire peut varier lorsque vous essayez d'initialiser les références.

 class ReferenceMemoryTest {
public String refStr;
public Object refObj;
public Double refDoub; 
}

Donc lors de la création de l'objet/référence tableau, tout son contenu sera occupé avec des références NULLES. Et nous savons que chaque référence nécessite 4 octets.

Et enfin, l'allocation de mémoire pour le code ci-dessous est de 20 octets.

ReferenceMemoryTest ref1 = new ReferenceMemoryTest(); ( 4(ref1) + 12 = 16 octets)
ReferenceMemoryTest ref2 = ref1; ( 4(ref2) + 16 = 20 octets)

Je cherchais un moteur d'exécution de calcul de la taille de l'objet qui satisfait aux exigences suivantes:

• Disponibles au moment de l'exécution, sans avoir besoin d'inclure l'instrumentation.
• Fonctionne avec Java 9+ sans accès à l'Dangereux.
• Est basé sur la Classe seulement. Pas une profonde sizeOf qui prend en compte les longueurs de chaîne, tableau des longueurs, etc.

La liste suivante est basée sur le code de base de l'original java spécialistes de l'article (https://www.javaspecialists.eu/archive/Issue078.html) et quelques brèves de l'Dangereux version dans une autre réponse à cette question.

J'espère que quelqu'un le trouve utile.

public class JavaSize {
private static final int NR_BITS = Integer.valueOf(System.getProperty("sun.arch.data.model"));
private static final int BYTE = 8;
private static final int WORD = NR_BITS / BYTE;
private static final int HEADER_SIZE = 8;
public static int sizeOf(Class<?> clazz) {
int result = 0;
while (clazz != null) {
Field[] fields = clazz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
if (!Modifier.isStatic(fields[i].getModifiers())) {
if (fields[i].getType().isPrimitive()) {
Class<?> primitiveClass = fields[i].getType();
if (primitiveClass == boolean.class || primitiveClass == byte.class) {
result += 1;
} else if (primitiveClass == short.class) {
result += 2;
} else if (primitiveClass == int.class || primitiveClass == float.class) {
result += 4;
} else if (primitiveClass == double.class || primitiveClass == long.class) {
result += 8;
}
} else {
//assume compressed references.
result += 4;
}
}
}
clazz = clazz.getSuperclass();
//round up to the nearest WORD length.
if ((result % WORD) != 0) {
result += WORD - (result % WORD);
}
}
result += HEADER_SIZE;
return result;
}

}

Je doute que vous voulez le faire par programmation sauf si vous voulez juste faire une fois et de les stocker pour une utilisation future. C'est un coûteuse. Il n'y a pas de sizeof() opérateur en Java, et même s'il y était, il ne serait que de compter le coût des références vers d'autres objets et la taille de l'primitives.

D'une manière que vous pourriez faire c'est de sérialiser la chose à un Fichier et regarde la taille du fichier, comme ceci:

Serializable myObject;
ObjectOutputStream oos = new ObjectOutputStream (new FileOutputStream ("obj.ser"));
oos.write (myObject);
oos.close ();

Bien sûr, cela suppose que chaque objet est distinct et ne contient pas non transitoire des références à autre chose.

Une autre stratégie serait de prendre chaque objet et de l'examiner ses membres par la réflexion et à ajouter les tailles (boolean & octet = 1 byte, short & char = 2 octets, etc.), travailler votre chemin vers le bas de l'adhésion de la hiérarchie. Mais c'est fastidieux et coûteux, et finit par faire la même chose, la sérialisation stratégie permettrait de le faire.