前言

21世紀，安卓虛擬機器正在一步步的走入我們的生活，小到個人部分朋友在電腦上使用安卓虛擬機器玩手遊，大到安卓從業人員在虛擬機器上面跑程式。不得不承認，對於每一位Androider 而言，安卓虛擬機器是我們日常開發中不可或缺的一環，但是關於安卓虛擬機器的一些知識點和小細節你真的完全掌握了麼？本文將就主要包括 dex file, oat file, mirror::Class, ArtField, ArtMethod, DexCache, ClassTable，這一塊內容進行一個簡單的概述和討論，希望新手們多多學習，老手們溫故而知新。

在這裡，歡迎大家在評論區留下您的高見或者是提出疑問、異議，歡迎各位朋友前來討論，互相交流，最後，如果覺得本文寫的不錯的朋友可以點個關注，咱們每日更新高質量Android進階知識，歡迎指正。

dex2oat 觸發場景

dex2oat 的作用：對 dex 檔案進行編譯，根據引數，生成 oat vdex art 檔案。

各種檔案

.dex
主要看下 class_def，class_def 代表的是類的基本資訊，關鍵內容：

• class_idx/superclass_idx：string_id 的索引，類名字串
• interfaces_off：陣列，對應的是實現的介面型別 id
  • type_list -> type_item -> type_idx
• class_data_off：所有成員變數和成員函式資訊
  • 定義、繼承和實現的函式
  • 除了 direct_methods 以外的
  • static, private, constructor
  • direct_methods
  • virtual_methods
  • class_data_item
• code_item 是什麼？
  • code_item 儲存的是 dex 中的位元組碼，用直譯器來執行

DexFile：

DexFile(const uint8_t* base,
          size_t size,
          const uint8_t* data_begin,
          size_t data_size,
          const std::string& location,
          uint32_t location_checksum,
          const OatDexFile* oat_dex_file,
          std::unique_ptr<DexFileContainer> container,
          bool is_compact_dex);
  const Header* const header_;
  const dex::StringId* const string_ids_;
  const dex::TypeId* const type_ids_;
  const dex::FieldId* const field_ids_;
  const dex::MethodId* const method_ids_;
  const dex::ProtoId* const proto_ids_;
  const dex::ClassDef* const class_defs_;

  // If this dex file was loaded from an oat file, oat_dex_file_ contains a
  // pointer to the OatDexFile it was loaded from. Otherwise oat_dex_file_ is
  // null.
  mutable const OatDexFile* oat_dex_file_;
};
 

如果該 dex 是從一個 oat 檔案裡獲取的，DexFile 中還包括一個 oat_dex_file 的指標，指向對於的 oat file。後面 loadClass 時會用到這個指標。

Dex 檔案裡儲存的是符號引用，需要經過一次解析才能拿到最終資訊，比如獲取類的名稱，需要通過 string_id 去 string_data 裡找一下才知道。

DexCache 的存在就是為了避免重複解析。

.odex
DVM 上使用。

.odex 在 dex 檔案前增加了 header 資訊，後面增加了其他 dex 的依賴和一些輔助資訊。

.oat

ART 上使用。

Oat 檔案是一種特殊的 ELF 檔案格式，它包含 dex 檔案編譯得到的機器指令，在 8.0 以下包括原始的 dex 內容，8.0 之後 raw dex 在 quicken 化之後是在 .vdex 裡。

• oat data section 對應的是 dex 檔案相關資訊（8.0 之後在 .vdex 檔案中）
• oat exec section 對應的是 dex 編譯生成的機器指令

.vdex

• VerifierDeps 用於快速校驗 dex 裡 method 合法性
  8.0 增加，目的是減少 dex2oat 時間

dex2oat::Setup()：

		// No need to verify the dex file when we have a vdex file, which means it was already
        // verified.
        const bool verify =
            (input_vdex_file_ == nullptr) && !compiler_options_->AssumeDexFilesAreVerified();
        if (!oat_writers_[i]->WriteAndOpenDexFiles(
            vdex_files_[i].get(),
            verify,
            update_input_vdex_,
            copy_dex_files_,
            &opened_dex_files_map,
            &opened_dex_files)) {
          return dex2oat::ReturnCode::kOther;
        }

如果之前做過 dex2oat，有 vdex 檔案，下次執行 dex2oat 時（比如系統 OTA）就可以省去重新 verify dex 的過程。

類資訊

mirror::Class

// C++ mirror of java.lang.Class
class MANAGED Class final : public Object {
  // Defining class loader, or null for the "bootstrap" system loader.
  HeapReference<ClassLoader> class_loader_;

  // 陣列元素的型別
  // (for String[][][], this will be String[][]). null for non-array classes.
  HeapReference<Class> component_type_;

  // 這個類對應的 DexCache 物件，虛擬機器直接建立的類沒有這個值（陣列、基本型別）
  HeapReference<DexCache> dex_cache_;

  //介面表，包括自己實現的和繼承的
  HeapReference<IfTable> iftable_;

  // 類名，"java.lang.Class" or "[C"
  HeapReference<String> name_;

  HeapReference<Class> super_class_;

  //虛擬函式表，invoke-virtual 呼叫的函式，包括父類的和當前類的
  HeapReference<PointerArray> vtable_;

  //本類定義的非靜態成員，不包括父類的。
  uint64_t ifields_;

  /* [0,virtual_methods_offset_):本類的direct函式
     [virtual_methods_offset_,copied_methods_offset_):本類的virtual函式
     [copied_methods_offset_, ...) 諸如miranda函式等  */
  uint64_t methods_;

  // Static fields length-prefixed array.
  uint64_t sfields_;

  uint32_t access_flags_;
  uint32_t class_flags_;

  // Total size of the Class instance; used when allocating storage on gc heap
  uint32_t class_size_;

  // Tid used to check for recursive <clinit> invocation.
  pid_t clinit_thread_id_;
  static_assert(sizeof(pid_t) == sizeof(int32_t), "java.lang.Class.clinitThreadId size check");

  // ClassDef index in dex file, -1 if no class definition such as an array.
  int32_t dex_class_def_idx_;

  // Type index in dex file.
  int32_t dex_type_idx_;
};

Class 成員變數比較多，重點關注這幾個：

• iftable_:
  • 介面類所對應的 Class 物件
  • 該介面類中的方法。
  • 儲存該類直接實現或間接實現（繼承）的介面資訊
  • 介面資訊包含兩個部分
• vtable_:
  • 儲存該類直接定義或間接定義的 virtual 方法
  • 比如Object類中的wait、notify、toString 等方法
• methods_:
  • 只包含本類直接定義的 direct、virtual 方法和 Miranda 方法
  • 一般 vtable_ 包含內容會多於 methods_
• sfields_ 靜態變數
• ifields_ 例項變數
  • ClassLinker::LoadClass 階段分配記憶體和設定資料

ArtField

class ArtField {
  GcRoot<mirror::Class> declaring_class_;
  uint32_t access_flags_ = 0;

  // 在 dex 中 field_ids 陣列中的索引
  uint32_t field_dex_idx_ = 0；
 //成員變數的offset  
  uint32_t offset_ = 0;
}

一個 ArtField 物件代表類中的一個成員變數。

offset_ 含義：

• 如果是靜態成員變數，offset_ 代表變數的儲存空間在 Class 物件的記憶體佈局裡的起始位置
• 如果是非靜態成員變數，offset_ 代表在 Object 物件的記憶體佈局裡的起始位置

ArtMethod

ArtMethod 代表一個執行在 Android Runtime 中的 Java 側的方法，主要結構：

class ArtMethod {

 protected:
  GcRoot<mirror::Class> declaring_class_;

  std::atomic<std::uint32_t> access_flags_;

  //在 dex file 中的位置
  // Offset to the CodeItem. 
  uint32_t dex_code_item_offset_;
  //在 dex 中 method_id 的 index，通過它獲取名稱等資訊
  uint32_t dex_method_index_;

  /* End of dex file fields. */

  // static/direct method -> declaringClass.directMethods
  // virtual method -> vtable
  // interface method -> ifTable
  uint16_t method_index_;

  // 呼叫一次加一，超過閾值可能會被編譯成本地方法
  uint16_t hotness_count_;

  // Fake padding field gets inserted here.

  // Must be the last fields in the method.
  struct PtrSizedFields {
    //方法入口地址
    void* entry_point_from_quick_compiled_code_;
  } ptr_sized_fields_;
}

這個 entry_point 是在 ClassLinker#LinkCode 時設定的入口，後面執行這個方法時，不論是解釋執行還是以本地機器指令執行，都通過 ArtMethod 的 GetEntryPointFromCompiledCode 獲取入口點。

快取

ClassTable

每個 ClassLoader 有一個 class_table_，它的成員主要是一個 ClassSet vector：

 ClassTable:
  // Lock to guard inserting and removing.
  mutable ReaderWriterMutex lock_;
  // We have a vector to help prevent dirty pages after the zygote forks by calling FreezeSnapshot.
  std::vector<ClassSet> classes_ GUARDED_BY(lock_);

  // Hash set that hashes class descriptor, and compares descriptors and class loaders. Results
  // should be compared for a matching class descriptor and class loader.
  typedef HashSet<TableSlot,
                  TableSlotEmptyFn,
                  ClassDescriptorHashEquals,
                  ClassDescriptorHashEquals,
                  TrackingAllocator<TableSlot, kAllocatorTagClassTable>> ClassSet;

通過 ClassLinker::InsertClass 插入到 ClassTable 中

• ClassLinker::InsertClassTableForClassLoader
  • ClassLinker::RegisterClassLoader 建立 ClassTable

void ClassLinker::RegisterClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
  CHECK(class_loader->GetAllocator() == nullptr);
  CHECK(class_loader->GetClassTable() == nullptr);
  Thread* const self = Thread::Current();
  ClassLoaderData data;
  data.weak_root = self->GetJniEnv()->GetVm()->AddWeakGlobalRef(self, class_loader);
  // Create and set the class table.
  data.class_table = new ClassTable;
  class_loader->SetClassTable(data.class_table);
  // Create and set the linear allocator.
  data.allocator = Runtime::Current()->CreateLinearAlloc();
  class_loader->SetAllocator(data.allocator);
  // Add to the list so that we know to free the data later.
  class_loaders_.push_back(data);
}

呼叫處：

FindClass 時會呼叫 LookupClass 查詢：

ObjPtr<mirror::Class> ClassLinker::LookupClass(Thread* self,
                                               const char* descriptor,
                                               size_t hash,
                                               ObjPtr<mirror::ClassLoader> class_loader) {
  ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
  ClassTable* const class_table = ClassTableForClassLoader(class_loader);
  if (class_table != nullptr) {
    ObjPtr<mirror::Class> result = class_table->Lookup(descriptor, hash);
    if (result != nullptr) {
      return result;
    }
  }
  return nullptr;
}

DexCache

DexCache 儲存的是一個 Dex 裡解析後的成員變數、方法、型別、字串資訊。

// C++ mirror of java.lang.DexCache.
class MANAGED DexCache final : public Object {
  HeapReference<ClassLoader> class_loader_;
  // 對應的 dex 檔案路徑
  HeapReference<String> location_;

  uint64_t dex_file_;                // const DexFile*
  uint64_t preresolved_strings_;     // GcRoot<mirror::String*> array
                                    
  uint64_t resolved_call_sites_;     // GcRoot<CallSite>* array
  
  //field_idx                               
  uint64_t resolved_fields_;         // std::atomic<FieldDexCachePair>*
  uint64_t resolved_method_types_;   // std::atomic<MethodTypeDexCachePair>*
  uint64_t resolved_methods_;        // ArtMethod*,
  uint64_t resolved_types_;          // TypeDexCacheType*
  uint64_t strings_;                 // std::atomic<StringDexCachePair>*

  uint32_t num_preresolved_strings_;   
  uint32_t num_resolved_call_sites_;   
  uint32_t num_resolved_fields_;       
  uint32_t num_resolved_method_types_;  
  uint32_t num_resolved_methods_;      
  uint32_t num_resolved_types_;      
  uint32_t num_strings_;               

}

什麼時候建立和讀取呢？

• 在 ART 中每當一個類被載入時，ART 執行時都會檢查該類所屬的 DEX 檔案是否已經關聯有一個 Dex Cache。如果還沒有關聯，那麼就會建立一個 Dex Cache，並且建立好關聯關係。

DefineClass:

  ObjPtr<mirror::DexCache> dex_cache = RegisterDexFile(*new_dex_file, class_loader.Get());
  if (dex_cache == nullptr) {
    self->AssertPendingException();
    return sdc.Finish(nullptr);
  }
  klass->SetDexCache(dex_cache);

結尾

好了，今天有關安卓虛擬機器的內容就到此為止了，感謝各位看官，喜歡的朋友可以點贊，收藏，評論，當然，如果能給我個關注那就最好不過了，這樣的話就不會錯過我的日更投稿哦，你的支援就是我最大的動力，感謝各位，那麼我們明天見。