Java object header

Have you ever wondered what the java objects look like from the inside?
Under the cat there will be a detailed description of the java object header, what it consists of and how much memory it takes.

First, remember that in jvm any object in memory consists of the object header and object variables (links and primitives). Also, the final object size can be expanded so that the size becomes a multiple of 8 bytes.

The title of each object (except for the array) consists of two machine words - mark word and class word . Arrays have an additional 32 bits to describe the length of the array.

Mark word stores identity hashcode, bits used by the garbage collector and bits used for locks. More details can always be found in the corresponding OpenJDK markOop.hpp sorts .

In Class word, a pointer is stored to the class itself, that is, to the place where the information about this data type lies: methods, annotations, inheritance, and more. More details can also always be found in the corresponding OpenJDK klass.hpp sorts .

Let's now take a closer look at the title of the object, and in particular the mark word.

32 bit jvm

As can be seen from the table, the content of Mark word can vary greatly depending on the current state of the object.

Normal state of the object (biased_lock = 0, lock = 01)

• identity_hashcode is a hash of an object that appears lazily. If the object has a System.identityHashCode (obj) call for the first time, this hash will be calculated and written into the object header.
  In other states, when different threads compete for an object, identity_hashcode will no longer be stored in the object header, but in the object monitor.
• age - the number of weathered garbage collections. When age reaches max-tenuring-threshold,
  the object is moved to the heap of the old generation.
• biased_lock - contains 1 if biased locking is enabled for this object, otherwise 0.

• lock - contains the lock state code. 00 - Lightweight Locked, 01 - Unlocked or Biased, 10 - Heavyweight Locked, 11 - Marked for Garbage Collection.

That is, in the table, the state of an object is determined by the combination of the biased_lock and lock bits.

Biased Locked Mode (biased_lock = 1, lock = 01)

• thread - in biased lock mode, it is assumed that the object is primarily owned by a particular thread, the id of this thread is stored in the field.
• epoch contains some temporary indicator of the ownership of an object by a thread whose id is stored in thread

Lightweight Locked Mode (lock = 00)

In this mode, it is assumed that the time taken by this object by different threads does not intersect at all or intersects slightly. In this mode, instead of heavy locks on the operating system, the JVM uses atomics.

• ptr_to_lock_record - to set / wait for a lock, use CAS (compare and set) inside the spin loop.
  For reference, the minimum OS blocking time will be around 10 ms, with the help of atoms the stream does not fall asleep, but continues to thresh a small cycle, and as soon as the resource becomes free, the cycle with the atom will end and the thread will immediately capture this object.

Heavyweight Locked Mode (lock = 10)

• ptr_to_heavyweight_monitor - if the capture time of this object by different threads intersects significantly, then the lightweight lock will be replaced by a heavy weight lock. In ptr_to_heavyweight_monitor will be recorded a pointer to the monitor. OS lock is used.

So, in a 32-bit jvm object header consists of 8 bytes. Arrays are additionally 4 bytes.

64 bit jvm

On a 64-bit jvm, the object header consists of 16 bytes. Arrays are additionally 4 bytes.

64 bit jvm with pointer compression

An object header consists of 12 bytes. Arrays are additionally 4 bytes.

A little bit about pointer compression. For a 32-bit pointer, the address space is limited to 4GB. However, if we recall again that in jvm the size of an object is a multiple of 8 bytes, then we can use a pseudo 35 bit pointer, with three zeros at the end. And, thus, to refer to 32GB of memory. Compression turns out not free, the price - additional operation (pointer << 3) at any appeal to heap.

Link to the original article:

Java Object Header

I would also like to add that everything described here is not a dogma, perhaps in other versions of jvm the title of the object will be different. Described here is relevant for openjdk 8.