android5 libdvm,02-Dalvik虚拟机启动过程

最新推荐文章于 2022-08-07 01:58:43 发布

阿玛粽子

最新推荐文章于 2022-08-07 01:58:43 发布

阅读量524

点赞数

文章标签： android5 libdvm

2.1 init.rc启动脚本

Android系统在启动时，第一个启动的进程就是init进程，也就是我们说的一号进程，我们通过下图的ps命令可以看到init进程号为1。接着，init进程根据读取/init.rc文件中的配置创建并启动app_process进程，也就是我们的Zygote进程,其启动参数见下表所示。

init.rc文件：

…

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

class main

socket zygote stream 660 root system

onrestart write /sys/android_power/request_state wake

onrestart write /sys/power/state on

onrestart restart media

onrestart restart netd

…

上面的文件参数：

service表示Zygote进程是以服务的形式启动；

/system/bin/app_process表示它对应的文件位置；

后面四个选项就是Zygote进程的启动参数，其中—start-system-server表示Zygote进程启动完以后，需要马上运行SystemServer进程。

下面通过ps命令获取当前运行的进程信息

接着我们查看android源码/framework/base/cmds/app_process源码的入口函数main:

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

{ … AppRuntime runtime;

…

bool zygote = false;

bool startSystemServer = false;

bool application = false;

const char* parentDir = NULL;

const char* niceName = NULL;

const char* className = NULL;

while (i < argc) {

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

if (!parentDir) {

parentDir = arg;

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

zygote = true;

niceName = "zygote";

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

startSystemServer = true;

} else if (strcmp(arg, "--application") == 0) {

application = true;

} else if (strncmp(arg, "--nice-name=", 12) == 0) {

niceName = arg + 12;

} else {

className = arg;

break;

}

…

if (zygote) {

//Zygote模式启动(创建Zygote进程和SystemServer进程)

runtime.start("com.android.internal.os.ZygoteInit", startSystemServer ? "start-system-server" : "");

} else if (className) {

//非Zygote模式启动(创建应用程序的进程)

// Remainder of args get passed to startup class main()

runtime.mClassName = className;

runtime.mArgC = argc - i;

runtime.mArgV = argv + i;

runtime.start("com.android.internal.os.RuntimeInit", application ? "application" : "tool");

} else {

fprintf(stderr, "Error: no class name or --zygote supplied.\n");

app_usage();

LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");

return 10;

}

通过init.rc中Zygote的启动参数，我们知道arg参数中包含了” --zygote”和”--zygote --start-system-server”参数。所以,zygote和startSystemServer变量都为true。这表示Zygote进程启动完以后，会接着启动SystemServer进程。

从上面的代码，我们知道Zygote分两种模式启动，分别是Zygote模式和非Zygote模式。当处于Zygote模式时，系统会调用com.android.internal.os.ZygoteInit启动Zygote进程和SystemServer进程；当处于非Zygote模式时，系统会调用com.android.internal.os.RuntimeInit创建应用程序的进程。

2.2 创建Zygote进程

下面，我们来分析下Zygote进程的启动过程。我们看下AndroidRuntime类的start方法的关键代码：

位置：Android源码/base/core/jni/AndroidRuntime.cpp

void AndroidRuntime::start(const char* className, const char* options)

{ … //加载libdvm.so JniInvocation jni_invocation; jni_invocation.Init(NULL); … //创建Dalvik虚拟机 if (startVm(&mJavaVM, &env) != 0) {

return;

}

…

//注册Android核心类的JNI方法

if (startReg(env) < 0) {

ALOGE("Unable to register all android natives\n");

return;

}

…

jclass stringClass;

jobjectArray strArray;

jstring classNameStr;

jstring optionsStr;

stringClass = env->FindClass("java/lang/String");

assert(stringClass != NULL);

strArray = env->NewObjectArray(2, stringClass, NULL);

assert(strArray != NULL);

classNameStr = env->NewStringUTF(className);

assert(classNameStr != NULL);

env->SetObjectArrayElement(strArray, 0, classNameStr);

optionsStr = env->NewStringUTF(options);

env->SetObjectArrayElement(strArray, 1, optionsStr);

//调用com.android.internal.os.ZygoteInit的main方法(进入Java层)

char* slashClassName = toSlashClassName(className);

jclass startClass = env->FindClass(slashClassName);

if (startClass == NULL) {

ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);

/* keep going */

} else {

jmethodID startMeth = env->GetStaticMethodID(startClass, "main",

"([Ljava/lang/String;)V");

if (startMeth == NULL) {

ALOGE("JavaVM unable to find main() in '%s'\n", className);

/* keep going */

} else {

env->CallStaticVoidMethod(startClass, startMeth, strArray);

}

…

}

该方法主要做了4个工作：

(1) 调用jni_invocation.Init()方法加载libdvm.so，并初始化JniInvocation类的成员

(2) 调用startVM()方法创建虚拟机，并初始化BootClassloader和加载/system/framework下的jar包

(3) 调用startReg()方法注册Android核心类的JNI方法

(4) 最后，通过JNI机制进入Java层的com.android.internal.os.ZygoteInit类的main方法，然后创建Zygote进程的Server端Socket，并启动SystemServer进程。

其关键流程如下图所示：

下面我们分别对上面4个工作进一步分析。

2.2.1 加载libdvm.so

参考[7]

位置：Android源码/libnativehelper/JniInvocation.cpp

我们看下JniInvocation类下的Init方法：

…

JniInvocation::JniInvocation() :

handle_(NULL),

JNI_GetDefaultJavaVMInitArgs_(NULL),

JNI_CreateJavaVM_(NULL),

JNI_GetCreatedJavaVMs_(NULL) { LOG_ALWAYS_FATAL_IF(jni_invocation_ != NULL, "JniInvocation instance already initialized"); jni_invocation_ = this; } … bool JniInvocation::Init(const char* library) { … #ifdef HAVE_ANDROID_OS static const char* kLibrarySystemProperty = "persist.sys.dalvik.vm.lib"; #endif static const char* kLibraryFallback = "libdvm.so"; bool JniInvocation::Init(const char* library) {

#ifdef HAVE_ANDROID_OS

char default_library[PROPERTY_VALUE_MAX];

property_get(kLibrarySystemProperty, default_library, kLibraryFallback);

#else

const char* default_library = kLibraryFallback;

#endif

if (library == NULL) {

library = default_library;

} … if (!FindSymbol(reinterpret_cast(&JNI_GetDefaultJavaVMInitArgs_), "JNI_GetDefaultJavaVMInitArgs")) {

return false;

}

if (!FindSymbol(reinterpret_cast(&JNI_CreateJavaVM_),"JNI_CreateJavaVM")) {

return false;

}

if (!FindSymbol(reinterpret_cast(&JNI_GetCreatedJavaVMs_),"JNI_GetCreatedJavaVMs")) {

return false;

}

return true;

}

我们首先看下JniInvocation类的定义，一共有4个成员，分别是handle_，用于保存dlopen加载libdvm.so后返回的文件句柄，以及JNI_GetDefaultJavaVMInitArgs_、JNI_CreateJavaVM_和JNI_GetCreatedJavaVMs_。

接下来继续分析Init方法。Init方法首先读取”persist.sys.dalvik.vm.lib”系统属性，该属性值可能是libdvm.so或libart.so，我们可以通过getprop命令后去persist.sys.dalvik.vm.lib属性的值，或者直接查看/system/build.prop文件。如下图，在Android4.4.3下默认还是libdvm.so，但用户可以通过在Settings=>Developer Options=>Select runtime来选择要Dalvik还是ART，如下图所示。而在Android5.0版本以后，则默认是ART。这里我们默认分析Dalvik。接下来，则调用dlopen加载libdvm.so，然后找到GetDefaultJavaVMInitArgs、CreateJavaVM和GetCreatedJavaVMs三个接口并赋值给JniInvocation类对应的3个成员。

我们可以看到，Init方法其实就是初始化JniInvocation类里面的成员，和初始化Dalvik虚拟机环境的。

获取persist.sys.dalvik.vm.lib属性的值。

TODO：了解JNI的环境

2.2.2 创建Dalvik虚拟机和初始化BootClassloader

完成JNI环境的初始化工作后，接着AndroidRuntime::start函数()调用startVM()方法创建虚拟机。我们看下startVM的代码：

位置：Android源码/base/core/jni/AndroidRuntime.cpp

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

{ …

JavaVMInitArgs initArgs;

JavaVMOption opt;

…

property_get("dalvik.vm.checkjni", propBuf, "");

…

property_get("dalvik.vm.execution-mode", propBuf, "");

…

property_get("dalvik.vm.stack-trace-file", stackTraceFileBuf, "");

…

property_get("dalvik.vm.check-dex-sum", propBuf, "");

…

property_get("dalvik.vm.heapsize", heapsizeOptsBuf+4, "16m");

…

property_get("dalvik.vm.stack-trace-file", stackTraceFileBuf, "");

…

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

}

startVM方法先是读取系统属性并设置Dalvik虚拟机的各项参数，然后才调用JNI_CreateJavaVM方法真正去创建Dalvik虚拟机。这些参数我们也可以通过getprop命令去获取，如下图所示。

而JNI_CreateJavaVM方法正式livdvm.so中的函数。

位置：Android源码/dalvik/vm/jni.cpp。

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

…

//初始化JavaVM变量

JavaVMExt* pVM = (JavaVMExt*) calloc(1, sizeof(JavaVMExt));

pVM->funcTable = &gInvokeInterface;

pVM->envList = NULL;

dvmInitMutex(&pVM->envListLock);

…

//初始化JNI环境(初始化JNIEnv变量)

JNIEnvExt* pEnv = (JNIEnvExt*) dvmCreateJNIEnv(NULL);

//初始化Dalvik虚拟机

gDvm.initializing = true;

std::string status = dvmStartup(argc, argv.get(), args->ignoreUnrecognized, (JNIEnv*)pEnv);

gDvm.initializing = false; …

}

JNI_CreateJavaVM首先初始化JavaVM和JNIEnv变量，完成JNI环境的初始化工作。接着调用创建虚拟机的核心方法dvmStartup()方法。我们看下dvmStartup()方法的源码：

位置：Android源码/dalvik/vm/Init.cpp

std::string dvmStartup(int argc, const char* const argv[],

bool ignoreUnrecognized, JNIEnv* pEnv)

{

…

//解析参数

int cc = processOptions(argc, argv, ignoreUnrecognized);

…

//初始化BootClassLoader

if (!dvmClassStartup()) {

return "dvmClassStartup failed";

}

dvmStartup首先对参数进行解析，然后做了很多其它工作，这里我们重点分析dvmClassStartup()方法，该方法初始化boot class loader，并加载bootclasspath路径下所有的jar包，也就是/system/framework下所有的类。也就是说Zygote进程加载了framework下所有的jar包，而由于app进程的创建是通过克隆Zygote进程的，所以说app也同样加载了所有的framework下的包。下图是BOOTCLASSPATH路径：

我们分析下dvmClassStartup()方法：

位置：Android源码/dalvik/vm/oo/Class.cpp

bool dvmClassStartup()

{ …

//loadedClasses是哈希表，保存所有已经加载了的类

gDvm.loadedClasses = dvmHashTableCreate(256, (HashFreeFunc) dvmFreeClassInnards);

…

//加载bootclasspath路径下的所有jar包

processClassPath(gDvm.bootClassPathStr, true); …

}

gDvm全局变量的loadedClasses成员是哈希表，保存了所有加载到内存中的类。

dvmClassStartup方法调用processClassPath函数进行/system/framework目录下jar包的加载工作。该方法其实就是调用加载解析dex或jar包的方法，我们会在xxx章详细介绍。

2.2.3 framework层资源加载过程

TODO：分析processClassPath加载framework资源过程

3.2.4 通过反射进入ZygoteInit类的main方法

接下来我们分析com.android.internal.os.ZygoteInit的main方法。

位置：Android源码/framework/base/core/java/com/android/internal/os/ZygoteInit.java

public static void main(String argv[]) {

…

registerZygoteSocket();

…

if (argv[1].equals("start-system-server")) {

startSystemServer();

}

…

runSelectLoop();

…

}

该main方法主要做了3件事：

(1) 注册创建Zygote进程的Server端Socket

(2) 启动SystemServer进程

(3) 进入消息循环，监听来自AMS发送过来的创建app进程的请求

2.3 创建Zygote进程Server端监听服务

Zygote进程创建Server端Socket关键流程如下图所示：

我们从ZygoteInit类main方法的registerZygoteSocket函数源码源码开始分析：

位置：Android源码/framework/base/core/java/com/android/internal/os/ZygoteInit.java

private static void registerZygoteSocket() {

if (sServerSocket == null) {

int fileDesc;

try {

String env = System.getenv(ANDROID_SOCKET_ENV);

fileDesc = Integer.parseInt(env);

} catch (RuntimeException ex) {

…

}

try {

sServerSocket = new LocalServerSocket(createFileDescriptor(fileDesc));

} catch (IOException ex) {

…

}

可以看到registerZygoteSocket方法通过LocalServerSocket创建Server端Socket，并保存在ZygoteInit类的静态成员变量sServerSocket中。

接着，判断传递过来的参数是否包含”start-system-server”。我们从上面源码分析知道，Zygote启动的配置参数里面是包含该参数的。然后就调用startSystemServer来启动SystemServer进程。最后调用runSelectLoop方法进入消息循环，等待处理来自AMS发送过来的请求。

我们分析下runSelectLoop方法接收到创建app请求后的过程是怎样的。

位置：Android源码/framework/base/core/java/com/android/internal/os/ZygoteInit.java

private static void runSelectLoop() throws MethodAndArgsCaller { … while (true) {

int index;

…

if (index < 0) {

…

} else if (index == 0) {

…

} else {

boolean done;

done = peers.get(index).runOnce();

i…

}

… }

}

这里，peers.get(index)返回的是ZygoteConnection对象，runSelectLoop方法实际上调用了ZygoteConnection对象的runOnce方法做进一步的处理。

位置：Android源码/framework/base/core/java/com/android/internal/os/ZygoteConnection.java

class ZygoteConnection {

…

boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {

String args[];

Arguments parsedArgs = null;

…

int pid = -1;

…

pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,

parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,

parsedArgs.niceName);

…

if (pid == 0) {

// in child

IoUtils.closeQuietly(serverPipeFd);

serverPipeFd = null;

handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);

return true;

}

… }

}

这里真正创建应用程序进程的操作是Zygote.forkAndSpecialize方法，当创建成功以后，就会调用handleChildProc来启动新创建的应用程序的进程。详细的分析我们会在3.5节讲解。

2.4 创建SystemServer进程

在3.2.3节，main入口函数调用了startSystemServer来启动SystemServer进程。SystemServer在这个过程中做了一件很重要的事情：

启动重要的系统服务，如ActivityManagerService、PackageManagerService、WindowManagerService等。

它创建SystemServer的关键流程如下图所示。

下面我们一个个分析这些关键函数。

位置：Android源码/framework/base/core/java/com/android/internal/os/ZygoteInit.java

private static boolean startSystemServer() throws MethodAndArgsCaller, RuntimeException {

long capabilities = posixCapabilitiesAsBits(

OsConstants.CAP_KILL,

OsConstants.CAP_NET_ADMIN,

OsConstants.CAP_NET_BIND_SERVICE,

OsConstants.CAP_NET_BROADCAST,

OsConstants.CAP_NET_RAW,

OsConstants.CAP_SYS_MODULE,

OsConstants.CAP_SYS_NICE,

OsConstants.CAP_SYS_RESOURCE,

OsConstants.CAP_SYS_TIME,

OsConstants.CAP_SYS_TTY_CONFIG

);

/* Hardcoded command line to start the system server */

String args[] = {

"--setuid=1000",

"--setgid=1000",

"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",

"--capabilities=" + capabilities + "," + capabilities,

"--runtime-init",

"--nice-name=system_server",

"com.android.server.SystemServer",

};

ZygoteConnection.Arguments parsedArgs = null;

int pid;

try {

parsedArgs = new ZygoteConnection.Arguments(args);

…

//调用forkSystemServer方法创建SystemServer进程

pid = Zygote.forkSystemServer(

parsedArgs.uid, parsedArgs.gid,

parsedArgs.gids,

parsedArgs.debugFlags,

null,

parsedArgs.permittedCapabilities,

parsedArgs.effectiveCapabilities);

} catch (IllegalArgumentException ex) {

throw new RuntimeException(ex);

}

//启动SystemServer进程

if (pid == 0) {

handleSystemServerProcess(parsedArgs);

}

return true;

}

首先创建参数数组，然后传递给forkSystemServer方法并创建SystemServer进程。创建成功后，接着调用handleSystemServerProcess方法来启动SystemServer进程。

SystemServer进程启动后，就会启动各种系统服务，如AMS、PMS、WMS等。

我们接着分析handleSystemServerProcess方法。

位置：Android源码/framework/base/core/java/com/android/internal/os/ZygoteInit.java

private static void handleSystemServerProcess(

ZygoteConnection.Arguments parsedArgs)

throws ZygoteInit.MethodAndArgsCaller {

…

if (parsedArgs.invokeWith != null) {

…

} else {

RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);

}

handleSystemServerProcess调用RuntimeInit类的zygoteInit方法。

位置：Android源码/framework/base/core/java/com/android/internal/os/RuntimeInit.java

public static final void zygoteInit(int targetSdkVersion, String[] argv)

throws ZygoteInit.MethodAndArgsCaller {

if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");

redirectLogStreams();

commonInit();

nativeZygoteInit();

applicationInit(targetSdkVersion, argv);

}

这里zygoteInit调用了一个重要的方法applicationInit方法。

位置：Android源码/framework/base/core/java/com/android/internal/os/RuntimeInit.java

private static void applicationInit(int targetSdkVersion, String[] argv)

throws ZygoteInit.MethodAndArgsCaller {

…

final Arguments args;

try {

args = new Arguments(argv);

} catch (IllegalArgumentException ex) {

…

}

// 调用com.android.server.SystemServer类的main方法

invokeStaticMain(args.startClass, args.startArgs);

}

applicationInit调用invokeStaticMain方法通过反射的办法调用com.android.server.SystemServer类的main方法。

我们转到SystemServer类。

位置：Android源码/framework/base/services/java/com/android/server/SystemServer.java

public class SystemServer {

…

public static void main(String[] args) {

…

/ Mmmmmm... more memory!

dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();

// The system server has to run all of the time, so it needs to be

// as efficient as possible with its memory usage.

VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

Environment.setUserRequired(true);

System.loadLibrary("android_servers");

Slog.i(TAG, "Entered the Android system server!");

// Initialize native services.

nativeInit();

// This used to be its own separate thread, but now it is

// just the loop we run on the main thread.

ServerThread thr = new ServerThread();

thr.initAndLoop();

}

main方法创建ServerThread对象并进入消息循环。

class ServerThread {

…

public void initAndLoop() {

…

Looper.prepareMainLooper();

…

context = ActivityManagerService.main(factoryTest);

…

pm = PackageManagerService.main(context, installer,

factoryTest != SystemServer.FACTORY_TEST_OFF,

onlyCore);

…

contentService = ContentService.main(context,

factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);

…

wm = WindowManagerService.main(context, power, display, inputManager,

wmHandler, factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL,

!firstBoot, onlyCore);

…

Looper.loop();

}

在initAndLoop方法里，通过调用各个系统服务类下的main方法创建完成关键系统服务的创建。然后调用Looper.loop()进入消息循环。

2.5 创建应用程序的进程

结合2.3中的内容，创建应用程序进程的关系如下图所示。

ActivityManagerService和Zygote进程服务端通过LocalSocket和LocalServerSocket进行进程间通信，而两者通信的媒介正式/dev/socket/zygote文件。在AMS的Client端，startProcessLocked函数是发送请求的关键函数，而Zygote进程Server端的runSelectLoop函数则是接收AMS发送过来的请求的关键方法。

回到3.1中android源码/framework/base/cmds/app_process的main函数入口，当处于非Zygote模式的时候创建的是应用程序的进程。然后通过3.3的分析我们知道，当我们点击桌面app的图标，启动一个应用程序的时候，AMS会调用startProcessLocked方法发送创建app进程的请求给Zygote进程Server端的Socket。

我们看下ActivityManagerService发送创建app进程请求的关键代码：

位置：Android源码/framework/base/services/java/com/android/server/am/ActivityManagerService.java

private final void startProcessLocked(ProcessRecord app, String hostingType, String hostingNameStr) {

…

Process.ProcessStartResult startResult = Process.start("android.app.ActivityThread",

app.processName, uid, uid, gids, debugFlags, mountExternal,

app.info.targetSdkVersion, app.info.seinfo, null);

…

}

该方法会调用Process类的start静态方法实际上是通过创建LocalSocket跟3.2.4节中Zygote进程创建的Server端Socket进行通信，而Process.start传进来的参数正是要发送给Server端要创建的应用程序的相关参数信息。

根据3.2.4节我们知道，负责接收AMS发送过来请求的是ZygoteInit类的静态成员函数runSelectLoopMode方法，该方法最终会调用Zygote.forAndSpecialize()方法创建app进程，然后调用ZygoteConnection的handleChildProc函数成员来启动该app进程。

位置：Android源码/framework/base/core/java/com/android/internal/os/ZygoteConnection.java

class ZygoteConnection {

…

private void handleChildProc(Arguments parsedArgs,

FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)

throws ZygoteInit.MethodAndArgsCaller {

…

if (parsedArgs.runtimeInit) {

if (parsedArgs.invokeWith != null) {

…

} else {

RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,

parsedArgs.remainingArgs);

}

…

}

这里，parsedArgs.runtimeInit为true，parsedArgs.invokeWith为null。然后调用RuntimeInit的静态成员函数zygoteInit，这一步跟创建SystemServer进程的时候是一样的，不一样的是传递过去的参数。根据3.3的分析我们知道，zygoteInit方法接着会调用applicaitonInit方法，该方法中调用了invokeStaticMain方法，同样通过反射的办法调用上面传递过来的参数，去实际调用android.app.ActivityThread类的main入口函数。

位置：Android源码/framework/base/core/java/com/android/internal/os/RuntimeInit.java

private static void applicationInit(int targetSdkVersion, String[] argv)

throws ZygoteInit.MethodAndArgsCaller {

…

final Arguments args;

try {

args = new Arguments(argv);

} catch (IllegalArgumentException ex) {

…

}

// 调用android.app.ActivityThread类的main方法

invokeStaticMain(args.startClass, args.startArgs);

}

从ActivityThread的main方法入口开始就是一个应用程序的启动过程。我们会在第二章的APP的启动过程做详细分析。

TODO:分析传递的参数

2.6 总结

现在我们用下面一幅图来梳理总结整个过程，对Dalvik的启动过程有一个全局的认识。

首先，Android系统在启动了init一号进程后，init进程就开始创建Zygote进程。Zygote进程主要负责两个工作：

(1) 启动SystemServer进程

(2) 创建应用程序的进程

Zygote进程在创建和初始化过程中，会调用dlopen去加载libdvm.so文件，并调用Class.cpp文件下的dvmClassStartup方法初始化BootClassloader类加载器，并加载bootclasspath，也就是/system/framework目录下的所有jar包。而由于应用程序进程的创建是通过克隆Zygote进程获得，所以，app进程中同样也加载了libdvm和/system/framework下的jar包。

然后Zygote进程会调用registerZygoteSocket()方法来创建一个Server端的Socket，然后调用runSelectLoopMode方法进入循环等待。这个Server端Socket主要负责接收ActivityManagerService发送过来的创建应用程序进程的请求，而AMS是通过调用startProcessLocked方法来发送请求的。当Zygote进程的Server端接收到来自AMS创建应用程序进程的请求后，就会调用forkAndSpecialize()方法创建。

参考：

[3]《Android系统源代码情景分析》第11、12章 Zygote和System进程的启动过程和Android应用程序进程的启动过程http://blog.youkuaiyun.com/luoshengyang/article/details/6768304

[4]《Android Dalvivk虚拟机结构及机制剖析》第6章 Dalvik虚拟机执行流程详解

打赏