В Java, каков наилучший способ определить размер объекта?

У меня есть приложение, которое читает файл CSV с кучами строк данных. Я даю пользователю сводную информацию о количестве строк на основе типов данных, но хочу убедиться, что я не читаю слишком много строк данных и вызываю OutOfMemoryError. Каждая строка переводится в объект. Есть ли простой способ узнать размер этого объекта программно? Есть ли ссылка, которая определяет, насколько велики примитивные типы и ссылки на объекты для VM?

Прямо сейчас у меня есть код, который читает до 32 000 строк ,, но я также хотел бы иметь код, который читает как можно больше строк, пока я не использовал 32 МБ из Память. Может быть, это другой вопрос, но я все еще хотел бы знать.

ОТВЕТЫ

Ответ 1

Вы можете использовать пакет java.lang.instrument

Скомпилируйте и поместите этот класс в 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);
    }
}

Добавьте в свой MANIFEST.MF следующее:

Premain-Class: ObjectSizeFetcher

Использовать getObjectSize:

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

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

Вызов с помощью:

java -javaagent:ObjectSizeFetcherAgent.jar C

Ответ 2

Вы должны использовать jol, инструмент, разработанный как часть проекта OpenJDK.

JOL (Java Object Layout) - это крошечный инструментарий для анализа схем компоновки объектов в JVM. Эти инструменты используют Unsafe, JVMTI и Serviceability Agent (SA) в значительной степени для декодирования фактического макета объекта, следа и ссылок. Это делает JOL гораздо более точным, чем другие инструменты, опираясь на кучи кучи, спецификации и т.д.

Чтобы получить размеры примитивов, ссылок и элементов массива, используйте VMSupport.vmDetails(). В Oracle JDK 1.8.0_40, работающем на 64-разрядной Windows (используется для всех следующих примеров), этот метод возвращает

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]

Вы можете получить мелкий размер экземпляра объекта с помощью ClassLayout.parseClass(Foo.class).toPrintable() (необязательно передать экземпляр в toPrintable). Это только пространство, потребляемое одним экземпляром этого класса; он не включает никаких других объектов, на которые ссылается этот класс. Он включает в себя накладные расходы VM для заголовка объекта, выравнивания полей и заполнения. Для 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

Вы можете получить сводный вид глубокого размера экземпляра объекта с помощью GraphLayout.parseInstance(obj).toFootprint(). Конечно, некоторые объекты в области отпечатков могут быть разделены (также ссылаются на другие объекты), поэтому это чрезмерное приближение пространства, которое можно было бы вернуть, когда этот объект собирает мусор. Для результата Pattern.compile("^[a-zA-Z0-9_.+-][email protected][a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$") (взятого из этого ответа) jol сообщает об общей глубине 1840 байт, из которых только 72 являются экземпляром Pattern.

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)

Если вы используете GraphLayout.parseInstance(obj).toPrintable(), jol сообщит вам адрес, размер, тип, значение и путь разметки полей для каждого объекта, на который ссылается, хотя обычно это слишком много деталей, чтобы быть полезным. Для текущего примера шаблонов вы можете получить следующее. (Адреса, вероятно, будут меняться между прогонами.)

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)

"(что-то еще)" записи описывают другие объекты в куче, которые не являются частью этого графа объектов.

Лучшая jol-документация - jol samples в репозитории jol. Образцы демонстрируют общие операции jol и показывают, как вы можете использовать jol для анализа внутренних компонентов VM и сборщика мусора.

Ответ 3

Несколько лет назад у Javaworld была статья об определении размера составных и потенциально вложенных объектов Java, они в основном проходят через создание sizeof() реализация на Java. Этот подход в основном основывается на другой работе, где люди экспериментально идентифицируют размер примитивов и типичных объектов Java, а затем применяют эти знания к методу, который рекурсивно ходит по графу объектов для подсчета общего размера.

Он всегда будет несколько менее точным, чем нативная реализация C, просто из-за того, что происходит за кулисами класса, но это должен быть хороший индикатор.

Альтернативно проект SourceForge называется sizeof, который предлагает библиотеку Java5 с реализацией sizeof().

P.S. Не используйте сериализационный подход, нет никакой корреляции между размером сериализованного объекта и объемом памяти, который он потребляет в режиме реального времени.

Ответ 4

Я случайно нашел класс java "jdk.nashorn.internal.ir.debug.ObjectSizeCalculator", уже в jdk, который прост в использовании и представляется весьма полезным для определения размера объекта.

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

результаты:

164192
48
16
48
416

Ответ 5

Во-первых, "размер объекта" не является четко определенной концепцией Java. Вы могли бы означать сам объект, с его членами, объектом и всеми объектами, на которые он ссылается (ссылочный граф). Вы можете указать размер в памяти или размер на диске. И JVM разрешено оптимизировать такие вещи, как Strings.

Поэтому единственный правильный способ - спросить JVM с хорошим профилировщиком (я использую YourKit), который, вероятно, не тот, который вы хотите.

Однако из приведенного выше описания кажется, что каждая строка будет самодостаточной и не имеет большого дерева зависимостей, поэтому метод сериализации, вероятно, будет хорошим приближением для большинства JVM. Самый простой способ сделать это:

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

Помните, что если у вас есть объекты с общими ссылками, это не даст правильного результата, а размер сериализации не всегда будет соответствовать размеру в памяти, но это хорошее приближение. Код будет немного более эффективным, если вы инициализируете размер ByteArrayOutputStream до разумного значения.

Ответ 6

Если вам просто хотелось узнать, сколько памяти используется в вашей JVM, и сколько бесплатно, вы можете попробовать что-то вроде этого:

// 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();

edit: Я думал, что это может быть полезно, поскольку автор вопроса также заявил, что хотел бы иметь логику, которая обрабатывает "чтение как можно большего количества строк, пока я не использовал 32 МБ памяти".

Ответ 7

Когда я работал в Twitter, я написал утилиту для вычисления размера большого объекта. Он учитывает различные модели памяти (32-разрядные, сжатые oops, 64-bit), padding, subclass padding, корректно работает с круговыми структурами данных и массивами. Вы можете просто скомпилировать этот .java файл; он не имеет внешних зависимостей:

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

Ответ 8

Большая часть других ответов предоставляет небольшие размеры - например, размер HashMap без каких-либо ключей или значений, что, скорее всего, не то, что вам нужно.

Проект jamm использует пакет java.lang.instrumentation, описанный выше, но обходит дерево и поэтому может дать вам глубокое использование памяти.

new MemoryMeter().measureDeep(myHashMap);

https://github.com/jbellis/jamm

Чтобы использовать MemoryMeter, запустите JVM с "-javaagent: /jamm.jar"

Ответ 9

Вам нужно пройти объекты, используя отражение. Будьте осторожны, как и вы:

  • Простое выделение объекта имеет несколько накладных расходов в JVM. Сумма зависит от JVM, поэтому вы можете сделать это значение параметром. По крайней мере, сделать его постоянным (8 байтов?) И применить к чему-либо выделенному.
  • Просто потому, что byte теоретически 1 байт не означает, что он занимает только один в памяти.
  • В объектных ссылках будут циклы, поэтому вам нужно будет сохранить HashMap или somesuch используя equal-equals в качестве компаратора для исключения бесконечных циклов.

@jodonnell: Мне нравится простота вашего решения, но многие объекты не являются Serializable (поэтому это порождает исключение), поля могут быть временными, а объекты могут переопределять стандартные методы.

Ответ 10

Вы должны измерить его с помощью инструмента или оценить его вручную, и это зависит от используемой вами JVM.

Существует некоторая фиксированная накладная плата для каждого объекта. Это JVM-специфический, но я обычно оцениваю 40 байт. Затем вам нужно взглянуть на членов класса. Ссылки на объекты - это 4 (8) байта в 32-битной (64-разрядной) JVM. Примитивные типы:

  • boolean и byte: 1 байт
  • char и короткий: 2 байта
  • int и float: 4 байта
  • long и double: 8 байт

Массивы следуют тем же правилам; то есть это ссылка на объект, так что в вашем объекте принимает 4 (или 8) байта, а затем его длина умножается на размер его элемента.

Попытка сделать это программно с помощью вызовов Runtime.freeMemory() просто не дает вам большой точности из-за асинхронных вызовов сборщику мусора и т.д. Профилирование кучи с помощью -Xrunhprof или других инструментов даст вам наиболее точные результаты.

Ответ 11

Я рекомендую библиотеку java-sizeof для поиска моркови. Это очень просто.

Вы можете получить его в maven:

 <dependency>
    <groupId>com.carrotsearch</groupId>
    <artifactId>java-sizeof</artifactId>
    <version>0.0.3</version>
</dependency>

Только одна строка кода возвращает байты объекта:

RamUsageEstimator.sizeOf(new Object());

Исходный код можно увидеть на странице https://github.com/dweiss/java-sizeof

И есть презентация от автора библиотеки http://www.slideshare.net/DawidWeiss/sizeofobject-how-much-memory-objects-take-on-jvms-and-when- this- may- matter? ref = HTTP://cheremin.blogspot.com/2012/05/how-much-memory-objects-take-on-jvm-and.html

Ответ 12

Класс java.lang.instrument.Instrumentation предоставляет хороший способ получить размер Java-объекта, но для этого требуется определить premain и запустить вашу программу с помощью java-агента. Это очень скучно, когда вам не нужен какой-либо агент, а затем вы должны предоставить фиктивный агент Jar для своего приложения.

Итак, я получил альтернативное решение, используя класс Unsafe из sun.misc. Итак, учитывая выравнивание кучи объектов в соответствии с архитектурой процессора и вычисление максимального смещения поля, вы можете измерить размер объекта Java. В приведенном ниже примере я использую вспомогательный класс UtilUnsafe для получения ссылки на объект 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() { }
}

Ответ 13

Существует также инструмент Память > (ранее на Google Code, теперь на GitHub), который прост и опубликован под коммерческой лицензией Apache 2.0, как описано в аналогичный вопрос.

Он также требует аргумент командной строки для интерпретатора java, если вы хотите измерить потребление байта памяти, но в противном случае, похоже, работает нормально, по крайней мере в сценариях, которые я использовал.

Ответ 14

Вот утилита, которую я сделал с помощью некоторых связанных примеров для обработки 32-разрядных, 64-битных и 64-битных со сжатым ООП. Он использует sun.misc.Unsafe.

Он использует Unsafe.addressSize() для получения размера собственного указателя и Unsafe.arrayIndexScale( Object[].class ) для размера ссылки на Java.

Он использует смещение поля известного класса для определения базового размера объекта.

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

Ответ 15

Без необходимости возиться с инструментами и т.д., и если вам не нужно знать байтовый точный размер объекта, вы можете пойти со следующим подходом:

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

do your job here

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

Таким образом, вы читаете использованную память до и после, и вызывая GC перед загрузкой использованной памяти, вы уменьшаете "шум" почти до 0.

Для получения более надежного результата вы можете выполнить свое задание n раз, а затем разделить используемую память на n, получив, сколько занимает память. Более того, вы можете запускать все это больше времени и делать средний.

Ответ 16

Нет вызова метода, если это то, о чем вы просите. С небольшими исследованиями, я полагаю, вы могли бы написать свои собственные. Конкретный экземпляр имеет фиксированный размер, полученный из числа ссылок и примитивных значений, а также учетных данных экземпляра. Вы просто будете ходить по графу объектов. Чем меньше типов строк, тем проще.

Если это слишком медленное или просто больше проблем, чем это стоит, всегда есть хорошее старомодное правило подсчета строк.

Ответ 17

Я написал быстрый тест один раз, чтобы оценить "на лету":

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

}

Общая концепция - выделять объекты и измерять изменение в свободном пространстве кучи. Ключ getFreeMemory(), который запрашивает GC, и ожидает, что указанный размер свободной кучи будет стабилизирован. Выходной сигнал выше:

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

Это то, что мы ожидаем, учитывая поведение выравнивания и возможные потери заголовка блока кучи.

Метод инструментария, подробно описанный в принятом ответе, здесь наиболее точным. Метод, который я описал, является точным, но только в контролируемых условиях, когда другие нити не создают/не отбрасывают объекты.

Ответ 18

Просто используйте Java визуальную виртуальную машину.

В нем есть все, что вам нужно для анализа и отладки памяти.

Он также имеет консоль OQL (Object Query Language), которая позволяет вам делать много полезных вещей, одним из которых является sizeof(o)

Ответ 19

Я искал во время выполнения вычисления размера объекта, который удовлетворял бы следующим требованиям:

  • Доступно во время выполнения без необходимости включать инструментарий.
  • Работает с Java 9+ без доступа к небезопасным.
  • Основан только на классе. Не глубокий sizeOf, который учитывает длину строки, длину массива и т.д.

Нижеследующее основано на основном коде исходной статьи специалистов по Java (https://www.javaspecialists.eu/archive/Issue078.html) и нескольких фрагментах небезопасной версии в другом ответе на этот вопрос.

Я надеюсь, что кто-то найдет это полезным.

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

}

Ответ 20

Мой ответ основан на коде, предоставленном Ником. Этот код измеряет общее количество байтов, которые заняты сериализованным объектом. Таким образом, это на самом деле измеряет размер сериализации + простой объект памяти (просто сериализуйте, например, int, и вы увидите, что общее количество сериализованных байтов не 4). Поэтому, если вы хотите получить необработанный байтовый номер, используемый именно для вашего объекта, вам нужно немного изменить этот код. Например:

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

}

Я тестировал это решение с примитивными типами, String и некоторыми тривиальными классами. Также могут быть и не охвачены случаи.


UPDATE:. Пример изменен для поддержки вычисления размера памяти объектов массива.

Ответ 21

Вы можете создать дамп кучи (например, с помощью jmap), а затем проанализировать вывод, чтобы найти размеры объектов. Это автономное решение, но вы можете изучить мелкие и глубокие размеры и т.д.

Ответ 22

long heapSizeBefore = Runtime.getRuntime().totalMemory();

// Code for object construction
...
long heapSizeAfter = Runtime.getRuntime().totalMemory();
long size = heapSizeAfter - heapSizeBefore;

размер дает вам увеличение использования памяти jvm из-за создания объекта и обычно это размер объекта.

Ответ 23

Этот ответ не связан с размером объекта, но когда вы используете массив для размещения объектов; сколько объема памяти он выделит для объекта.

Таким образом, массивы, список или карта всех этих коллекций не будут храниться на самом деле (только во время примитивов, необходим размер памяти реального объекта), он будет хранить только ссылки для этих объектов.

Теперь Used heap memory = sizeOfObj + sizeOfRef (* 4 bytes) in collection

  • (4/8 байт) зависит от (32/64 бит) ОС

примитивов

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

ПРЕДМЕТЫ

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.

Я хочу сказать, что для всего объекта REFERENCE требуется всего 4 байта памяти. Это может быть ссылка на String OR Double Reference, но зависит от создания объекта. Необходимая память будет меняться.

e.g) Если я создам объект для нижележащего класса ReferenceMemoryTest, тогда будет создано 4 + 4 + 4 = 12 байт памяти. При попытке инициализации ссылок память может отличаться.

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

Итак, когда создается массив объектов/ссылок, все его содержимое будет занято ссылками NULL. И мы знаем, что для каждой ссылки требуется 4 байта.

И, наконец, выделение памяти для кода ниже 20 байтов.

ReferenceMemoryTest ref1 = new ReferenceMemoryTest(); (4 (ref1) + 12 = 16 байт) ReferenceMemoryTest ref2 = ref1; (4 (ref2) + 16 = 20 байт)

Ответ 24

Предположим, я объявляю класс с именем Complex например:

public class Complex {

    private final long real;
    private final long imaginary;

    // omitted
}

Чтобы увидеть, сколько памяти выделено для живых экземпляров этого класса:

$ jmap -histo:live <pid> | grep Complex

 num     #instances         #bytes  class name (module)
-------------------------------------------------------
 327:             1             32  Complex

Ответ 25

Для JSONObject приведенный ниже код может вам помочь.

'JSONObject.toString().getBytes("UTF-8").length'

возвращает размер в байтах

Я проверил его с помощью объекта JSONArray, записав его в файл. Он дает размер объекта.

Ответ 26

Я сомневаюсь, что вы хотите сделать это программно, если вы просто не захотите сделать это один раз и сохранить его для будущего использования. Это дорогостоящая вещь. В Java нет оператора sizeof(), и даже если бы он был, он учитывал бы только стоимость ссылок на другие объекты и размер примитивов.

Один из способов сделать это - сериализовать вещь в файл и посмотреть размер файла, например:

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

Конечно, это предполагает, что каждый объект отличается и не содержит непереходных ссылок на что-либо еще.

Другая стратегия заключалась бы в том, чтобы взять каждый объект и исследовать его членов путем отражения и добавить размеры (логические и байтовые = 1 байт, короткие и char= 2 байта и т.д.), работая по иерархии членства, Но это утомительно и дорого и заканчивается тем же, что и стратегия сериализации.