浅谈java对象结构 对象头 Markword

 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)
 [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

 We assume that stack/thread pointers have the lowest two bits cleared.
ObjectMonitor* monitor() const {
 assert(has_monitor(), "check");
 // Use xor instead of &~ to provide one extra tag-bit check.
 return (ObjectMonitor*) (value() ^ monitor_value);//monitor_value=2,value最右两位为10，因此异或之后最右两位为0
 }
JavaThread* biased_locker() const {
 assert(has_bias_pattern(), "should not call this otherwise");
 return (JavaThread*) ((intptr_t) (mask_bits(value(), ~(biased_lock_mask_in_place | age_mask_in_place | epoch_mask_in_place))));
//~(biased_lock_mask_in_place | age_mask_in_place | epoch_mask_in_place)为11111111111111111111110010000000，计算后的结果中，低10位全部为0;
 }

// Alignment of JavaThread pointers encoded in object header required by biased locking
 enum { biased_lock_alignment = 2 << (epoch_shift + epoch_bits)
//epoch_shift+epoch_bits＝10
 };

void* operator new(size_t size) { return allocate(size, true); }

// ======= Thread ========
// Support for forcing alignment of thread objects for biased locking
void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
 if (UseBiasedLocking) {
 const int alignment = markOopDesc::biased_lock_alignment;//10
 size_t aligned_size = size + (alignment - sizeof(intptr_t));
 void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)
           : os::malloc(aligned_size, flags, CURRENT_PC);
 void* aligned_addr  = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
   ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
   "JavaThread alignment code overflowed allocated storage");
 if (TraceBiasedLocking) {
  if (aligned_addr != real_malloc_addr)
  tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,
      real_malloc_addr, aligned_addr);
 }
 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
 return aligned_addr;
 } else {
 return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)
      : os::malloc(size, flags, CURRENT_PC);
 }
}

 private static Test t1=new Test();
 private Test t2;
 private int a=5;
 private Integer b=7;
 private String c="112";
 private BigDecimal d=new BigDecimal("5");
 private long e=9l;