In Java, qual è il modo migliore per determinare la dimensione di un oggetto?

Ho un'applicazione che legge un file CSV con pile di righe di dati. Fornisco all'utente un riepilogo del numero di righe in base ai tipi di dati, ma desidero assicurarmi di non leggere troppe righe di dati e causare OutOfMemoryErrors. Ogni riga si traduce in un oggetto. C'è un modo semplice per scoprire la dimensione di quell'oggetto a livello di codice? Esiste un riferimento che definisce quanto sono grandi i tipi primitivi e i riferimenti agli oggetti per un VM?

In questo momento, ho un codice che dice di leggere fino a 32.000 righe , ma vorrei anche avere un codice che dice di leggere quante più righe possibili fino a quando non ho usato 32 MB di memoria. Forse questa è una domanda diversa, ma mi piacerebbe comunque saperlo.

È possibile utilizzare il pacchetto java.lang.instrument

Compila e metti questa classe in un JAR:

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);
    }
}

Aggiungi quanto segue al tuo MANIFEST.MF:

Premain-Class: ObjectSizeFetcher

Usa getObjectSize:

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

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

Invocare con:

java -javaagent:ObjectSizeFetcherAgent.jar C

Dovresti usare jol , uno strumento sviluppato come parte del progetto OpenJDK.

JOL (Java Object Layout) è la minuscola cassetta degli attrezzi per analizzare gli schemi di layout degli oggetti nelle JVM. Questi strumenti utilizzano Unsafe, JVMTI e Serviceability Agent (SA) pesantemente per decodificare il layout dell'oggetto reale, l'impronta e i riferimenti. Ciò rende JOL molto più preciso di altri strumenti che si basano su dump di heap, ipotesi di specifica, ecc.

Per ottenere le dimensioni di primitive, riferimenti ed elementi dell'array, utilizzare VMSupport.vmDetails(). Su Oracle JDK 1.8.0_40 in esecuzione su Windows a 64 bit (utilizzato per tutti gli esempi seguenti), questo metodo restituisce

Running 64-bit HotSpot VM.
Using compressed oop with 0-bit shift.
Using compressed klass with 3-bit shift.
Objects are 8 bytes aligned.
Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]
Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]

È possibile ottenere la dimensione ridotta di un'istanza di oggetto utilizzando ClassLayout.parseClass(Foo.class).toPrintable()(facoltativamente passando un'istanza a toPrintable). Questo è solo lo spazio consumato da una singola istanza di quella classe; non include altri oggetti a cui fa riferimento quella classe. Essa non comprende VM overhead per l'intestazione oggetto, allineamento campo e imbottitura. Per java.util.regex.Pattern:

java.util.regex.Pattern object internals:
 OFFSET  SIZE        TYPE DESCRIPTION                    VALUE
      0     4             (object header)                01 00 00 00 (0000 0001 0000 0000 0000 0000 0000 0000)
      4     4             (object header)                00 00 00 00 (0000 0000 0000 0000 0000 0000 0000 0000)
      8     4             (object header)                cb cf 00 20 (1100 1011 1100 1111 0000 0000 0010 0000)
     12     4         int Pattern.flags                  0
     16     4         int Pattern.capturingGroupCount    1
     20     4         int Pattern.localCount             0
     24     4         int Pattern.cursor                 48
     28     4         int Pattern.patternLength          0
     32     1     boolean Pattern.compiled               true
     33     1     boolean Pattern.hasSupplementary       false
     34     2             (alignment/padding gap)        N/A
     36     4      String Pattern.pattern                (object)
     40     4      String Pattern.normalizedPattern      (object)
     44     4        Node Pattern.root                   (object)
     48     4        Node Pattern.matchRoot              (object)
     52     4       int[] Pattern.buffer                 null
     56     4         Map Pattern.namedGroups            null
     60     4 GroupHead[] Pattern.groupNodes             null
     64     4       int[] Pattern.temp                   null
     68     4             (loss due to the next object alignment)
Instance size: 72 bytes (reported by Instrumentation API)
Space losses: 2 bytes internal + 4 bytes external = 6 bytes total

È possibile ottenere una vista di riepilogo delle dimensioni profonde di un'istanza di oggetto utilizzando GraphLayout.parseInstance(obj).toFootprint(). Naturalmente, alcuni oggetti nell'impronta potrebbero essere condivisi (a cui fa riferimento anche da altri oggetti), quindi si tratta di una sovrapprossimazione dello spazio che potrebbe essere recuperata quando quell'oggetto viene raccolto. Per il risultato di Pattern.compile("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$")(preso da questa risposta ), jol riporta un footprint totale di 1840 byte, di cui solo 72 sono l'istanza Pattern stessa.

java.util.regex.Pattern instance footprint:
     COUNT       AVG       SUM   DESCRIPTION
         1       112       112   [C
         3       272       816   [Z
         1        24        24   java.lang.String
         1        72        72   java.util.regex.Pattern
         9        24       216   java.util.regex.Pattern$1
        13        24       312   java.util.regex.Pattern$5
         1        16        16   java.util.regex.Pattern$Begin
         3        24        72   java.util.regex.Pattern$BitClass
         3        32        96   java.util.regex.Pattern$Curly
         1        24        24   java.util.regex.Pattern$Dollar
         1        16        16   java.util.regex.Pattern$LastNode
         1        16        16   java.util.regex.Pattern$Node
         2        24        48   java.util.regex.Pattern$Single
        40                1840   (total)

Se invece lo usi GraphLayout.parseInstance(obj).toPrintable(), jol ti dirà l'indirizzo, la dimensione, il tipo, il valore e il percorso delle dereferenze di campo a ciascun oggetto referenziato, anche se di solito sono troppi dettagli per essere utili. Per l'esempio di modello in corso, potresti ottenere quanto segue. (Probabilmente gli indirizzi cambieranno tra le esecuzioni.)

java.util.regex.Pattern object externals:
          ADDRESS       SIZE TYPE                             PATH                           VALUE
         d5e5f290         16 java.util.regex.Pattern$Node     .root.next.atom.next           (object)
         d5e5f2a0        120 (something else)                 (somewhere else)               (something else)
         d5e5f318         16 java.util.regex.Pattern$LastNode .root.next.next.next.next.next.next.next (object)
         d5e5f328      21664 (something else)                 (somewhere else)               (something else)
         d5e647c8         24 java.lang.String                 .pattern                       (object)
         d5e647e0        112 [C                               .pattern.value                 [^, [, a, -, z, A, -, Z, 0, -, 9, _, ., +, -, ], +, @, [, a, -, z, A, -, Z, 0, -, 9, -, ], +, \, ., [, a, -, z, A, -, Z, 0, -, 9, -, ., ], +, $]
         d5e64850        448 (something else)                 (somewhere else)               (something else)
         d5e64a10         72 java.util.regex.Pattern                                         (object)
         d5e64a58        416 (something else)                 (somewhere else)               (something else)
         d5e64bf8         16 java.util.regex.Pattern$Begin    .root                          (object)
         d5e64c08         24 java.util.regex.Pattern$BitClass .root.next.atom.val$rhs        (object)
         d5e64c20        272 [Z                               .root.next.atom.val$rhs.bits   [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
         d5e64d30         24 java.util.regex.Pattern$1        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e64d48         24 java.util.regex.Pattern$1        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs.val$rhs (object)
         d5e64d60         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e64d78         24 java.util.regex.Pattern$1        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$rhs (object)
         d5e64d90         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e64da8         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs.val$lhs (object)
         d5e64dc0         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs (object)
         d5e64dd8         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs        (object)
         d5e64df0         24 java.util.regex.Pattern$5        .root.next.atom                (object)
         d5e64e08         32 java.util.regex.Pattern$Curly    .root.next                     (object)
         d5e64e28         24 java.util.regex.Pattern$Single   .root.next.next                (object)
         d5e64e40         24 java.util.regex.Pattern$BitClass .root.next.next.next.atom.val$rhs (object)
         d5e64e58        272 [Z                               .root.next.next.next.atom.val$rhs.bits [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
         d5e64f68         24 java.util.regex.Pattern$1        .root.next.next.next.atom.val$lhs.val$lhs.val$lhs (object)
         d5e64f80         24 java.util.regex.Pattern$1        .root.next.next.next.atom.val$lhs.val$lhs.val$rhs (object)
         d5e64f98         24 java.util.regex.Pattern$5        .root.next.next.next.atom.val$lhs.val$lhs (object)
         d5e64fb0         24 java.util.regex.Pattern$1        .root.next.next.next.atom.val$lhs.val$rhs (object)
         d5e64fc8         24 java.util.regex.Pattern$5        .root.next.next.next.atom.val$lhs (object)
         d5e64fe0         24 java.util.regex.Pattern$5        .root.next.next.next.atom      (object)
         d5e64ff8         32 java.util.regex.Pattern$Curly    .root.next.next.next           (object)
         d5e65018         24 java.util.regex.Pattern$Single   .root.next.next.next.next      (object)
         d5e65030         24 java.util.regex.Pattern$BitClass .root.next.next.next.next.next.atom.val$rhs (object)
         d5e65048        272 [Z                               .root.next.next.next.next.next.atom.val$rhs.bits [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
         d5e65158         24 java.util.regex.Pattern$1        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e65170         24 java.util.regex.Pattern$1        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$lhs.val$rhs (object)
         d5e65188         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$lhs (object)
         d5e651a0         24 java.util.regex.Pattern$1        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$rhs (object)
         d5e651b8         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom.val$lhs.val$lhs (object)
         d5e651d0         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom.val$lhs (object)
         d5e651e8         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom (object)
         d5e65200         32 java.util.regex.Pattern$Curly    .root.next.next.next.next.next (object)
         d5e65220        120 (something else)                 (somewhere else)               (something else)
         d5e65298         24 java.util.regex.Pattern$Dollar   .root.next.next.next.next.next.next (object)

Le voci "(qualcos'altro)" descrivono altri oggetti nell'heap che non fanno parte di questo grafico di oggetti .

La migliore documentazione jol sono i campioni jol nel repository jol. Gli esempi mostrano operazioni jol comuni e mostrano come è possibile utilizzare jol per analizzare interni di VM e Garbage Collector.

Ho trovato accidentalmente una classe java "jdk.nashorn.internal.ir.debug.ObjectSizeCalculator", già in jdk, che è facile da usare e sembra abbastanza utile per determinare la dimensione di un oggetto.

System.out.println(ObjectSizeCalculator.getObjectSize(new gnu.trove.map.hash.TObjectIntHashMap<String>(12000, 0.6f, -1)));
System.out.println(ObjectSizeCalculator.getObjectSize(new HashMap<String, Integer>(100000)));
System.out.println(ObjectSizeCalculator.getObjectSize(3));
System.out.println(ObjectSizeCalculator.getObjectSize(new int[]{1, 2, 3, 4, 5, 6, 7 }));
System.out.println(ObjectSizeCalculator.getObjectSize(new int[100]));

i risultati:

164192
48
16
48
416

Alcuni anni fa Javaworld aveva pubblicato un articolo sulla determinazione della dimensione di oggetti Java compositi e potenzialmente nidificati , che in pratica descrivono la creazione di un'implementazione sizeof () in Java. L'approccio si basa fondamentalmente su altri lavori in cui le persone hanno identificato sperimentalmente la dimensione delle primitive e degli oggetti Java tipici e quindi applicano tale conoscenza a un metodo che ricorre in modo ricorsivo al grafico di un oggetto per calcolare la dimensione totale.

Sarà sempre in qualche modo meno preciso di un'implementazione in C nativa semplicemente a causa delle cose che accadono dietro le quinte di una classe, ma dovrebbe essere un buon indicatore.

In alternativa, un progetto SourceForge chiamato appropriatamente sizeof che offre una libreria Java5 con un'implementazione sizeof ().

PS Non utilizzare l'approccio di serializzazione, non esiste alcuna correlazione tra la dimensione di un oggetto serializzato e la quantità di memoria che consuma quando è attiva.

Innanzitutto "la dimensione di un oggetto" non è un concetto ben definito in Java. Potresti intendere l'oggetto stesso, con solo i suoi membri, l'oggetto e tutti gli oggetti a cui fa riferimento (il grafico di riferimento). Potresti indicare la dimensione in memoria o la dimensione sul disco. E alla JVM è consentito ottimizzare cose come le stringhe.

Quindi l'unico modo corretto è chiedere alla JVM, con un buon profiler (io uso YourKit ), che probabilmente non è quello che vuoi.

Tuttavia, dalla descrizione sopra sembra che ogni riga sia autonoma e non abbia un grande albero delle dipendenze, quindi il metodo di serializzazione sarà probabilmente una buona approssimazione sulla maggior parte delle JVM. Il modo più semplice per farlo è il seguente:

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

Ricorda che se hai oggetti con riferimenti comuni questo non darà il risultato corretto e la dimensione della serializzazione non corrisponderà sempre alla dimensione in memoria, ma è una buona approssimazione. Il codice sarà un po 'più efficiente se si inizializza la dimensione ByteArrayOutputStream su un valore sensibile.

Se vuoi solo sapere quanta memoria viene utilizzata nella tua JVM e quanto è gratuita, puoi provare qualcosa del genere:

// Get current size of heap in bytes
long heapSize = Runtime.getRuntime().totalMemory();

// Get maximum size of heap in bytes. The heap cannot grow beyond this size.
// Any attempt will result in an OutOfMemoryException.
long heapMaxSize = Runtime.getRuntime().maxMemory();

// Get amount of free memory within the heap in bytes. This size will increase
// after garbage collection and decrease as new objects are created.
long heapFreeSize = Runtime.getRuntime().freeMemory();

modifica: ho pensato che ciò potesse essere utile in quanto anche l'autore della domanda ha affermato che vorrebbe avere una logica che gestisca "leggi quante più righe possibile finché non avrò usato 32 MB di memoria".

Quando lavoravo su Twitter, ho scritto un'utilità per il calcolo delle dimensioni degli oggetti profondi. Tiene conto di diversi modelli di memoria (32-bit, oops compressi, 64-bit), padding, padding di sottoclassi, funziona correttamente su strutture e matrici di dati circolari. Puoi semplicemente compilare questo file .java; non ha dipendenze esterne:

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

Molte delle altre risposte forniscono dimensioni poco profonde, ad esempio le dimensioni di una HashMap senza nessuna delle chiavi o dei valori, che probabilmente non è quello che desideri.

Il progetto jamm usa il pacchetto java.lang.instrumentation sopra ma cammina sull'albero e quindi può darti l'uso della memoria profonda.

new MemoryMeter().measureDeep(myHashMap);

https://github.com/jbellis/jamm

Per utilizzare MemoryMeter, avviare JVM con "-javaagent: /jamm.jar"

Devi camminare gli oggetti usando la riflessione. Stai attento mentre fai:

• La semplice allocazione di un oggetto ha un certo sovraccarico nella JVM. L'importo varia in base a JVM, pertanto è possibile impostare questo valore come parametro. Almeno renderlo una costante (8 byte?) E applicare a tutto ciò che è allocato.
• Solo perché byteteoricamente 1 byte non significa che ne richiede solo uno in memoria.
• Ci saranno dei loop nei riferimenti agli oggetti, quindi dovrai tenere un HashMapo qualche altro usando object-uguale come comparatore per eliminare i loop infiniti.

@jodonnell: mi piace la semplicità della tua soluzione, ma molti oggetti non sono serializzabili (quindi ciò genererebbe un'eccezione), i campi possono essere transitori e gli oggetti possono ignorare i metodi standard.

Devi misurarlo con uno strumento o stimarlo manualmente e dipende dalla JVM che stai utilizzando.

C'è un overhead fisso per oggetto. È specifico per JVM, ma di solito stima 40 byte. Quindi devi guardare i membri della classe. I riferimenti agli oggetti sono 4 (8) byte in una JVM a 32 bit (64 bit). I tipi primitivi sono:

• booleano e byte: 1 byte
• char e short: 2 byte
• int e float: 4 byte
• lungo e doppio: 8 byte

Le matrici seguono le stesse regole; vale a dire, è un riferimento all'oggetto in modo che occupi 4 (o 8) byte nel tuo oggetto, e quindi la sua lunghezza moltiplicata per la dimensione del suo elemento.

Cercare di farlo in modo programmatico con le chiamate Runtime.freeMemory()non ti dà molta precisione, a causa delle chiamate asincrone al garbage collector, ecc. La profilazione dell'heap con -Xrunhprof o altri strumenti ti darà i risultati più accurati.

La java.lang.instrument.Instrumentationclasse fornisce un modo piacevole per ottenere le dimensioni di un oggetto Java, ma richiede di definire a premained eseguire il programma con un agente Java. Questo è molto noioso quando non hai bisogno di alcun agente e quindi devi fornire un agente Jar fittizio alla tua applicazione.

Quindi ho ottenuto una soluzione alternativa usando la Unsafeclasse dal sun.misc. Pertanto, considerando l'allineamento dell'heap degli oggetti in base all'architettura del processore e calcolando l'offset del campo massimo, è possibile misurare la dimensione di un oggetto Java. Nell'esempio seguente uso una classe ausiliaria UtilUnsafeper ottenere un riferimento sun.misc.Unsafeall'oggetto.

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

Esiste anche lo strumento Memory Measurer (precedentemente in Google Code , ora su GitHub ), che è semplice e pubblicato sotto la licenza commerciale Apache 2.0 , come discusso in una domanda simile .

Inoltre, richiede un argomento da riga di comando all'interprete java se si desidera misurare il consumo di byte di memoria, ma per il resto sembra funzionare bene, almeno negli scenari in cui l'ho usato.

Senza dover fare confusione con la strumentazione e così via, e se non hai bisogno di conoscere la dimensione esatta del byte di un oggetto, potresti seguire il seguente approccio:

System.gc();
Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

do your job here

System.gc();
Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

In questo modo leggi la memoria usata prima e dopo, e chiamando il GC appena prima di ottenere la memoria usata riduci il "rumore" quasi a 0.

Per un risultato più affidabile, è possibile eseguire il lavoro n volte, quindi dividere la memoria utilizzata per n, ottenendo la quantità di memoria necessaria per l'esecuzione. Ancora di più, puoi eseguire il tutto più volte e fare una media.

Ecco un'utilità che ho creato usando alcuni degli esempi collegati per gestire 32-bit, 64-bit e 64-bit con OOP compresso. Utilizza sun.misc.Unsafe.

Utilizza Unsafe.addressSize()per ottenere le dimensioni di un puntatore nativo e Unsafe.arrayIndexScale( Object[].class )per le dimensioni di un riferimento Java.

Utilizza l'offset di campo di una classe nota per calcolare la dimensione di base di un oggetto.

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 );
    }
}

Stavo cercando un calcolo di runtime di una dimensione dell'oggetto che soddisfacesse i seguenti requisiti:

• Disponibile in fase di esecuzione senza necessità di includere la strumentazione.
• Funziona con Java 9+ senza accesso a Unsafe.
• Si basa solo sulla classe. Non una dimensione profonda di quella che prende in considerazione la lunghezza delle stringhe, la lunghezza dell'array, ecc.

Quanto segue si basa sul codice di base dell'articolo originale degli specialisti Java ( https://www.javaspecialists.eu/archive/Issue078.html ) e alcuni bit della versione non sicura in un'altra risposta a questa domanda.

Spero che qualcuno lo trovi 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;
}

}

Non c'è una chiamata di metodo, se è quello che stai chiedendo. Con un po 'di ricerca, suppongo che tu possa scrivere il tuo. Un'istanza particolare ha una dimensione fissa derivata dal numero di riferimenti e valori primitivi più i dati di contabilità dell'istanza. Cammineresti semplicemente sul grafico dell'oggetto. Meno vari sono i tipi di riga, più facile.

Se è troppo lento o solo più problemi di quanti ne valga la pena, c'è sempre una buona vecchia fila che conta la regola dei pollici.

Ho scritto un test rapido una volta per stimare al volo:

public class Test1 {

    // non-static nested
    class Nested { }

    // static nested
    static class StaticNested { }

    static long getFreeMemory () {
        // waits for free memory measurement to stabilize
        long init = Runtime.getRuntime().freeMemory(), init2;
        int count = 0;
        do {
            System.out.println("waiting..." + init);
            System.gc();
            try { Thread.sleep(250); } catch (Exception x) { }
            init2 = init;
            init = Runtime.getRuntime().freeMemory();
            if (init == init2) ++ count; else count = 0;
        } while (count < 5);
        System.out.println("ok..." + init);
        return init;
    }

    Test1 () throws InterruptedException {

        Object[] s = new Object[10000];
        Object[] n = new Object[10000];
        Object[] t = new Object[10000];

        long init = getFreeMemory();

        //for (int j = 0; j < 10000; ++ j)
        //    s[j] = new Separate();

        long afters = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            n[j] = new Nested();

        long aftersn = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            t[j] = new StaticNested();

        long aftersnt = getFreeMemory();

        System.out.println("separate:      " + -(afters - init) + " each=" + -(afters - init) / 10000);
        System.out.println("nested:        " + -(aftersn - afters) + " each=" + -(aftersn - afters) / 10000);
        System.out.println("static nested: " + -(aftersnt - aftersn) + " each=" + -(aftersnt - aftersn) / 10000);

    }

    public static void main (String[] args) throws InterruptedException {
        new Test1();
    }

}

Il concetto generale è di allocare oggetti e misurare il cambiamento nello spazio di heap libero. Essendo la chiave getFreeMemory(), che richiede l'esecuzione di GC e attende la stabilizzazione della dimensione dell'heap disponibile riportata . L'output di quanto sopra è:

nested:        160000 each=16
static nested: 160000 each=16

Questo è quello che ci aspettiamo, dato il comportamento di allineamento e il possibile sovraccarico dell'intestazione del blocco heap.

Il metodo di strumentazione dettagliato nella risposta accettata qui il più accurato. Il metodo che ho descritto è accurato ma solo in condizioni controllate in cui nessun altro thread sta creando / scartando oggetti.

Usa solo Java Visual VM.

Ha tutto il necessario per profilare ed eseguire il debug dei problemi di memoria.

Ha anche una console OQL (Object Query Language) che ti permette di fare molte cose utili, una delle quali è sizeof(o)

Quando si utilizza JetBrains IntelliJ, abilitare innanzitutto "Collega agente di memoria" in File | Impostazioni | Build, Execution, Deployment | Debugger.

Durante il debug, fai clic con il pulsante destro del mouse su una variabile di interesse e scegli "Calcola dimensione mantenuta":

La mia risposta si basa sul codice fornito da Nick. Tale codice misura la quantità totale di byte occupati dall'oggetto serializzato. Quindi questo in realtà misura roba di serializzazione + footprint di memoria di oggetti semplici (basta serializzare ad esempio inte vedrai che la quantità totale di byte serializzati non lo è 4). Quindi, se vuoi ottenere un numero di byte non elaborato utilizzato esattamente per il tuo oggetto, devi modificare un po 'quel codice. Così:

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectSizeCalculator {
    private Object getFirstObjectReference(Object o) {
        String objectType = o.getClass().getTypeName();

        if (objectType.substring(objectType.length()-2).equals("[]")) {
            try {
                if (objectType.equals("java.lang.Object[]"))
                    return ((Object[])o)[0];
                else if (objectType.equals("int[]"))
                    return ((int[])o)[0];
                else
                    throw new RuntimeException("Not Implemented !");
            } catch (IndexOutOfBoundsException e) {
                return null;
            }
        }

        return o;
    } 

    public int getObjectSizeInBytes(Object o) {
        final String STRING_JAVA_TYPE_NAME = "java.lang.String";

        if (o == null)
            return 0;

        String objectType = o.getClass().getTypeName();
        boolean isArray = objectType.substring(objectType.length()-2).equals("[]");

        Object objRef = getFirstObjectReference(o);
        if (objRef != null && !(objRef instanceof Serializable))
            throw new RuntimeException("Object must be serializable for measuring it's memory footprint using this method !");

        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(o);
            oos.close();
            byte[] bytes = baos.toByteArray();

            for (int i = bytes.length - 1, j = 0; i != 0; i--, j++) {
                if (objectType != STRING_JAVA_TYPE_NAME) {
                    if (bytes[i] == 112)
                        if (isArray)
                            return j - 4;
                        else
                            return j;
                } else {
                    if (bytes[i] == 0)
                        return j - 1;
                }
            }
        } catch (Exception e) {
            return -1;
        }

        return -1;
    }    

}