Shulou(Shulou.com)06/01 Report--

This article mainly introduces Java objects in memory space composition and the concept of what is the head of the relevant knowledge, content detailed and easy to understand, simple and fast operation, with a certain reference value, I believe that we read this Java objects in memory space composition and the concept of the head of the object is what the article will be harvested, let's take a look at it.

Object memory composition

Java through the new keyword to create an instance of a class object, the object stored in the heap of memory and assign it a memory address, then have you ever thought about the following problems:

In what form does this instance object exist in memory?

How much does an Object occupy in memory?

How are properties in objects allocated in memory?

In the JVM, Java objects, when stored in the heap, consist of three parts:

Object header: Contains basic information about heap object layout, type, GC state, synchronization state, and identification hash code. Java objects and vm internals have a common object header format.

Instance Data: mainly stores data information of classes, information of parent classes, and attribute information of object fields.

Aligned padding: data padded for byte alignment, not necessary.

object head

A description of Hotspot can be found in the official documentation (below). As you can see, it is a common format for Java objects and virtual machine internal objects, consisting of two words (computer terminology). In addition, if the object is a Java array, there must also be a piece of data in the object header that records the length of the array, because the virtual machine can determine the size of the Java object from the metadata information of the ordinary Java object, but the size of the array cannot be determined from the metadata of the array.

It mentions that the object header consists of two words. What are these two words? We still look up in the official Hotspot document above, and we can find that there are two other definitions of nouns, namely mark word and klass pointer.

The first word is mark word and the second is klass pointer.

Mark Word

Used to store runtime data of the object itself, such as hash code, GC generation age, lock status flag, lock held by thread, biased thread ID, biased timestamp, etc.

Mark Word is 32 bits long in a 32-bit JVM and 64 bits long in a 64-bit JVM. We open the openjdk source package, corresponding to the path/openjdk/hotspot/src/share/vm/oops, Mark Word corresponds to the C++ code markOop.hpp, you can see their composition from the comments, all the code in this article is based on Jdk1.8.

Mark Word stores different contents in different lock states, which is the case in 32-bit JVM

In 64-bit JVMs, this is what happens.

Although they vary in length across different bit JVMs, the basic components are consistent.

Lock flag bit (lock): distinguish lock status, 11 indicates that the object is waiting for GC recovery status, only the last 2 bits of lock identification (11) are valid.

biased_lock: whether biased lock, because the lock flag of no lock and biased lock is 01, there is no way to distinguish, here introduce a one-bit biased lock flag bit.

Generation age: Indicates the number of times an object has been GC, and when the number reaches a threshold, the object will move to an older age.

Object hashcode (hash): Call System.identityHashCode() at runtime to compute, delay computation, and assign the result here. When the object is locked, the calculated result 31 bits is not enough to represent, in bias lock, light lock, weight lock, hashcode will be transferred to Monitor.

Java Thread ID: In biased mode, when a thread holds an object, the object is set to the ID of that thread. There is no need to attempt to acquire the lock in the following operations.

epoch: biased lock During CAS lock operation, biased flag, indicating which lock the object prefers.

ptr_to_lock_record: Pointer to lock record in stack in lightweight lock state. When lock acquisition is contention-free, JVM uses atomic operations rather than OS mutual exclusion. This technique is called lightweight locking. In the case of lightweight locking, the JVM sets a pointer to the lock record in the object's header word through a CAS operation.

ptr_to_heavyweight_monitor: pointer to the object monitor in heavyweight lock state. If two different threads are competing on the same object at the same time, lightweight locking must be escalated to Monitor to manage the waiting threads. In the case of heavyweight locking, the JVM sets a pointer to Monitor in the ptr_to_heavyweight_monitor of the object.

Klass Pointer

A pointer to the metadata of an object's class that the virtual machine uses to determine which class the object is an instance of.

instance data

If the object has attribute fields, there will be data information. If the object has no attribute fields, there will be no data. Different bytes are occupied according to different field types, for example, boolean type occupies 1 byte, int type occupies 4 bytes, etc.;

alignment data

Objects may or may not have alignment data. By default, the starting address of an object in the Java virtual machine heap needs to be aligned to a multiple of 8. If an object uses less than 8N bytes, it needs to be padded to make up for the space remaining after the object header and instance data occupy memory. If the object header and instance data already fill up the memory space allocated by the JVM, there is no need for alignment padding.

The total SIZE of bytes allocated to all objects needs to be a multiple of 8. If the total SIZE occupied by the previous object header and instance data does not meet the requirements, the data is filled by aligning the data.

Why align data? One reason for field memory alignment is to have fields appear only in cache lines of the same CPU. If the fields are not aligned, then there is a possibility of cross-cache line fields. That is, the read of this field may require replacing two cache lines, and the storage of this field may contaminate both cache lines. Both of these situations are detrimental to the efficiency of the execution of the procedure. In fact, the ultimate purpose of filling it is for efficient computer addressing.

At this point, we have seen the overall structural layout of objects in heap memory

Talk is cheap, show me code

Conceptual things are abstract. If you say that they are composed in this way, is it true? Learning requires skepticism, and any theory or concept can only be accepted after it has been proved and practiced by itself. Fortunately, openjdk provides us with a toolkit that can be used to obtain information about objects and virtual machines. We only need to introduce jol-core dependencies, as follows

org.openjdk.jol jol-core 0.8

Jol-core three common methods

ClassLayout.parseInstance(object).toPrintable(): View object internals.

GraphLayout.parseInstance(object).toPrintable(): View information external to an object, including referenced objects.

GraphLayout.parseInstance(object).totalSize(): View total object size.

normal object

To simplify things, let's create a class D ourselves without complex objects. Let's start with no attribute fields.

public class D {}

Through jol-core api, we print out the internal information of the object

public static void main(String[] args) { D d = new D(); System.out.println(ClassLayout.parseInstance(d).toPrintable());}

OFFSET, SIZE, TYPE DESCRIPTION, VALUE are nouns whose meanings are

OFFSET: offset address, unit byte;

SIZE: the size of the memory occupied, in bytes;

TYPE DESCRIPTION: type description, where object header is the object header;

VALUE: corresponds to the value currently stored in memory, binary 32 bits;

It can be seen that the d object instance occupies a total of 16 bytes, the object header occupies 12 bytes (96 bits), of which mark word occupies 8 bytes (64 bits), klass pointe occupies 4 bytes, and the remaining 4 bytes are filled and aligned.

Since pointer compression is enabled by default here, the object header occupies 12 bytes. The specific concept of pointer compression is not described here. Interested readers can consult the official documentation themselves. jdk8 version is the default to enable pointer compression, you can configure vm parameter to enable and disable pointer compression, -XX:-UseCompressed Oops.

If you turn off pointer compression and reprint the memory layout of the object, you can find that the total SIZE has become larger. As you can see from the figure below, the memory size occupied by the object header has changed to 16 bytes (128 bits), of which mark word accounts for 8 bytes, klass pointe accounts for 8 bytes, and there is no alignment filling.

Turning on pointer compression reduces memory usage for objects. From the layout information of the D object printed twice, when the pointer compression is turned off, the SIZE of the object head increases by 4 bytes. Here, since the D object is attribute-free, readers can try to add several attribute fields to see, so that Size will obviously increase. So turning on pointer compression, theoretically speaking, can save about 50% of memory. Pointer compression is enabled by default in jdk8 and later versions, no configuration is required.

array object

The above is the use of ordinary objects, let's look at the memory layout of array objects, compare the similarities and differences

public static void main(String[] args) { int[] a = {1}; System.out.println(ClassLayout.parseInstance(a).toPrintable());}

You can see that the total SIZE is 24 bytes, the object header accounts for 16 bytes, of which Mark Work accounts for 8 bytes, Klass Point accounts for 4 bytes, array length accounts for 4 bytes, because there is only one int type 1, so the instance data of the array object occupies 4 bytes, and the remaining alignment fills occupy 4 bytes.

About "Java object in memory space composition and object head concept is what" the content of this article is introduced here, thank you for reading! I believe that everyone has a certain understanding of the knowledge of "Java object composition in memory space and the concept of object head." If you still want to learn more knowledge, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.