(原创)基于Android R之ART虚拟机的创建流程

2021-01-10 1条评论 4,210次阅读 0人点赞

我们知道Android的底层是Linux系统，Android系统运行的APK都是包含的Java代码。要在Linux上运行Java代码，这里就会涉及Java虚拟机创建的过程，Android系统自5.1版本后使用的是ART虚拟机，所以这篇，研究ART虚拟机的创建过程，下面所有分析的代码都是基于Android11_R17进行分析。

Zygote作为Android系统首个运行的Java进程，同时也是App进程的孵化器，可以稍微判断出ART虚拟机的创建会在zygote进程中进行。下面我们就从分析zygote进程出来，来看ART虚拟机的创建流程。zygote启动是在init.zygote64.rc文件中进行的，zygote启动的代码如下

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc reserved_disk
    socket zygote stream 660 root system
    socket usap_pool_primary stream 660 root system
    onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
    ......

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server

class main

priority -20

user root

group root readproc reserved_disk

socket zygote stream 660 root system

socket usap_pool_primary stream 660 root system

onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse

......

service zygote 是rc文件的写法，表示这里启动的是一个service
/system/bin/app_process64 表示启动的二进制进程是/system/bin/app_process64，在手机端查看，/system/bin/app_process64是软连接到/system/bin/app_process的
剩余部分是传递给app_process64的参数

上面一顿分析发现，如果想了解ART虚拟机的启动流程，那么就得看app_process的启动流程了

1. app_process源码分析

app_process是由app_main.cpp编译而来，下面查看具体的实现，我们只关注ART虚拟机的创建部分，其余部分我们就略过

int main(int argc, char* const argv[])
{
    ......
    // 2.1 初始化runtime，这里传递两个参数
    // 首先是argv[0]：可以理解为传递的是argv参数列表的首地址
    // computeArgBlockSize是使用来计算argv所占用的内存大小，因此第二个参数是传递argv所占内存字节数
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    ......
    // 下面是介绍app_process支持的参数
    // --zygote : Start in zygote mode
    // --start-system-server : Start the system server.
    // --application : Start in application (stand alone, non zygote) mode.
    // --nice-name : The nice name for this process.
    ......
    // 参数解析过程
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;
    String8 className;

    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {
    ......
    // 2.2 启动zygote，调用runtime.start方法
    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {   
......    
}

int main(int argc, char* const argv[])

{

......

// 2.1 初始化runtime，这里传递两个参数

// 首先是argv[0]：可以理解为传递的是argv参数列表的首地址

// computeArgBlockSize是使用来计算argv所占用的内存大小，因此第二个参数是传递argv所占内存字节数

AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));

......

// 下面是介绍app_process支持的参数

// --zygote : Start in zygote mode

// --start-system-server : Start the system server.

// --application : Start in application (stand alone, non zygote) mode.

// --nice-name : The nice name for this process.

......

// 参数解析过程

bool zygote = false;

bool startSystemServer = false;

bool application = false;

String8 niceName;

String8 className;

while (i < argc) {

const char* arg = argv[i++];

if (strcmp(arg, "--zygote") == 0) {

zygote = true;

niceName = ZYGOTE_NICE_NAME;

} else if (strcmp(arg, "--start-system-server") == 0) {

......

// 2.2 启动zygote，调用runtime.start方法

if (zygote) {

runtime.start("com.android.internal.os.ZygoteInit", args, zygote);

} else if (className) {

......

}

上述两个地方调用到AppRuntime，第一个是调用其构造，第二个就是调用其start，下面我们分别来看看这两处调用的内容

AppRuntime分析

AppRuntime类的实现也是放在了app_main.cpp中，AppRuntime继承了父类AndroidRuntime，所以要分析AppRuntime的构造，我们同时还要关注其父类AndroidRuntime的构造方法

2.1 AppRutnime构造方法和AndroidRuntime构造方法

// AppRuntime类在app_main.cpp中实现
// 直接调用了父类的构造方法
AppRuntime(char* argBlockStart, const size_t argBlockLength)
    : AndroidRuntime(argBlockStart, argBlockLength)
    , mClass(NULL)
{
}


// AndroidRuntime类在frameworks/base/core/jni/AndroidRuntime.cpp中
AndroidRuntime::AndroidRuntime(char* argBlockStart, const size_t argBlockLength) :
        mExitWithoutCleanup(false),
        mArgBlockStart(argBlockStart),
        mArgBlockLength(argBlockLength)
{
    // 初始化graphics，不是我们关注的内容
    init_android_graphics();

    // Pre-allocate enough space to hold a fair number of options.
    mOptions.setCapacity(20);

    assert(gCurRuntime == NULL);        // one per process
    gCurRuntime = this;
}

// AppRuntime类在app_main.cpp中实现

// 直接调用了父类的构造方法

AppRuntime(char* argBlockStart, const size_t argBlockLength)

: AndroidRuntime(argBlockStart, argBlockLength)

, mClass(NULL)

{

}

// AndroidRuntime类在frameworks/base/core/jni/AndroidRuntime.cpp中

AndroidRuntime::AndroidRuntime(char* argBlockStart, const size_t argBlockLength) :

mExitWithoutCleanup(false),

mArgBlockStart(argBlockStart),

mArgBlockLength(argBlockLength)

{

// 初始化graphics，不是我们关注的内容

init_android_graphics();

// Pre-allocate enough space to hold a fair number of options.

mOptions.setCapacity(20);

assert(gCurRuntime == NULL); // one per process

gCurRuntime = this;

}

从上面的调用流程看，AppRuntime的实现很简单，只是做了graphics的初始化，还没有涉及到任何虚拟机创建的内容，因此我们可以推测，ART虚拟机实际的创建工作会在start方法中进行的。

2.2 runtime.start方法

因为runtime实际的对象是AppRuntime，但是我们发现AppRuntime中是没有实现start方法的，因此我们直接查看AndroidRuntime类的start方法，

// start方法内部的处理流程很多，不过我们只是关注runtime的创建，那么就会省略掉其他的内容
// 如果读者对其他内容也感兴趣的话，可以尝试去查看具体的代码啦
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ......
    /* start the virtual machine */
    // 构造函数初始化
    JniInvocation jni_invocation;
    // 3.1 init方法，这个是需要重点关注的方法之一
    jni_invocation.Init(NULL);
    JNIEnv* env;
    // 3.2 startVM，从方法名就知道这个方法也是需要我们重点关注的
    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
        return;
    }
    // 3.3 虚拟机启动后的处理
    onVmCreated(env);
    ......
}

// start方法内部的处理流程很多，不过我们只是关注runtime的创建，那么就会省略掉其他的内容

// 如果读者对其他内容也感兴趣的话，可以尝试去查看具体的代码啦

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)

{

......

/* start the virtual machine */

// 构造函数初始化

JniInvocation jni_invocation;

// 3.1 init方法，这个是需要重点关注的方法之一

jni_invocation.Init(NULL);

JNIEnv* env;

// 3.2 startVM，从方法名就知道这个方法也是需要我们重点关注的

if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {

return;

}

// 3.3 虚拟机启动后的处理

onVmCreated(env);

......

}

上面的代码中有注释表明，开始启动虚拟机。首先是构造JniInvocation对象，调用流程JniInvocation->JinInvocationCreate->JniInvocationImpl。到最后Impl类中，也只是将类中的成员进行初始化，没有进行特殊的函数调用，所以下面我们还是重点关注Init和startVM这两个方法

ART虚拟机启动的关键

3.1 JniInvocation的Init方法

JniInvocation的Init方法也存在一个简单的调用链：JniInvocation::Init->JniInvocation::JinInvocationInit->JniInvocationImpl::Init，所以最后干活的还是JniInvocationImpl

bool JniInvocationImpl::Init(const char* library) {
#ifdef __ANDROID__
  char buffer[PROP_VALUE_MAX];
#else
  char* buffer = NULL;
#endif
  // GetLibrary返回的是libart.so这个库
  library = GetLibrary(library, buffer);
  // OpenLibrary内部通过dlopne，打开上述libart.so库
  handle_ = OpenLibrary(library);
  ......
  // 下面FindSymbol内部是通过dlsym，获取so库内的方法句柄并保存到对应的方法指针中
  // JNI_GetDefaultJavaVMInitArgs方法的地址存放在JNI_GetDefaultJavaVMInitArgs_指针
  if (!FindSymbol(reinterpret_cast<FUNC_POINTER*>(&JNI_GetDefaultJavaVMInitArgs_),
                  "JNI_GetDefaultJavaVMInitArgs")) {
    return false;
  }

  // JNI_CreateJavaVM方法的地址存放在JNI_CreateJavaVM_指针中
  if (!FindSymbol(reinterpret_cast<FUNC_POINTER*>(&JNI_CreateJavaVM_),
                  "JNI_CreateJavaVM")) {
    return false;
  }

  // JNI_GetCreatedJavaVMs方法的地址存放在JNI_GetCreatedJavaVMs_指针中
  if (!FindSymbol(reinterpret_cast<FUNC_POINTER*>(&JNI_GetCreatedJavaVMs_),
                  "JNI_GetCreatedJavaVMs")) {
    return false;
  }
  return true;
}

bool JniInvocationImpl::Init(const char* library) {

#ifdef __ANDROID__

char buffer[PROP_VALUE_MAX];

#else

char* buffer = NULL;

#endif

// GetLibrary返回的是libart.so这个库

library = GetLibrary(library, buffer);

// OpenLibrary内部通过dlopne，打开上述libart.so库

handle_ = OpenLibrary(library);

......

// 下面FindSymbol内部是通过dlsym，获取so库内的方法句柄并保存到对应的方法指针中

// JNI_GetDefaultJavaVMInitArgs方法的地址存放在JNI_GetDefaultJavaVMInitArgs_指针

if (!FindSymbol(reinterpret_cast<FUNC_POINTER*>(&JNI_GetDefaultJavaVMInitArgs_),

"JNI_GetDefaultJavaVMInitArgs")) {

return false;

}

// JNI_CreateJavaVM方法的地址存放在JNI_CreateJavaVM_指针中

if (!FindSymbol(reinterpret_cast<FUNC_POINTER*>(&JNI_CreateJavaVM_),

"JNI_CreateJavaVM")) {

return false;

}

// JNI_GetCreatedJavaVMs方法的地址存放在JNI_GetCreatedJavaVMs_指针中

if (!FindSymbol(reinterpret_cast<FUNC_POINTER*>(&JNI_GetCreatedJavaVMs_),

"JNI_GetCreatedJavaVMs")) {

return false;

}

return true;

}

Init方法主要的作用是对libart.so文件进行加载和解析，获取so库中的方法句柄留作后用

3.2 startVM方法

int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote, bool primary_zygote)
{
   JavaVMInitArgs initArgs;
    // 前面一大片代码都是都是用来设置ART虚拟机的启动参数的，这里先略过
    ......

    initArgs.version = JNI_VERSION_1_4;
    initArgs.options = mOptions.editArray();
    initArgs.nOptions = mOptions.size();
    initArgs.ignoreUnrecognized = JNI_FALSE;

    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
        ALOGE("JNI_CreateJavaVM failed\n");
        return -1;
    }

    return 0;
}

int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote, bool primary_zygote)

{

JavaVMInitArgs initArgs;

// 前面一大片代码都是都是用来设置ART虚拟机的启动参数的，这里先略过

......

initArgs.version = JNI_VERSION_1_4;

initArgs.options = mOptions.editArray();

initArgs.nOptions = mOptions.size();

initArgs.ignoreUnrecognized = JNI_FALSE;

if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {

ALOGE("JNI_CreateJavaVM failed\n");

return -1;

}

return 0;

}

上面代码中最后调用JNI_CreateJavaVM来创建虚拟机，这里的JNI_CreateJavaVM是在JniInvocation.cpp中进行实现的，其中的实现很简单，就是调用JNI_CreateJavaVM_方法指针，在前一步Init的时候，我们已经从libart.so库中查找到这个方法的句斌，并将其赋值给JNI_CreateJavaVM_。这里绕了一下，但是最后还是会调用到libart.so库的方法。libart.so库中的JNI_CreateJavaVM是在java_vm_ext.cc这个文件中实现的

extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void* vm_args) {
  ScopedTrace trace(__FUNCTION__);
  const JavaVMInitArgs* args = static_cast<JavaVMInitArgs*>(vm_args);
  // 虚拟机参数准备，省略具体的过程
  // ......

  // 3.2.1 调用Runtime::Create方法，这里就是进行Runtime对象的创建的
  if (!Runtime::Create(options, ignore_unrecognized)) {
    return JNI_ERR;
  }

  // 初始化并加载其他系统动态库，需要加载的动态库都定义在/etc/public.libraryies.txt文件中
  android::InitializeNativeLoader();

  // 3.2.2 获取当前runtime对象并调用Start进行启动
  Runtime* runtime = Runtime::Current();
  bool started = runtime->Start();
  if (!started) {
    delete Thread::Current()->GetJniEnv();
    delete runtime->GetJavaVM();
    LOG(WARNING) << "CreateJavaVM failed";
    return JNI_ERR;
  }

  // 保存当前线程和进程的JinEnv和JavaVM对象，JinEnv是每个线程一个，不同线程之间的JinEnv是不同的
  //JavaVM是一个进程只有一个
  *p_env = Thread::Current()->GetJniEnv();
  *p_vm = runtime->GetJavaVM();
  return JNI_OK;
}

extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void* vm_args) {

ScopedTrace trace(__FUNCTION__);

const JavaVMInitArgs* args = static_cast<JavaVMInitArgs*>(vm_args);

// 虚拟机参数准备，省略具体的过程

// ......

// 3.2.1 调用Runtime::Create方法，这里就是进行Runtime对象的创建的

if (!Runtime::Create(options, ignore_unrecognized)) {

return JNI_ERR;

}

// 初始化并加载其他系统动态库，需要加载的动态库都定义在/etc/public.libraryies.txt文件中

android::InitializeNativeLoader();

// 3.2.2 获取当前runtime对象并调用Start进行启动

Runtime* runtime = Runtime::Current();

bool started = runtime->Start();

if (!started) {

delete Thread::Current()->GetJniEnv();

delete runtime->GetJavaVM();

LOG(WARNING) << "CreateJavaVM failed";

return JNI_ERR;

}

// 保存当前线程和进程的JinEnv和JavaVM对象，JinEnv是每个线程一个，不同线程之间的JinEnv是不同的

//JavaVM是一个进程只有一个

*p_env = Thread::Current()->GetJniEnv();

*p_vm = runtime->GetJavaVM();

return JNI_OK;

}

还差最后一小部分了，坚持看下去

3.2.1 Runtime::Create

bool Runtime::Create(const RuntimeOptions& raw_options, bool ignore_unrecognized) {
  RuntimeArgumentMap runtime_options;
  // ParseOptions目的很简单，和其参数方法名一样，就是为了解析参数
  // 但是其内部的代码通过模版类定义一套解析方法，有兴趣的同学可以去看看
  // 我们的重点放在Create方法
  return ParseOptions(raw_options, ignore_unrecognized, &runtime_options) &&
      Create(std::move(runtime_options));
}

bool Runtime::Create(const RuntimeOptions& raw_options, bool ignore_unrecognized) {

RuntimeArgumentMap runtime_options;

// ParseOptions目的很简单，和其参数方法名一样，就是为了解析参数

// 但是其内部的代码通过模版类定义一套解析方法，有兴趣的同学可以去看看

// 我们的重点放在Create方法

return ParseOptions(raw_options, ignore_unrecognized, &runtime_options) &&

Create(std::move(runtime_options));

}

ParseOptions方法目的简单，主要就是用来解析参数的，但是其内部的代码其实相当的复杂，就目前看其实不影响我们分析ART虚拟机的创建，所以我们就先跳过。有兴趣的伙伴可以去查看代码，接着我们分析Create方法的过程

bool Runtime::Create(RuntimeArgumentMap&& runtime_options) {
  // instance_记录当前进程是否已经创建过runtime，如果有就直接退出
  if (Runtime::instance_ != nullptr) {
    return false;
  }
  // 创建Runtime
  instance_ = new Runtime;
  Locks::SetClientCallback(IsSafeToCallAbort);
  // 对Runtime进行Init操作
  if (!instance_->Init(std::move(runtime_options))) {
    instance_ = nullptr;
    return false;
  }
  return true;
}

bool Runtime::Create(RuntimeArgumentMap&& runtime_options) {

// instance_记录当前进程是否已经创建过runtime，如果有就直接退出

if (Runtime::instance_ != nullptr) {

return false;

}

// 创建Runtime

instance_ = new Runtime;

Locks::SetClientCallback(IsSafeToCallAbort);

// 对Runtime进行Init操作

if (!instance_->Init(std::move(runtime_options))) {

instance_ = nullptr;

return false;

}

return true;

}

上面重点还是看Runtime的Init方法，new Runtime主要还是进行变量初始化，不涉及过多的函数调用。Init方法是runtime创建过程中最为核心的函数了。ART虚拟机使用到的大多数模块都会在这里进行初始化。因为函数内容过多，我们只挑出重点的内容进行讲解

// 代码阅读过程中，部分参考来自邓凡平老师的《深入理解ART虚拟机》一书
bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) {
  ......
  // C++的using语法，可以理解为Opt是RUntimeArgumentMap的别名
  using Opt = RuntimeArgumentMap;
  Opt runtime_options(std::move(runtime_options_in));
  ......
  // MemMap初始化，MemMap用于管理内存映射。ART虚拟机内大量的使用了内存映射技术。
  // 比如oat文件记载过程就会使用内存映射将文件内容映射到虚拟机内
  MemMap::Init();
  ......
  // 如其名，OatFileManager是用来管理虚拟机内部的Oat文件的
  oat_file_manager_ = new OatFileManager;

  ......
  // Monitor初始化，Monitor是虚拟机的关键模块，是用来实现线程同步的。
  Monitor::Init(runtime_options.GetOrDefault(Opt::LockProfThreshold),
                runtime_options.GetOrDefault(Opt::StackDumpLockProfThreshold));
  ......
  // 提取传递过来的参数，Init接下来部分有很多这样的初始化动作
  boot_class_path_ = runtime_options.ReleaseOrDefault(Opt::BootClassPath);
  boot_class_path_locations_ = runtime_options.ReleaseOrDefault(Opt::BootClassPathLocations);
  DCHECK(boot_class_path_locations_.empty() ||
         boot_class_path_locations_.size() == boot_class_path_.size());
  if (boot_class_path_.empty()) {
  ......
  // A. MonitorList用于维护一组Monitor对象
  // B. MonitorPool，如其名是个Monitor池，加速创建Monitor对象
  // C. ThreadList用于维护ART内部的线程对象
  // D. InternTable和string intern table有关，是字符串常量池
  monitor_list_ = new MonitorList;
  monitor_pool_ = MonitorPool::Create();
  thread_list_ = new ThreadList(runtime_options.GetOrDefault(Opt::ThreadSuspendTimeout));
  intern_table_ = new InternTable;
  ......
  // 从传递的参数中获取虚拟机对hidden api的策略
  hidden_api_policy_ = runtime_options.GetOrDefault(Opt::HiddenApiPolicy);
  DCHECK(!is_zygote_ || hidden_api_policy_ == hiddenapi::EnforcementPolicy::kDisabled);
  ......
  // 非常关键的地方，ART虚拟机内部Heap模块
  heap_ = new gc::Heap(runtime_options.GetOrDefault(Opt::MemoryInitialSize),
                       ......
                       );

  ......
  // ArenaPool以及LinearAlloc：runtime内部需要创建喝多对象或者存储一些信息，因此虚拟机内部为了更好的管理，设计了
  // A.内存池AreanPool，ArenaPool可管理多个内存单元
  // B.内存分配器LinearAlloc，使用LinearAlloc可在ArenaPool中分配任意大小的内存
  const bool use_malloc = IsAotCompiler();
  if (use_malloc) {
    arena_pool_.reset(new MallocArenaPool());
    jit_arena_pool_.reset(new MallocArenaPool());
  } else {
    arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ false));
    jit_arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ false, "CompilerMetadata"));
  }

  if (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA)) {
    // 4gb, no malloc. Explanation in header.
    low_4gb_arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ true));
  }
  linear_alloc_.reset(CreateLinearAlloc());

  // 接下来的内容是和信号处理有关系。
  // 这里是阻塞SIGPIPE、SIGQUIT和SIGUSER1信号
  BlockSignals();
  // 这里是为某些信号设置自定义的信号处理函数。
  InitPlatformSignalHandlers();
  ......
  // 对运行在目标设备上的ART虚拟机来说，no_sig_chain_取默认值false
  if (!no_sig_chain_) {
    // A. implicit_null_checks_ 是否启用隐式指针检查，此处取值为true
    // B. implicit_so_checks_ 是否启用隐式堆栈溢出检查，此处取值为true
    // C. implicit_suspend_checks_ 是否启用隐式线程暂停检查，此处取值为false
    if (implicit_null_checks_ || implicit_so_checks_ || implicit_suspend_checks_) {
      // FaltManager模块是用于处理SIGSEV信号
      fault_manager.Init();

      if (implicit_suspend_checks_) {
        new SuspensionHandler(&fault_manager);
      }

      if (implicit_so_checks_) {
        new StackOverflowHandler(&fault_manager);
      }

      if (implicit_null_checks_) {
        new NullPointerHandler(&fault_manager);
      }

      if (kEnableJavaStackTraceHandler) {
        new JavaStackTraceHandler(&fault_manager);
      }
    }
  }
  ......
  // 调用JavaVMExt的create方法了，JavaVMExt就是JNI中代表Java虚拟机的对象，其基类为JavaVM，真是
  // 类型是JavaVmExt。根据JNI规范，一个进程只有唯一的一个JavaVM对象。
  java_vm_ = JavaVMExt::Create(this, runtime_options, &error_msg);
  if (java_vm_.get() == nullptr) {
    LOG(ERROR) << "Could not initialize JavaVMExt: " << error_msg;
    return false;
  }
  ......
  // Thread代表ART虚拟机中的线程类
  Thread::Startup();
  Thread* self = Thread::Attach("main", false, nullptr, false);
  ......
  // 创建ClassLinker，这里会分情况创建，但是从代码中可以知道，绝大部分时候IsAotCompiler取值为false的
  // 查看代码可以知道IsAotCompiler是只在dex2oat环境中才有可能取值为true，所以这里的是new ClassLinker
  // ClassLinker是关键的模块，是底层进行class相关处理的地方，例如解析或者查找某个类
  if (UNLIKELY(IsAotCompiler())) {
    class_linker_ = new AotClassLinker(intern_table_);
  } else {
    class_linker_ = new ClassLinker(
        intern_table_,
        runtime_options.GetOrDefault(Opt::FastClassNotFoundException));
  }
  // 接下来就是初始化class_linker_，将一些boot class类加载进去
  if (GetHeap()->HasBootImageSpace()) {
    bool result = class_linker_->InitFromBootImage(&error_msg);
   ......
      class_linker_->AddExtraBootDexFiles(self, std::move(extra_boot_class_path));
   ......
  } else {
    ......
    if (!class_linker_->InitWithoutImage(std::move(boot_class_path), &error_msg)) {
    ......
  CHECK(class_linker_ != nullptr);
  // ClassVerifier模块，用于对classLinker进行校验
  verifier::ClassVerifier::Init(class_linker_);

  // native bridge library加载
  if (IsZygote() && IsPerfettoHprofEnabled()) {
    constexpr const char* plugin_name = kIsDebugBuild ?
    "libperfetto_hprofd.so" : "libperfetto_hprof.so";
    // Load eagerly in Zygote to improve app startup times. This will make
    // subsequent dlopens for the library no-ops.
    dlopen(plugin_name, RTLD_NOW | RTLD_LOCAL);
  }
  // oat_file_manager处理
  if (runtime_options.Exists(Opt::OnlyUseSystemOatFiles)) {
    oat_file_manager_->SetOnlyUseSystemOatFiles();
  }

  return true;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

// 代码阅读过程中，部分参考来自邓凡平老师的《深入理解ART虚拟机》一书

bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) {

......

// C++的using语法，可以理解为Opt是RUntimeArgumentMap的别名

using Opt = RuntimeArgumentMap;

Opt runtime_options(std::move(runtime_options_in));

......

// MemMap初始化，MemMap用于管理内存映射。ART虚拟机内大量的使用了内存映射技术。

// 比如oat文件记载过程就会使用内存映射将文件内容映射到虚拟机内

MemMap::Init();

......

// 如其名，OatFileManager是用来管理虚拟机内部的Oat文件的

oat_file_manager_ = new OatFileManager;

......

// Monitor初始化，Monitor是虚拟机的关键模块，是用来实现线程同步的。

Monitor::Init(runtime_options.GetOrDefault(Opt::LockProfThreshold),

runtime_options.GetOrDefault(Opt::StackDumpLockProfThreshold));

......

// 提取传递过来的参数，Init接下来部分有很多这样的初始化动作

boot_class_path_ = runtime_options.ReleaseOrDefault(Opt::BootClassPath);

boot_class_path_locations_ = runtime_options.ReleaseOrDefault(Opt::BootClassPathLocations);

DCHECK(boot_class_path_locations_.empty() ||

boot_class_path_locations_.size() == boot_class_path_.size());

if (boot_class_path_.empty()) {

......

// A. MonitorList用于维护一组Monitor对象

// B. MonitorPool，如其名是个Monitor池，加速创建Monitor对象

// C. ThreadList用于维护ART内部的线程对象

// D. InternTable和string intern table有关，是字符串常量池

monitor_list_ = new MonitorList;

monitor_pool_ = MonitorPool::Create();

thread_list_ = new ThreadList(runtime_options.GetOrDefault(Opt::ThreadSuspendTimeout));

intern_table_ = new InternTable;

......

// 从传递的参数中获取虚拟机对hidden api的策略

hidden_api_policy_ = runtime_options.GetOrDefault(Opt::HiddenApiPolicy);

DCHECK(!is_zygote_ || hidden_api_policy_ == hiddenapi::EnforcementPolicy::kDisabled);

......

// 非常关键的地方，ART虚拟机内部Heap模块

heap_ = new gc::Heap(runtime_options.GetOrDefault(Opt::MemoryInitialSize),

......

);

......

// ArenaPool以及LinearAlloc：runtime内部需要创建喝多对象或者存储一些信息，因此虚拟机内部为了更好的管理，设计了

// A.内存池AreanPool，ArenaPool可管理多个内存单元

// B.内存分配器LinearAlloc，使用LinearAlloc可在ArenaPool中分配任意大小的内存

const bool use_malloc = IsAotCompiler();

if (use_malloc) {

arena_pool_.reset(new MallocArenaPool());

jit_arena_pool_.reset(new MallocArenaPool());

} else {

arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ false));

jit_arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ false, "CompilerMetadata"));

}

if (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA)) {

// 4gb, no malloc. Explanation in header.

low_4gb_arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ true));

}

linear_alloc_.reset(CreateLinearAlloc());

// 接下来的内容是和信号处理有关系。

// 这里是阻塞SIGPIPE、SIGQUIT和SIGUSER1信号

BlockSignals();

// 这里是为某些信号设置自定义的信号处理函数。

InitPlatformSignalHandlers();

......

// 对运行在目标设备上的ART虚拟机来说，no_sig_chain_取默认值false

if (!no_sig_chain_) {

// A. implicit_null_checks_ 是否启用隐式指针检查，此处取值为true

// B. implicit_so_checks_ 是否启用隐式堆栈溢出检查，此处取值为true

// C. implicit_suspend_checks_ 是否启用隐式线程暂停检查，此处取值为false

if (implicit_null_checks_ || implicit_so_checks_ || implicit_suspend_checks_) {

// FaltManager模块是用于处理SIGSEV信号

fault_manager.Init();

if (implicit_suspend_checks_) {

new SuspensionHandler(&fault_manager);

}

if (implicit_so_checks_) {

new StackOverflowHandler(&fault_manager);

}

if (implicit_null_checks_) {

new NullPointerHandler(&fault_manager);

}

if (kEnableJavaStackTraceHandler) {

new JavaStackTraceHandler(&fault_manager);

}

......

// 调用JavaVMExt的create方法了，JavaVMExt就是JNI中代表Java虚拟机的对象，其基类为JavaVM，真是

// 类型是JavaVmExt。根据JNI规范，一个进程只有唯一的一个JavaVM对象。

java_vm_ = JavaVMExt::Create(this, runtime_options, &error_msg);

if (java_vm_.get() == nullptr) {

LOG(ERROR) << "Could not initialize JavaVMExt: " << error_msg;

return false;

}

......

// Thread代表ART虚拟机中的线程类

Thread::Startup();

Thread* self = Thread::Attach("main", false, nullptr, false);

......

// 创建ClassLinker，这里会分情况创建，但是从代码中可以知道，绝大部分时候IsAotCompiler取值为false的

// 查看代码可以知道IsAotCompiler是只在dex2oat环境中才有可能取值为true，所以这里的是new ClassLinker

// ClassLinker是关键的模块，是底层进行class相关处理的地方，例如解析或者查找某个类

if (UNLIKELY(IsAotCompiler())) {

class_linker_ = new AotClassLinker(intern_table_);

} else {

class_linker_ = new ClassLinker(

intern_table_,

runtime_options.GetOrDefault(Opt::FastClassNotFoundException));

}

// 接下来就是初始化class_linker_，将一些boot class类加载进去

if (GetHeap()->HasBootImageSpace()) {

bool result = class_linker_->InitFromBootImage(&error_msg);

......

class_linker_->AddExtraBootDexFiles(self, std::move(extra_boot_class_path));

......

} else {

......

if (!class_linker_->InitWithoutImage(std::move(boot_class_path), &error_msg)) {

......

CHECK(class_linker_ != nullptr);

// ClassVerifier模块，用于对classLinker进行校验

verifier::ClassVerifier::Init(class_linker_);

// native bridge library加载

if (IsZygote() && IsPerfettoHprofEnabled()) {

constexpr const char* plugin_name = kIsDebugBuild ?

"libperfetto_hprofd.so" : "libperfetto_hprof.so";

// Load eagerly in Zygote to improve app startup times. This will make

// subsequent dlopens for the library no-ops.

dlopen(plugin_name, RTLD_NOW | RTLD_LOCAL);

}

// oat_file_manager处理

if (runtime_options.Exists(Opt::OnlyUseSystemOatFiles)) {

oat_file_manager_->SetOnlyUseSystemOatFiles();

}

return true;

}

好了，这个方法内容真的是非常的多的，简单解释先到这里，JavaVmExt相关介绍，留到下一篇博主再做介绍。回到前面JNI_CreateJavaVM的地方，这里我们就算是介绍完Runtime::Create的相关内容了。接着我们看runtime->Start

3.2.2 Runtime::Start

bool Runtime::Start() {
  ......
  Thread* self = Thread::Current();

  self->TransitionFromRunnableToSuspended(kNative);

  DoAndMaybeSwitchInterpreter([=](){ started_ = true; });

  // 这里IsImageDex2OatEnabled和HasBootImageSpace返回都是true，直接跳过判断
  if (!IsImageDex2OatEnabled() || !GetHeap()->HasBootImageSpace()) {
    ......
  }

  // 初始化Java环境必须的底层so库，这里主要是加载并初始化libicu_jni.so、libjavacore.so和libopenjdk.so库
  // 同时需要注册一些重要的JNI方法， 这个方法有点意思，计划放在下一篇进行分析
  {
    ScopedTrace trace2("InitNativeMethods");
    InitNativeMethods();
  }

  // 初始化intrinsic
 InitializeIntrinsics();

  // 初始化平台黑灰名单
  art::hiddenapi::InitializeCorePlatformApiPrivateFields();

  // 初始化线程组
  InitThreadGroups(self);

  Thread::FinishStartup();

  // 初始化JIT
  if (jit_options_->UseJitCompilation() || jit_options_->GetSaveProfilingInfo()) {
    // Try to load compiler pre zygote to reduce PSS. b/27744947
    std::string error_msg;
    if (!jit::Jit::LoadCompilerLibrary(&error_msg)) {
      LOG(WARNING) << "Failed to load JIT compiler with error " << error_msg;
    }
    CreateJitCodeCache(/*rwx_memory_allowed=*/true);
    CreateJit();
  }

  {
    ScopedObjectAccess soa(self);
    callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kStart);
  }

  // 创建系统classloader
  system_class_loader_ = CreateSystemClassLoader(this);

  // 当前处于zygote进程中
  if (!is_zygote_) {
    .....
  }

  StartDaemonThreads();

  ......

  // 注册profile信息，让ART虚拟机可以收集应用执行的热点函数信息
  if (jit_.get() != nullptr && jit_options_->GetSaveProfilingInfo() &&
      !jit_options_->GetProfileSaverOptions().GetProfilePath().empty()) {
    std::vector<std::string> dex_filenames;
    Split(class_path_string_, ':', &dex_filenames);
    RegisterAppInfo(dex_filenames, jit_options_->GetProfileSaverOptions().GetProfilePath());
  }

  return true;
}

bool Runtime::Start() {

......

Thread* self = Thread::Current();

self->TransitionFromRunnableToSuspended(kNative);

DoAndMaybeSwitchInterpreter([=](){ started_ = true; });

// 这里IsImageDex2OatEnabled和HasBootImageSpace返回都是true，直接跳过判断

if (!IsImageDex2OatEnabled() || !GetHeap()->HasBootImageSpace()) {

......

}

// 初始化Java环境必须的底层so库，这里主要是加载并初始化libicu_jni.so、libjavacore.so和libopenjdk.so库

// 同时需要注册一些重要的JNI方法，这个方法有点意思，计划放在下一篇进行分析

{

ScopedTrace trace2("InitNativeMethods");

InitNativeMethods();

}

// 初始化intrinsic

InitializeIntrinsics();

// 初始化平台黑灰名单

art::hiddenapi::InitializeCorePlatformApiPrivateFields();

// 初始化线程组

InitThreadGroups(self);

Thread::FinishStartup();

// 初始化JIT

if (jit_options_->UseJitCompilation() || jit_options_->GetSaveProfilingInfo()) {

// Try to load compiler pre zygote to reduce PSS. b/27744947

std::string error_msg;

if (!jit::Jit::LoadCompilerLibrary(&error_msg)) {

LOG(WARNING) << "Failed to load JIT compiler with error " << error_msg;

}

CreateJitCodeCache(/*rwx_memory_allowed=*/true);

CreateJit();

}

{

ScopedObjectAccess soa(self);

callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kStart);

}

// 创建系统classloader

system_class_loader_ = CreateSystemClassLoader(this);

// 当前处于zygote进程中

if (!is_zygote_) {

.....

}

StartDaemonThreads();

......

// 注册profile信息，让ART虚拟机可以收集应用执行的热点函数信息

if (jit_.get() != nullptr && jit_options_->GetSaveProfilingInfo() &&

!jit_options_->GetProfileSaverOptions().GetProfilePath().empty()) {

std::vector<std::string> dex_filenames;

Split(class_path_string_, ':', &dex_filenames);

RegisterAppInfo(dex_filenames, jit_options_->GetProfileSaverOptions().GetProfilePath());

}

return true;

}

OK，ART虚拟机启动的流程已简单介绍过，这篇不打算涉及特别多的细节，有涉及的一些细节计划在后面的文章再逐步展开。

Jimmy's Blog

Jimmy Chen

(原创)基于Android R之ART虚拟机的创建流程

1. app_process源码分析

AppRuntime分析

2.1 AppRutnime构造方法和AndroidRuntime构造方法

2.2 runtime.start方法

ART虚拟机启动的关键

3.1 JniInvocation的Init方法

3.2 startVM方法

3.2.1 Runtime::Create

3.2.2 Runtime::Start

赞过：

相关

本作品采用知识共享署名-相同方式共享 4.0 国际许可协议进行许可

发表回复取消回复

Jimmy Chen

1. app_process源码分析

AppRuntime分析

2.1 AppRutnime构造方法和AndroidRuntime构造方法

2.2 runtime.start方法

ART虚拟机启动的关键

3.1 JniInvocation的Init方法

3.2 startVM方法

3.2.1 Runtime::Create

3.2.2 Runtime::Start

赞过：

相关

本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可

发表回复 取消回复

本作品采用知识共享署名-相同方式共享 4.0 国际许可协议进行许可

发表回复取消回复