How to calculate the number of bytes occupied by a Java object

The example in this article describes how to calculate (or estimate) the amount of memory occupied by a Java object. Share it with everyone for your reference. The specific analysis is as follows:

Usually, the premise of the heap memory usage we talk about is based on the background of "general situations". Excluding the following two situations:

In some cases, the JVM does not put the Object into the heap at all. For example: In principle, a small thread-local object exists on the stack, not in the heap.
The size of the memory occupied by the Object depends on the current state of the Object. For example: whether the Object's synchronization lock is in effect, or whether the Object is being recycled.
Let’s first take a look at what a single Object looks like in the heap

In the heap, each object consists of four fields (A, B, C and D), let’s explain them one by one below:

A: Object header, occupying very few bytes, expressing information about the current state of the Object
B: The space occupied by the basic type field (the native field refers to int , boolean, short, etc.)
C: The space occupied by the reference type field (the reference type field refers to the reference of other objects, each reference occupies 4 bytes)
D: The space occupied by the filler (what will be explained later It’s filler)

Below we explain A, B, C and D one by one

A: Object header
In memory, the total space occupied by each object not only includes the declaration within the object The space required by the variable also includes some additional information, such as object header and filler. The function of the "object header" is to record the instance name, ID and instance status of an object (for example, whether the current instance is "reachable", or the status of the current lock, etc.).
In the current JVM version (Hotspot), the number of bytes occupied by the "object header" is as follows:

An ordinary object occupies 8 bytes
An array occupies 12 bytes, including ordinary objects 8 bytes + 4 bytes (array length)

B: Basic type

boolean and byte occupy 1 byte, char and short occupy 2 bytes, int and float occupy 4 bytes, long and double occupy 8 bytes

C: Reference type
Each reference type occupies 4 bytes

D: Filler
In Hotspot, the total space occupied by each object is based on 8 Calculated by multiples, when the total space occupied by the object (object header + declared variables) is less than a multiple of 8, it will be filled in automatically. However, these filled spaces can be called "fillers". Let’s look at a specific example:

An empty object (without any variables declared) occupies 8 bytes -- > The object header occupies 8 bytes
A class that only declares a boolean type variable occupies 16 bytes - -> Object header (8 bytes) + boolean (1 bytes) + filler (7 bytes)
Declares a class with 8 boolean type variables, occupying 16 bytes --> Object header (8 bytes) + boolean (1 bytes) * 8

Through the above examples, it will help us deepen our understanding of Java programming.

For more related articles on how to calculate the number of bytes occupied by a Java object, please pay attention to the PHP Chinese website!