Qual è l'overhead di memoria di una funzione in una classe?Qual è l'overhead di memoria di un metodo Java?
Per esempio,
Class A
{
int a
}
Class B
{
int a
int foo(int);
}
Così 100 istanze di classe A dovrebbe essere di 80 byte. Che dire di 100 esempi di classe B?
Probabilmente sizeof il puntatore v-table arrotondato ad un multiplo di 16.
Le classi di entrambi gli oggetti avranno una sorta di riferimento alla loro classe. –
Sì, il puntatore alla tabella delle funzioni virtuali. – tpdi
Il metodo non viene memorizzato nella forma serializzata. E 'così semplice.
Modifica: Per quanto riguarda gli oggetti nella VM durante l'esecuzione, la dimensione deve essere costante, indipendentemente dal numero di metodi della classe dell'oggetto.
80 byte poiché un metodo non è incluso nell'oggetto. A meno che non si stia parlando anche del tipo di oggetto "vtable", nel qual caso probabilmente 160 byte.
Chiarimento sui 160 byte. Il 160 sarebbe se ogni oggetto assegnasse il proprio vtable (che è una possibile implementazione). In alternativa (e come indicato nei commenti) un modo migliore sarebbe un vtable per classe, il che significherebbe 80 + la dimensione del puntatore al vtable (probabilmente 4 o 8 byte a seconda della VM). Quindi 84 o 88 byte.
Questa intera cosa dipende totalmente dal modo in cui la VM alloca la memoria e si occupa di metodi non finali. Senza sapere come viene implementata la particolare VM, nessuna domanda può essere risolta correttamente.
Entrambe le classi hanno un qualche tipo di riferimento alla loro classe (un equivalente a un puntatore vtbl C++). Non è come se ogni oggetto portasse un sacco di informazioni di classe su qualsiasi tipo di VM ragionevole. –
Questa è un'implementazione specifica per la macchina virtuale, in quanto è un'immigrazione specifica del compilatore C++. – TofuBeer
Tom, sembra che tu sia eccessivamente incentrato sull'implementazione di Sun quando commenta le mie risposte. Se non puoi preoccuparti di pensare che ci sono altre possibili implementazioni VM, beh, non so cosa dire. – TofuBeer
Uguale, 80! (in breve)
Come poche altre persone hanno detto, il metodo non è memorizzato nella serializzazione.
È possibile eseguire facilmente un test per mostrarlo in questo esempio con il seguente codice.
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class SerializationTest {
public static void main(String[] args) {
serialize(true);
serialize(false);
}
public static void serialize(boolean aOrB) {
FileOutputStream fos = null;
ObjectOutputStream out = null;
try {
fos = new FileOutputStream("output.txt");
out = new ObjectOutputStream(fos);
out.writeObject(aOrB ? new A() : new B());
out.close();
fos.close();
} catch (IOException ex) {
ex.printStackTrace();
}
File file = new File("output.txt");
System.out.println(file.length());
}
public static class A implements Serializable {
int a = 0;
}
public static class B implements Serializable {
int a = 0;
public int foo(int a) {
return a;
}
}
}
Per me Questo stampa
48
48
La serializzazione non riflette necessariamente il modo in cui i dati vengono allocati all'interno di una VM in esecuzione. – TofuBeer
L'overhead è ... nessuno.
La definizione del metodo e l'indirizzo del codice sono memorizzati nell'oggetto Class, che ha un'istanza univoca verso cui punta ogni istanza dell'oggetto. In questo caso, indipendentemente dal fatto che tu abbia aggiunto o meno questo metodo, il sovraccarico per ogni singolo oggetto non è nulla.
E non capisco il voto negativo, poiché la risposta è esatta. – Varkhan
Non io, ma questa risposta non è esattamente corretta. C'è un sovraccarico nel mantenimento delle definizioni dei metodi, anche se il sovraccarico è fisso e non dipende dal numero di istanze. Possiamo avere un milione di metodi? Se no, allora esiste un sovraccarico. – Pacerier
Gli oggetti di entrambe le classi utilizzano circa 20-24 byte per JVM a 32/64 bit.
Non è chiamato una funzione. Si chiama metodo. – eleven81
lol, sì, si chiama un metodo, e sarebbe meglio fare un test. –
non è testabile, tranne guardando la sorgente VM, a meno che non si faccia ciò che gli altri stanno facendo e si assuma che il modulo serializzato sia lo stesso del modulo in memoria. – TofuBeer