面试必问的安卓虚拟机,你真的掌握了么?——安卓虚拟机基础知识回顾

·  阅读 195
面试必问的安卓虚拟机,你真的掌握了么?——安卓虚拟机基础知识回顾

前言

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

结尾

好了,今天有关安卓虚拟机的内容就到此为止了,感谢各位看官,喜欢的朋友可以点赞,收藏,评论,当然,如果能给我个关注那就最好不过了,这样的话就不会错过我的日更投稿哦,你的支持就是我最大的动力,感谢各位,那么我们明天见。

分类:
Android
标签:
分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改