JVM（二）JVM内存布局

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

// 如果是new操作的时候
CASE(_new): {
        u2 index = Bytes::get_Java_u2(pc+1);
        ConstantPool* constants = istate->method()->constants();
        if (!constants->tag_at(index).is_unresolved_klass()) {
          // Make sure klass is initialized and doesn‘t have a finalizer
　　　　　　// 1. 确保类已经初始化，及类已经加载/验证/准备/解析/初始化完成了。
          Klass* entry = constants->slot_at(index).get_klass();
　　　　　　// 确保类已经被解析
          assert(entry->is_klass(), "Should be resolved klass");
          Klass* k_entry = (Klass*) entry;
　　　　　　// 确保类已经被初始化
          assert(k_entry->oop_is_instance(), "Should be InstanceKlass");
          InstanceKlass* ik = (InstanceKlass*) k_entry;
　　　　　　// 2. 如果类已经初始化并且能够进行快速内存分配
          if ( ik->is_initialized() && ik->can_be_fastpath_allocated() ) {
　　　　　　　 // 获取对象实例的大小
            size_t obj_size = ik->size_helper();
            oop result = NULL;
            // If the TLAB isn‘t pre-zeroed then we‘ll have to do it
　　　　　　　// 如果在TLAB上分配内存，如果TLAB上事先未将内存进行置零处理，则后续在内存分配完毕之后，需要将对象所在的内存进行置零操作
            bool need_zero = !ZeroTLAB;
            if (UseTLAB) {
　　　　　　　　 // 如果开启了线程的TLAB，则直接在线程的TLAB上给对象分配内存，如果分配成功，则返回对象的地址，否则返回null，是否开启TLAB是通过虚拟机参数：-XX:+/-UseTLAB参数来设定，默认是开启的。
              result = (oop) THREAD->tlab().allocate(obj_size);
            }
            // Disable non-TLAB-based fast-path, because profiling requires that all
            // allocations go through InterpreterRuntime::_new() if THREAD->tlab().allocate
            // returns NULL.
#ifndef CC_INTERP_PROFILE
            if (result == NULL) {
　　　　　　　　// 如果在TLAB上未成功分配到内存给对象，则从堆上为对象分配内存
              need_zero = true;
              // Try allocate in shared eden
            retry:
　　　　　　　　// 获取堆顶的地址
              HeapWord* compare_to = *Universe::heap()->top_addr();
　　　　　　　　// 获取分配obj_size字节的内存后，堆顶的位置
              HeapWord* new_top = compare_to + obj_size;
　　　　　　　　// 如果堆顶地址小于或等于堆的最大内存地址，则采用原子操作CAS，将堆顶的地址指向new_top，从而完成内存的分配
              if (new_top <= *Universe::heap()->end_addr()) {
                if (Atomic::cmpxchg_ptr(new_top, Universe::heap()->top_addr(), compare_to) != compare_to) {
                  goto retry;
                }
　　　　　　　　　　// 如果CAS操作成功，则表示内存分配成功，然后把原来堆顶的内存地址赋值给指向对象的引用，即对象的内存地址
                result = (oop) compare_to;
              }
            }
#endif
            if (result != NULL) {
              // Initialize object (if nonzero size and need) and then the header
　　　　　　　　 // 如果对象不为空，且需要置零，则置零处理
              if (need_zero ) {
　　　　　　　　　　// 我们知道，对象的头是不能置零处理的，只有对象的body部分能置零处理，所以跳过对象的头部内存sizeof(oopDesc)/oopSize部分
                HeapWord* to_zero = (HeapWord*) result + sizeof(oopDesc) / oopSize;
                obj_size -= sizeof(oopDesc) / oopSize;
                if (obj_size > 0 ) {
　　　　　　　　　　  // 置零处理
                  memset(to_zero, 0, obj_size * HeapWordSize);
                }
              }
　　　　　　　　　// 如果对象使用偏向锁
              if (UseBiasedLocking) {
                result->set_mark(ik->prototype_header());
              } else {
                result->set_mark(markOopDesc::prototype());
              }
　　　　　　　　// 内存对齐
              result->set_klass_gap(0);
　　　　　　　　// 设置对象的类元数据信息
              result->set_klass(k_entry);
              // Must prevent reordering of stores for object initialization
              // with stores that publish the new object.
              OrderAccess::storestore();
              SET_STACK_OBJECT(result, 0);
　　　　　　　　// 更新PC的指令地址，执行吓一条指令
              UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
            }
          }
        }
        // Slow case allocation
        // 如果未执行快速内存划分，则执行慢速内存划分，可能会采用锁的机制来完成，效率会比较低
        CALL_VM(InterpreterRuntime::_new(THREAD, METHOD->constants(), index),
                handle_exception);
        // Must prevent reordering of stores for object initialization
        // with stores that publish the new object.
        OrderAccess::storestore();
        SET_STACK_OBJECT(THREAD->vm_result(), 0);
        THREAD->set_vm_result(NULL);
        UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
      }