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

This article introduces the relevant knowledge of "which areas is the memory layout of java objects?". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

In the HotSpot virtual machine, the layout of objects in memory is divided into three areas: object headers, instance data, and alignment padding.

1) object header: includes two parts: tag field and type pointer (Note: if it is an array object, it contains three parts):

1) Mark Word (tag field): used to store the data of the object itself at run time. 1 > the amount of memory occupied is consistent with the virtual machine bit length. During operation, considering the space efficiency of JVM, Mark Word is designed as a non-fixed data structure in order to store more effective data. 2 > storing the data of the object itself at run time: hash code (hash) GC generational age (age) lock identification bit: 01 no lock 01 bias lock 00 lightweight lock 10 heavyweight lock bias lock identification bit (biased_lock) 0 no lock 1 lock bias thread ID (JavaThread*) bias timestamp (epoch) description: lock identification bit, The concrete implementation of biased lock identification bit, biased thread ID and so on are all done in the monitor object. The data stored in (ObjectMonitor object in source code) 3 > Mark Word will change with the change of lock log bits, that is, different lock states. Stores different data: lock state stores content lock identification bit is biased towards lock identifier bit (whether it is biased lock)-- -unlocked hash code, GC generation age 01 0 tends to lock thread ID, bias timestamp, GC generation age 01 1 lightweight lock to the pointer of the lock record in the stack 00 the pointer of the weightless lock to monitor 10 No GC tag, no 11, no 2) Class Metadata Address (type pointer): class metadata to the object (Class data in the method area) The virtual machine uses this pointer to determine which class the object is an instance of. 3) if the object is an array type, the length of the array is also stored in the object header.

2) instance data: stores the attribute data information of the class, including the attribute information of the parent class.

3) alignment padding: because the virtual machine requires that the starting address of the object must be an integer multiple of 8 bytes, padding data is not necessary, just for byte alignment.

4) use the JOL (Java Object Layout) tool to view the memory layout of the java object:

Maven dependency: org.openjdk.jol jol-core 0.14 Code: public class TestClassLayout {public static void main (String [] args) {TestClass [] testClassObj = new TestClass [5]; / / View object memory layout System.out.println (ClassLayout.parseInstance (testClassObj) .toPrintable ()) Result: 1 [Lcom.jxn.test.TestClass Object internals: 2 OFFSET SIZE TYPE DESCRIPTION VALUE 3 0 4 (object header) 01 000000 (00000001 00000000 00000000 00000000) (1) 4 4 4 (object header) 00000000 (00000000 00000000 00000000) (0) 5 8 4 (object header) 82 C1 00 f8 (10000010 11000001 00000000 11111000) (- 134168190) 6 12 4 (object header) 05 000000 (00000101 00000000 00000000) (5) 7 16 20 com.jxn.test.TestClass TestClass . Nbytes total A 8 36 4 (loss due to the next object alignment) 9 Instance size: 40 bytes 10 Space losses: 0 bytes internal + 4 bytes external = 4 bytes total object header: line 3 + 4: Mark Word (tag field) line 5: Line 6 of the type pointer: array length instance data: line 7: references to 5 TestClass objects are stored in the array (after pointer compression is enabled The type reference occupies 4 bytes, so it takes up 5 bytes, 4 bytes, and 20 bytes. Alignment padding: line 8: object header + instance data takes up 36 bytes of memory (not an integer multiple of 8), so 4 bytes of alignment padding is required. Total space occupied by the object: line 9 total memory wasted space: line 10: alignment padding consumes 4 bytes. Note: if the length of the array is changed to 6, the memory occupied by the object header + instance data is 40 bytes (a multiple of 8), so there will be no alignment padding: [Lcom.jxn.test.TestClass Object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 01 000000 (00000001 00000000 00000000 00000000) (1) 4 4 (object header) 00000000 (00000000 00000000 00000000) (0) 8 4 (object header) 82 C1 00 f8 (10000010 11000001 00000000 11111000) (- 134168190) 12 4 (object header) 06 000000 (00000110 00000000 00000000 000000) (6) 16 24 com.jxn.test.TestClass TestClass . NCMA Instance size: 40 bytes Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

5) instructions in hotspot/src/share/vm/oops/markOop.hpp source code:

/ / The markOop describes the header of an object.//// Note that the mark is not a real oop but just a word.// It is placed in the oop hierarchy for historical reasons.//// Bit-format of an object header (most significant first Big endian layout below): / 32 bits://-/ / hash:25-> | age:4 biased_lock:1 lock:2 (normal object) / / JavaThread*:23 epoch:2 age:4 biased_lock:1 lock:2 (biased object) / / size:32- -- > | (CMS free block) / / PromotedObject*:29-> | promo_bits:3-> | (CMS promoted object) / 64 bits://-/ / unused:25 hash:31-> | unused:1 age:4 biased_lock:1 lock: 2 (normal object) / / JavaThread*:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 (biased object) / / PromotedObject*:61-> | promo_bits:3-> | (CMS promoted object) / / size:64-- -> | (CMS free block) / unused:25 hash:31-> | cms_free:1 age:4 biased_lock:1 lock:2 (COOPs & & normal object) / / JavaThread*:54 epoch:2 cms_free:1 age:4 biased_lock:1 lock:2 (COOPs & & biased object) / / narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3- -> | (COOPs & & CMS promoted object) / / unused:21 size:35-- > | cms_free:1 unused:7-> | (COOPs & & CMS free block) /-hash contains the identity hash value: largest value is// 31 bits See os::random (). Also, 64-bit vm's require// a hash value no bigger than 32 bits because they will not// properly generate a mask larger than that: see library_call.cpp// and c1_CodePatterns_sparc.cpp.////-the biased lock pattern is used to bias a lock toward a given// thread. When this pattern is set in the low three bits, the lock// is either biased toward a given thread or "anonymously" biased,// indicating that it is possible for it to be biased. When the// lock is biased toward a given thread, locking and unlocking can// be performed by that thread without using atomic operations.// When a lock's bias is revoked, it reverts back to the normal// locking scheme described below.//// Note that we are overloading the meaning of the "unlocked" state// of the header. Because we steal a bit from the age we can// guarantee that the bias pattern will never be seen for a truly// unlocked object.//// Note also that the biased state contains the age bits normally// contained in the object header. Large increases in scavenge// times were seen when these bits were absent and an arbitrary age// assigned to all biased objects, because they tended to consume a// significant fraction of the eden semispaces and were not// promoted promptly, causing an increase in the amount of copying// performed. The runtime system aligns all JavaThread* pointers to// a very large value (currently 128bytes (32bVM) or 256bytes (64bVM)) / / to make room for the age bits & the epoch bits (used in support of// biased locking) And for the CMS "freeness" bit in the 64bVM (+ COOPs). / [JavaThread* | epoch | age | 1 | 01] lock is biased toward given thread// [0 | epoch | age | 1 | 01] lock is anonymously biased////-the two lock bits are used to describe three states: locked/unlocked and monitor.//// [ptr | 00] locked ptr points to Real header on stack// [header | 0 | 01] unlocked regular object header// [ptr | 10] monitor inflated lock (header is wapped out) / / [ptr | 11] marked used by markSweep to mark an object not valid at any other time//// We assume that stack/thread pointers have the lowest two bits cleared. "memory of the java object Which areas is the layout divided into? "this is the end of the introduction. Thank you for your reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

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.