Calcola la dimensione dell'oggetto in Java

Question

Voglio registrare la quantità di memoria (in byte, si spera) che un oggetto occupa per un progetto (sto confrontando le dimensioni delle strutture dati) e sembra che non ci sia alcun metodo per farlo in Java. Presumibilmente, C/C++ ha il metodo sizeOf(), ma questo non esiste in Java. Ho provato a registrare la memoria libera nella JVM con Runtime.getRuntime().freeMemory() prima e dopo aver creato l'oggetto e quindi registrato la differenza, ma darebbe solo 0 o 131304 e nulla tra loro, indipendentemente dal numero di elementi nella struttura. Aiuto per favore!

Answer 1

È possibile utilizzare il pacchetto java.lang.instrumentation:

http://docs.oracle.com/javase/7/docs/api/java/lang/instrument/Instrumentation.html

Ha un metodo che può essere utilizzato per ottenere il ravvicinamento implementazione specifica della dimensione dell'oggetto, così come overhead associato all'oggetto.

La risposta che Sergey collegata ha un grande esempio, che io ripubblicare qui, ma si dovrebbe avere già guardato dal suo commento:

import java.lang.instrument.Instrumentation; 

public class ObjectSizeFetcher { 
    private static Instrumentation instrumentation; 

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

    public static long getObjectSize(Object o) { 
     return instrumentation.getObjectSize(o); 
    } 
} 

Uso getObjectSize:

public class C { 
    private int x; 
    private int y; 

    public static void main(String [] args) { 
     System.out.println(ObjectSizeFetcher.getObjectSize(new C())); 
    } 
} 

fonte per esempio:

In Java, what is the best way to determine the size of an object?

Answer 2

a google la ricerca di "Java sizeof" ha prodotto un bel articolo su Java sizeof su javaworld. In realtà, una lettura interessante.

Per rispondere alla tua domanda, non esiste un equivalente Java di "sizeof()", ma l'articolo descrive un paio di modi per ottenere la dimensione in byte delle classi istanziate.

Answer 3

Cerca in https://github.com/DimitrisAndreou/memory-measurer Guava lo utilizza internamente e ObjectGraphMeasurer è particolarmente semplice da utilizzare, senza alcuno speciale argomento della riga di comando.  

import objectexplorer.ObjectGraphMeasurer; 

public class Measurer { 

    public static void main(String[] args) { 
    Set<Integer> hashset = new HashSet<Integer>(); 
    Random random = new Random(); 
    int n = 10000; 
    for (int i = 1; i <= n; i++) { 
     hashset.add(random.nextInt()); 
    } 
    System.out.println(ObjectGraphMeasurer.measure(hashset)); 
    } 
} 

Answer 4

La classe java.lang.instrument.Instrumentation fornisce un bel modo per ottenere la dimensione di un oggetto Java, ma si richiede di definire un premain ed eseguire il programma con un agente Java. Questo è molto noioso quando non hai bisogno di alcun agente e quindi devi fornire un agente fittizio Jar alla tua applicazione.

Quindi ho ottenuto una soluzione alternativa utilizzando la classe Unsafe da sun.misc. Pertanto, considerando l'allineamento degli heap degli oggetti in base all'architettura del processore e il calcolo dell'offset del campo massimo, è possibile misurare la dimensione di un oggetto Java. Nell'esempio seguente utilizzo una classe ausiliaria UtilUnsafe per ottenere un riferimento all'oggetto sun.misc.Unsafe.

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() { } 
}