源碼分析：Java對象的內存分配

時間  2019-11-26
標籤 源碼 分析 java 對象 內存 分配 欄目 Java 简体版
原文   原文鏈接

　　Java對象的分配，根據其過程，將其分爲快速分配和慢速分配兩種形式，其中快速分配使用無鎖的指針碰撞技術在新生代的Eden區上進行分配，而慢速分配根據堆的實現方式、GC的實現方式、代的實現方式不一樣而具備不一樣的分配調用層次。 
下面就以bytecodeInterpreter解釋器對於new指令的解釋出發，分析實例對象的內存分配過程：html

　1、快速分配

　 1.實例的建立首先須要知道該類型是否被加載和正確解析，根據字節碼所指定的CONSTANT_Class_info常量池索引，獲取對象的類型信息並調用is_unresovled_klass()驗證該類是否被解析過，在建立類的實例以前，必須確保該類型已經被正確加載和解析。java

 CASE(_new): {
        u2 index = Bytes::get_Java_u2(pc+1);
        constantPoolOop constants = istate->method()->constants();
        if (!constants->tag_at(index).is_unresolved_klass()) {

　　2.接下來獲取該類型在虛擬機中的表示instanceKlass(具體能夠參考前文實例探索Java對象的組織結構)　bootstrap

oop entry = constants->slot_at(index).get_oop();
          assert(entry->is_klass(), "Should be resolved klass");
          klassOop k_entry = (klassOop) entry;
          assert(k_entry->klass_part()->oop_is_instance(), "Should be instanceKlass");
          instanceKlass* ik = (instanceKlass*) k_entry->klass_part();

　　3.當類型已經被初始化而且能夠被快速分配時，那麼將根據UseTLAB來決定是否使用TLAB技術(Thread-Local Allocation Buffers，線程局部分配緩存技術)來將分配工做交由線程自行完成。TLAB是每一個線程在Java堆中預先分配了一小塊內存，當有對象建立請求內存分配時，就會在該塊內存上進行分配，而不須要在Eden區經過同步控制進行內存分配。緩存

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
            bool need_zero = !ZeroTLAB;
            if (UseTLAB) {
              result = (oop) THREAD->tlab().allocate(obj_size);
            }
            if (result == NULL) {
              need_zero = true;

　　4.若是不使用TLAB或在TLAB上分配失敗，則會嘗試在堆的Eden區上進行分配。Universe::heap()返回虛擬機內存體系所使用的CollectedHeap，其top_addr()返回的是Eden區空閒塊的起始地址變量_top的地址，end_addr()是Eden區空閒塊的結束地址變量_end的地址。故這裏compare_to是Eden區空閒塊的起始地址，new_top爲使用該塊空閒塊進行分配後新的空閒塊起始地址。這裏使用CAS操做進行空閒塊的同步操做，即觀察_top的預期值，若與compare_to相同，即沒有其餘線程操做該變量，則將new_top賦給_top真正成爲新的空閒塊起始地址值，這種分配技術叫作bump-the-pointer(指針碰撞技術)。app

　　

 retry:
              HeapWord* compare_to = *Universe::heap()->top_addr();
              HeapWord* new_top = compare_to + obj_size;
              if (new_top <= *Universe::heap()->end_addr()) {
                if (Atomic::cmpxchg_ptr(new_top, Universe::heap()->top_addr(), compare_to) != compare_to) {
                  goto retry;
                }
                result = (oop) compare_to;
              }
            }

 

　　5.根據是否須要填0選項，對分配空間的對象數據區進行填0jvm

if (result != NULL) {
              // Initialize object (if nonzero size and need) and then the header
              if (need_zero ) {
                HeapWord* to_zero = (HeapWord*) result + sizeof(oopDesc) / oopSize;
                obj_size -= sizeof(oopDesc) / oopSize;
                if (obj_size > 0 ) {
                  memset(to_zero, 0, obj_size * HeapWordSize);
                }
              }

　　6.根據是否使用偏向鎖，設置對象頭信息，而後設置對象的klassOop引用(這樣對象自己就獲取了獲取類型數據的途徑)ide

if (UseBiasedLocking) {
                result->set_mark(ik->prototype_header());
              } else {
                result->set_mark(markOopDesc::prototype());
              }
              result->set_klass_gap(0);
              result->set_klass(k_entry);

　　7.把對象地址引入棧，並繼續執行下一個字節碼函數

SET_STACK_OBJECT(result, 0);
              UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);

　　8.若該類型沒有被解析，就會調用InterpreterRuntime的_new函數完成慢速分配oop

// Slow case allocation
        CALL_VM(InterpreterRuntime::_new(THREAD, METHOD->constants(), index),
                handle_exception);
        SET_STACK_OBJECT(THREAD->vm_result(), 0);
        THREAD->set_vm_result(NULL);
        UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);

以上就是快速分配的過程，其流程圖以下，關鍵在於快速分配在Eden區所使用的無鎖指針碰撞技術 post

　　　　

　2、慢速分配

　　接下來看看慢速分配是如何進行的： 
　　1.InterpreterRuntime的_new函數定義在/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp中：

IRT_ENTRY(void, InterpreterRuntime::_new(JavaThread* thread, constantPoolOopDesc* pool, int index))
  klassOop k_oop = pool->klass_at(index, CHECK);
  instanceKlassHandle klass (THREAD, k_oop);

  // Make sure we are not instantiating an abstract klass
  klass->check_valid_for_instantiation(true, CHECK);

  // Make sure klass is initialized
  klass->initialize(CHECK);

  oop obj = klass->allocate_instance(CHECK);
  thread->set_vm_result(obj);
IRT_END

　　該函數在進行了對象類的檢查(確保不是抽象類)和對該類型進行初始化後，調用instanceKlassHandle的allocate_instance進行內存分配。 
　　其中instanceKlassHandle類由DEF_KLASS_HANDLE宏進行聲明，注意該類重載了成員訪問運算符」->」，這裏的一系列成員方法的訪問其實是instanceKlass對象的訪問。

 type*    operator -> () const       { return (type*)obj()->klass_part(); }

　　2.因此其實是調用了instanceKlass的allocate_instance()成員函數： 
　　allocate_instance()定義在/hotspot/src/share/vm/oops/instanceKlass.cpp 
　　(1).檢查是否設置了Finalizer函數，獲取對象所需空間的大小

instanceOop instanceKlass::allocate_instance(TRAPS) {
     bool has_finalizer_flag = has_finalizer(); // Query before possible GC
     int size = size_helper();  // Query before forming handle.

　　(2).調用CollectedHeap的obj_allocate()建立一個instanceOop(堆上的對象實例)，並根據狀況註冊Finalizer函數

　　　 KlassHandle h_k(THREAD, as_klassOop());

      instanceOop i;

      i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
      if (has_finalizer_flag && !RegisterFinalizersAtInit) {
        i = register_finalizer(i, CHECK_NULL);
      }
      return i;

　　3.CollectedHeap::ojb_allocate()定義在/hotspot/src/share/vm/gc_interface/CollectedHeap.hpp中，它將轉而調用內聯函數obj_allocate()

　　4.obj_allocate()定義在/hotspot/src/share/vm/gc_interface/CollectedHeap.inline.h中，若當正處於gc狀態時，不容許進行內存分配申請，不然將調用common_mem_allocate_init()進行內存分配並返回得到內存的起始地址，隨後將調用post_allocation_setup_obj()進行一些初始化工做　

oop CollectedHeap::obj_allocate(KlassHandle klass, int size, TRAPS) {
 //...assert
  HeapWord* obj = common_mem_allocate_init(size, false, CHECK_NULL);
  post_allocation_setup_obj(klass, obj, size);
  NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
  return (oop)obj;
}

　　5.common_mem_allocate_init()分爲兩部分，將分別調用common_mem_allocate_noinit()進行內存空間的分配和調用init_obj()進行對象空間的初始化

HeapWord* CollectedHeap::common_mem_allocate_init(size_t size, bool is_noref, TRAPS) {
  HeapWord* obj = common_mem_allocate_noinit(size, is_noref, CHECK_NULL);
  init_obj(obj, size);
  return obj;
}

　　6.common_mem_allocate_noinit()以下： 
　　(1).若使用了本地線程分配緩衝TLAB，則會調用allocate_from_tlab()嘗試從TLAB中分配內存

  HeapWord* result = NULL;
  if (UseTLAB) {
    result = CollectedHeap::allocate_from_tlab(THREAD, size);
    if (result != NULL) {
      assert(!HAS_PENDING_EXCEPTION,
             "Unexpected exception, will result in uninitialized storage");
      return result;
    }
  }

　　(2).不然會調用堆的mem_allocate()嘗試分配

　

  bool gc_overhead_limit_was_exceeded = false;
  result = Universe::heap()->mem_allocate(size,
                                          is_noref,
                                          false,
                                          &gc_overhead_limit_was_exceeded);

　　(3).統計分配的字節數

 if (result != NULL) {
   //...
    THREAD->incr_allocated_bytes(size * HeapWordSize);
    return result;
  }

　　(4).不然說明申請失敗，若在申請過程當中gc沒有超時，則拋出OOM異常

if (!gc_overhead_limit_was_exceeded) {
    // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
    report_java_out_of_memory("Java heap space");

    if (JvmtiExport::should_post_resource_exhausted()) {
      JvmtiExport::post_resource_exhausted(
        JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP,
        "Java heap space");
    }

    THROW_OOP_0(Universe::out_of_memory_error_java_heap());

　　7.對象內存分配後的初始化過程包括兩部分，一個是init_obj()完成對對象內存空間的對齊和填充，一個是post_allocation_setup_obj()對堆上的oop對象進行初始化。 

　　(1).init_obj()：

void CollectedHeap::init_obj(HeapWord* obj, size_t size) {
  assert(obj != NULL, "cannot initialize NULL object");
  const size_t hs = oopDesc::header_size();
  assert(size >= hs, "unexpected object size");
  ((oop)obj)->set_klass_gap(0);
  Copy::fill_to_aligned_words(obj + hs, size - hs);
}

　　hs就是對象頭的大小，fill_to_aligned_words將對象空間除去對象頭的部分作填0處理，該函數定義在/hotspot/src/share/vm/utilities/copy.h中，並轉而調用pd_fill_to_aligned_words()。 
　　pd_fill_to_aligned_words根據不一樣平臺實現，以x86平臺爲例，該函數定義在/hotspot/src/cpu/x86/vm/copy_x86.h中：

static void pd_fill_to_words(HeapWord* tohw, size_t count, juint value) {
#ifdef AMD64
  julong* to = (julong*) tohw;
  julong  v  = ((julong) value << 32) | value;
  while (count-- > 0) {
    *to++ = v;
  }
#else
  juint* to = (juint*)tohw;
  count *= HeapWordSize / BytesPerInt;
  while (count-- > 0) {
    *to++ = value;
  }
#endif // AMD64
}

　　該函數的做用就是先將地址類型轉換，而後把堆的字數轉化爲字節數，再對該段內存進行填值(value = 0)處理

　　(2).post_allocation_setup_obj()調用了post_allocation_setup_common()進行初始化工做，而後調用post_allocation_notify()通知JVMTI和dtrace
　　

void CollectedHeap::post_allocation_setup_obj(KlassHandle klass,
                                              HeapWord* obj,
                                              size_t size) {
  post_allocation_setup_common(klass, obj, size);
  assert(Universe::is_bootstrapping() ||
         !((oop)obj)->blueprint()->oop_is_array(), "must not be an array");
  // notify jvmti and dtrace
  post_allocation_notify(klass, (oop)obj);
}

　　post_allocation_setup_common()以下：

void CollectedHeap::post_allocation_setup_common(KlassHandle klass,
                                                 HeapWord* obj,
                                                 size_t size) {
  post_allocation_setup_no_klass_install(klass, obj, size);
  post_allocation_install_obj_klass(klass, oop(obj), (int) size);
}

　　post_allocation_setup_no_klass_install()根據是否使用偏向鎖，設置對象頭信息等，即初始化oop的_mark字段。post_allocation_install_obj_klass()設置對象實例的klassOop引用，即初始化oop的_metadata(_klass/_compressed_klass)字段 。

　　以上內容就是堆實現無關的慢速分配過程，其流程圖以下： 

　　　　　　　　

　3、堆的分配實現

　　1.mem_allocate將由堆的實現類型定義，以GenCollectedHeap爲例：

HeapWord* GenCollectedHeap::mem_allocate(size_t size,
                                         bool is_large_noref,
                                         bool is_tlab,
                                         bool* gc_overhead_limit_was_exceeded) {
  return collector_policy()->mem_allocate_work(size,
                                               is_tlab,
                                               gc_overhead_limit_was_exceeded);
}

　　2.由以前分析，GenCollectedHeap根據用戶配置有着不一樣的GC策略(默認的和配置UseSerialGC的MarkSweepPolicy、配置UseComcMarkSweepGC和UseAdaptiveSizePolicy的ASConcurrentMarkSweepPolicy、只配置UseComcMarkSweepGC的ConcurrentMarkSweepPolicy)，但這裏，對象內存空間的基本結構和分配的思想是一致的，因此統一由GenCollectorPolicy實現進行分代層級的對象分配操做，但具體的工做將交由各代的實現者來完成。

　　GenCollectedPolicy的mem_allocate_work()函數以下： 
　　(1).gch指向GenCollectedHeap堆，內存分配請求將循環不斷地進行嘗試，直到分配成功或GC後分配失敗

HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
                                        bool is_tlab,
                                        bool* gc_overhead_limit_was_exceeded) {
  GenCollectedHeap *gch = GenCollectedHeap::heap();
  //...
  // Loop until the allocation is satisified,
  // or unsatisfied after GC.
  for (int try_count = 1; /* return or throw */; try_count += 1) {

　　對於佔用空間比較大的對象，若是常常放在新生代，那麼剩餘的內存空間就會很是緊張，將可能會致使新生代內存垃圾回收的頻繁觸發。故若對象的大小超過必定值，那麼就不該該分配在新生代。

　　 //...緊接上面部分
 　　HandleMark hm; // discard any handles allocated in each iteration

    // First allocation attempt is lock-free.
    Generation *gen0 = gch->get_gen(0);

    if (gen0->should_allocate(size, is_tlab)) {
      result = gen0->par_allocate(size, is_tlab);
      if (result != NULL) {
        assert(gch->is_in_reserved(result), "result not in heap");
        return result;
      }
    }

　　若對象應該在新生代上分配，就會調用新生代的par_allocate()進行分配，注意在新生代廣泛是採用複製收集器的，而內存的分配對應採用了無鎖式的指針碰撞技術。

　　(2).在新生代上嘗試無鎖式的分配失敗，那麼就獲取堆的互斥鎖，並嘗試在各代空間內進行內存分配

unsigned int gc_count_before;  // read inside the Heap_lock locked region
    {
      MutexLocker ml(Heap_lock);
     //...
      bool first_only = ! should_try_older_generation_allocation(size);

      result = gch->attempt_allocation(size, is_tlab, first_only);
      if (result != NULL) {
        assert(gch->is_in_reserved(result), "result not in heap");
        return result;
      }

　　其中should_try_older_generation_allocation()以下：

bool GenCollectorPolicy::should_try_older_generation_allocation(
        size_t word_size) const {
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
  return    (word_size > heap_word_size(gen0_capacity))
         || GC_locker::is_active_and_needs_gc()
         || gch->incremental_collection_failed();
}

　　當進行gc前，新生代的空閒空間大小不足以分配對象，或者有線程觸發了gc，或前一次的FullGC是由MinorGC觸發的狀況，都應該再也不嘗試再更高的內存代上進行分配，以保證新分配的對象儘量在新生代空間上。 

　　attempt_allocation()實現以下：

HeapWord* GenCollectedHeap::attempt_allocation(size_t size,
                                               bool is_tlab,
                                               bool first_only) {
  HeapWord* res;
  for (int i = 0; i < _n_gens; i++) {
    if (_gens[i]->should_allocate(size, is_tlab)) {
      res = _gens[i]->allocate(size, is_tlab);
      if (res != NULL) return res;
      else if (first_only) break;
    }
  }
  // Otherwise...
  return NULL;
}

　　即由低內存代向高內存代嘗試分配內存 

　　(3).從各個代空間都找不到可用的空閒內存(或不該該在更高的內存代上分配時)，若是已經有線程觸發了gc，那麼當各代空間還有virtual space可擴展空間可用時，將會嘗試擴展代空間並再次嘗試進行內存分配，有點在gc前想盡一切辦法得到內存的意思。

if (GC_locker::is_active_and_needs_gc()) {
        if (is_tlab) {
          return NULL;  // Caller will retry allocating individual object
        }
        if (!gch->is_maximal_no_gc()) {
          // Try and expand heap to satisfy request
          result = expand_heap_and_allocate(size, is_tlab);
          // result could be null if we are out of space
          if (result != NULL) {
            return result;
          }
        }

　　(4).不然各代已經沒有可用的可擴展空間時，噹噹前線程沒有位於jni的臨界區時，將釋放堆的互斥鎖，以使得請求gc的線程能夠進行gc操做，等待全部本地線程退出臨界區和gc完成後，將繼續循環嘗試進行對象的內存分配

JavaThread* jthr = JavaThread::current();
        if (!jthr->in_critical()) {
          MutexUnlocker mul(Heap_lock);
          // Wait for JNI critical section to be exited
          GC_locker::stall_until_clear();
          continue;
        }

　　(5).若各代沒法分配對象的內存，而且沒有gc被觸發，那麼當前請求內存分配的線程將發起一次gc，這裏將提交給VM一個GenCollectForAllocation操做以觸發gc，當操做執行成功並返回時，若gc鎖已被得到，那麼說明已經由其餘線程觸發了gc，將繼續循環以等待gc完成

VM_GenCollectForAllocation op(size,
                                  is_tlab,
                                  gc_count_before);
    VMThread::execute(&op);
    if (op.prologue_succeeded()) {
      result = op.result();
      if (op.gc_locked()) {
         assert(result == NULL, "must be NULL if gc_locked() is true");
         continue;  // retry and/or stall as necessary
      }

　　不然將等待gc完成，若gc超時則會將gc_overhead_limit_was_exceeded設置爲true返回給調用者，並重置超時狀態，並對分配的對象進行填充處理

　　　 const bool limit_exceeded = size_policy()->gc_overhead_limit_exceeded();
      const bool softrefs_clear = all_soft_refs_clear();
      assert(!limit_exceeded || softrefs_clear, "Should have been cleared");
      if (limit_exceeded && softrefs_clear) {
        *gc_overhead_limit_was_exceeded = true;
        size_policy()->set_gc_overhead_limit_exceeded(false);
        if (op.result() != NULL) {
          CollectedHeap::fill_with_object(op.result(), size);
        }
        return NULL;
      }

　　以上內容就是堆的實現相關、但代/GC實現無關的分配過程，其流程圖概括以下： 

　　　　　　　　

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程