Какое потребление памяти у объекта в Java?

Нет, для регистрации объекта тоже требуется немного памяти. 100 объектов с 1 атрибутом займут больше памяти.

нет, 100 маленьких объектов требует больше информации (памяти), чем один большой.

У каждого объекта есть определенные накладные расходы на связанный с ним монитор и информацию о типе, а также на сами поля. Помимо этого, поля могут быть размещены практически так, как JVM считает нужным (я считаю), но, поскольку показано в другом ответе, по крайней мере, немного JVM будут упакованы довольно плотно. Рассмотрим такой класс:

public class SingleByte
{
    private byte b;
}

против

public class OneHundredBytes
{
    private byte b00, b01, ..., b99;
}

На 32-битной JVM я ожидаю, что 100 экземпляров SingleByte займут 1200 байтов (8 байтов служебных + 4 байта для поля из-за заполнения / выравнивания). Я ожидал, что один экземпляр OneHundredBytes займет 108 байтов - служебные данные, а затем 100 байтов в упаковке. Это, безусловно, может варьироваться в зависимости от JVM - одна реализация может решить не упаковывать поля в OneHundredBytes, что приведет к тому, что она займет 408 байтов (= 8 байтов накладных расходов + 4 * 100 выровненных / дополненных байтов). На 64-битной JVM накладные расходы тоже могут быть больше (не уверен).

Обновлено: см. Комментарий ниже; очевидно, HotSpot ограничивает границы 8 байтами вместо 32, поэтому каждый экземпляр SingleByte будет занимать 16 байтов.

В любом случае «один большой объект» будет по крайней мере так же эффективен, как несколько небольших объектов - для таких простых случаев, как этот.

Mindprod указывает, что на этот вопрос непросто ответить:

A JVM is free to store data any way it pleases internally, big or little endian, with any amount of padding or overhead, though primitives must behave as if they had the official sizes.
For example, the JVM or native compiler might decide to store a boolean[] in 64-bit long chunks like a BitSet. It does not have to tell you, so long as the program gives the same answers.

• It might allocate some temporary Objects on the stack.
• It may optimize some variables or method calls totally out of existence replacing them with constants.
• It might version methods or loops, i.e. compile two versions of a method, each optimized for a certain situation, then decide up front which one to call.

Then of course the hardware and OS have multilayer caches, on chip-cache, SRAM cache, DRAM cache, ordinary RAM working set and backing store on disk. Your data may be duplicated at every cache level. All this complexity means you can only very roughly predict RAM consumption.

Методы измерения

Вы можете использовать Instrumentation.getObjectSize(), чтобы получить оценку хранилища, потребляемого объектом.

Для визуализации компоновки, посадочного места и ссылок объекта действительный можно использовать Инструмент JOL (Java Object Layout).

Заголовки объектов и ссылки на объекты

В современном 64-битном JDK объект имеет 12-байтовый заголовок, дополненный кратным 8 байтам, поэтому минимальный размер объекта составляет 16 байтов. Для 32-битных JVM накладные расходы составляют 8 байтов с дополнениями, кратными 4 байтам. (Из Ответ Дмитрия Спихальского, Ответ Джейен и JavaWorld.)

Обычно ссылки составляют 4 байта на 32-битных платформах или на 64-битных платформах вплоть до -Xmx32G; и 8 байтов выше 32 ГБ (-Xmx32G). (См. ссылки на сжатые объекты.)

В результате 64-битной JVM обычно требуется на 30-50% больше места в куче. (Что мне следует использовать: 32- или 64-битную JVM?, 2012, JDK 1.7)

Упакованные типы, массивы и строки

Упакованные обертки имеют накладные расходы по сравнению с примитивными типами (из JavaWorld):

• Integer: The 16-byte result is a little worse than I expected because an int value can fit into just 4 extra bytes. Using an Integer costs me a 300 percent memory overhead compared to when I can store the value as a primitive type

• Long: 16 bytes also: Clearly, actual object size on the heap is subject to low-level memory alignment done by a particular JVM implementation for a particular CPU type. It looks like a Long is 8 bytes of Object overhead, plus 8 bytes more for the actual long value. In contrast, Integer had an unused 4-byte hole, most likely because the JVM I use forces object alignment on an 8-byte word boundary.

Дорого стоят и другие контейнеры:

• Multidimensional arrays: it offers another surprise.
  Developers commonly employ constructs like int[dim1][dim2] in numerical and scientific computing.

  In an int[dim1][dim2] array instance, every nested int[dim2] array is an Object in its own right. Each adds the usual 16-byte array overhead. When I don't need a triangular or ragged array, that represents pure overhead. The impact grows when array dimensions greatly differ.

  For example, a int[128][2] instance takes 3,600 bytes. Compared to the 1,040 bytes an int[256] instance uses (which has the same capacity), 3,600 bytes represent a 246 percent overhead. In the extreme case of byte[256][1], the overhead factor is almost 19! Compare that to the C/C++ situation in which the same syntax does not add any storage overhead.

• String: a String's memory growth tracks its internal char array's growth. However, the String class adds another 24 bytes of overhead.

  For a nonempty String of size 10 characters or less, the added overhead cost relative to useful payload (2 bytes for each char plus 4 bytes for the length), ranges from 100 to 400 percent.

Выравнивание

Рассмотрим этот пример объекта:

class X {                      // 8 bytes for reference to the class definition
   int a;                      // 4 bytes
   byte b;                     // 1 byte
   Integer c = new Integer();  // 4 bytes for a reference
}

Наивная сумма предполагает, что экземпляр X будет использовать 17 байтов. Однако из-за выравнивания (также называемого заполнением) JVM выделяет память в количестве, кратном 8 байтам, поэтому вместо 17 байтов она будет выделять 24 байта.

Я получил очень хорошие результаты от подхода java.lang.instrument.Instrumentation, упомянутого в другом ответе. Хорошие примеры его использования см. В статье Счетчик памяти КИП из Информационного бюллетеня JavaSpecialists и библиотеки java.sizeOf на SourceForge.

Правила о том, сколько памяти потребляется, зависят от реализации JVM и архитектуры ЦП (например, 32-разрядная версия вместо 64-разрядной).

Чтобы узнать подробные правила для SUN JVM, проверьте мой старый блог

С уважением, Маркус

Если это кому-то будет полезно, вы можете скачать с моего сайта небольшой Агент Java для запроса использования памяти объектом. Это также позволит вам запрашивать "глубокое" использование памяти.

Общий объем используемой / свободной памяти программы можно получить в программе через

java.lang.Runtime.getRuntime();

Среда выполнения имеет несколько методов, связанных с памятью. Следующий пример кодирования демонстрирует его использование.

 public class PerformanceTest {
     private static final long MEGABYTE = 1024L * 1024L;

     public static long bytesToMegabytes(long bytes) {
         return bytes / MEGABYTE;
     }

     public static void main(String[] args) {
         // I assume you will know how to create an object Person yourself...
         List <Person> list = new ArrayList <Person> ();
         for (int i = 0; i <= 100_000; i++) {
             list.add(new Person("Jim", "Knopf"));
         }

         // Get the Java runtime
         Runtime runtime = Runtime.getRuntime();

         // Run the garbage collector
         runtime.gc();

         // Calculate the used memory
         long memory = runtime.totalMemory() - runtime.freeMemory();
         System.out.println("Used memory is bytes: " + memory);
         System.out.println("Used memory is megabytes: " + bytesToMegabytes(memory));
     }
 }

Вопрос будет очень широким.

Это зависит от переменной класса, или вы можете вызвать использование памяти в java.

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

Память кучи, используемая объектом Java, включает

• память для примитивных полей в соответствии с их размером (размеры примитивных типов см. ниже);

• память для справочных полей (по 4 байта);

• заголовок объекта, состоящий из нескольких байтов «служебной» информации;

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

Размер заголовка объекта Java варьируется на 32- и 64-битных jvm.

Хотя это основные потребители памяти, jvm также иногда требует дополнительных полей, например, для выравнивания кода и т. д.

Размеры примитивных типов

логическое и байтовое - 1

char & short - 2

int & float - 4

длинный и двойной - 8

Похоже, что каждый объект имеет накладные расходы в 16 байт в 32-битных системах (и 24 байта в 64-битных системах).

http://algs4.cs.princeton.edu/14analysis/ - хороший источник информации. Среди многих хороших примеров можно привести следующий.

http://www.cs.virginia.edu/kim/publicity/pldi09tutorials/memory-efficient-java-tutorial.pdf тоже очень информативный, например:

Это зависит от архитектуры / jdk. Для современной архитектуры JDK и 64-битной архитектуры объект имеет 12-байтовый заголовок и заполнение на 8 байтов, поэтому минимальный размер объекта составляет 16 байтов. Вы можете использовать инструмент под названием Макет объекта Java, чтобы определить размер и получить подробную информацию о макете объекта и внутренней структуре любого объекта или угадать эту информацию по ссылке на класс. Пример вывода для Integer в моей среде:

Running 64-bit HotSpot VM.
Using compressed oop with 3-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]

java.lang.Integer object internals:
 OFFSET  SIZE  TYPE DESCRIPTION                    VALUE
      0    12       (object header)                N/A
     12     4   int Integer.value                  N/A
Instance size: 16 bytes (estimated, the sample instance is not available)
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

Итак, для Integer размер экземпляра составляет 16 байтов, потому что 4-байтовые int сжимаются на месте сразу после заголовка и перед границей заполнения.

Пример кода:

import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.util.VMSupport;

public static void main(String[] args) {
    System.out.println(VMSupport.vmDetails());
    System.out.println(ClassLayout.parseClass(Integer.class).toPrintable());
}

Если вы используете maven, чтобы получить JOL:

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.3.2</version>
</dependency>

Is the memory space consumed by one object with 100 attributes the same as that of 100 objects, with one attribute each?

Нет.

How much memory is allocated for an object?

• Накладные расходы составляют 8 байтов для 32-разрядной версии, 12 байтов для 64-разрядной версии; а затем округляется до кратного 4 байтам (32-разрядная версия) или 8 байтов (64-разрядная версия).

How much additional space is used when adding an attribute?

• Атрибуты варьируются от 1 байта (байта) до 8 байтов (длинный / двойной), но ссылки имеют размер 4 байта или 8 байтов в зависимости от нет от того, 32-битный он или 64-битный, а скорее от того, является ли -Xmx <32 ГБ или> = 32 ГБ: обычно 64 -bit JVM имеют оптимизацию, называемую "-UseCompressedOops", которая сжимает ссылки до 4 байтов, если размер кучи меньше 32 ГБ.