探索APP进程的启动流程(二)完结篇

首先回顾下冷启动的流程图： 共有四个步骤： 1.launcher进程通过binder请求ams启动Activity，AMS进程查询内存中是否存在该进程。 2.内存中无相应进程，ams通过socket发送创建进程命令和相关资料到zygote进程。 3.zygote进程收到socket信息后，fork子进程，创建出ActivityThread的进程（目的进程） 4.ActivityThread通过binder把新建的进程信息与AMS进行相关联。 在上一篇博客中探索APP进程的启动流程(一)，介绍了从用户点开app到发送指令给zygote进程的过程（步骤1，步骤2）。

再往下就去到Zygote进程（步骤3，步骤4），Zygote接收到初始化进程指令，fork子进程。 （剧透：如果没时间看源码，可以直接去到本文末尾，有 zygote进程等待socket消息和处理的简单模型 图） frameworks\base\core\java\com\android\internal\os\ZygoteInit.java

public static void main(String argv[]) { //ZygoteServer处理有关socket服务端的业务 ZygoteServer zygoteServer = new ZygoteServer(); ... ///注册Zygote的Socket服务端 zygoteServer.registerServerSocketFromEnv(socketName); ... if (startSystemServer) { //开启SystemServer startSystemServer(abiList, socketName, zygoteServer); } Log.i(TAG, "Accepting command socket connections"); //等待客户端请求， //在runSelectLoop（）里面是while(true),线程堵塞等到客户端的socket发送信息 zygoteServer.runSelectLoop(abiList); //关闭Socket服务端 zygoteServer.closeServerSocket(); ... }

zygoteServer. runSelectLoop(), 进行接收socket客户端信息

\frameworks\base\core\java\com\android\internal\os\ZygoteServer.java

Runnable runSelectLoop(String abiList) { ... ZygoteConnection connection = peers.get(i); //接收到socket客户端信息，processOneCommand进行处理 final Runnable command = connection.processOneCommand(this); ... }

\frameworks\base\core\java\com\android\internal\os\ZygoteConnection.java 继续看看processOneCommand（）如何处理socket信息

Runnable processOneCommand(ZygoteServer zygoteServer) { String args[]; Arguments parsedArgs = null; FileDescriptor[] descriptors; try { //readArgumentList函数来获取启动应用程序进程的命令参数 args = readArgumentList(); ... //将readArgumentList函数返回的字符串args封装到Arguments对象parsedArgs中 parsedArgs = new Arguments(args); ... //调用Zygote的forkAndSpecialize函数来创建应用程序进程， //参数为parsedArgs中存储的应用进程启动参数，返回值为pid //forkAndSpecialize函数主要是通过fork当前进程来创建一个子进程(native完成) pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids, parsedArgs.runtimeFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo, parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.startChildZygote, parsedArgs.instructionSet, parsedArgs.appDataDir); ... if (pid == 0) { // 如果pid等于0，则说明是现在在新创建的子进程中执行 // in child zygoteServer.setForkChild(); zygoteServer.closeServerSocket(); IoUtils.closeQuietly(serverPipeFd); serverPipeFd = null; ， //调用 handleChildProc 函数来启动这个子进程也就是应用程序进程 return handleChildProc(parsedArgs, descriptors, childPipeFd, parsedArgs.startChildZygote); } ... }

\frameworks\base\core\java\com\android\internal\os\ZygoteConnection.java 进去handleChildProc()看看

private Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors, FileDescriptor pipeFd, boolean isZygote) { ... //zygoteInit() 来初始化进程 return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, null /* classLoader */); ... }

frameworks\base\core\java\com\android\internal\os\ZygoteInit.java

public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) { ... // 新创建的应用程序进程中创建Binder线程池 ZygoteInit.nativeZygoteInit(); //初始化进程入口类ActivityThread return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader); }

frameworks\base\core\java\com\android\internal\os\RuntimeInit.java

protected static Runnable applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) { ... // args.startClass 为 从AMS的startProcessLocked()传入的参数 return findStaticMain(args.startClass, args.startArgs, classLoader); ... }

再跟进findStaticMain(): frameworks\base\core\java\com\android\internal\os\RuntimeInit.java

protected static Runnable findStaticMain(String className, String[] argv, ClassLoader classLoader) { Class<?> cl; ... //根据类加载器，获得Android.app.ActivityThread类 cl = Class.forName(className, true, classLoader); ... Method m; ... //获得ActivityThread.java main() m = cl.getMethod("main", new Class[] { String[].class }); ... //把调用ActivityThread. main()的runnable实例返回 return new MethodAndArgsCaller(m, argv); }

new MethodAndArgsCaller(m, argv)返回的runnable实例到ZygoteInit类的caller对象。 在ZygoteInit.main()方法中执行caller.run() frameworks\base\core\java\com\android\internal\os\ZygoteInit.java

public static void main(String argv[]) { ZygoteServer zygoteServer = new ZygoteServer(); ... // We're in the child process and have exited the select loop. Proceed to execute the // command. //子进程会离开socket服务端等待信息的循环 if (caller != null) { caller.run(); }

MethodAndArgsCaller.run()执行了，ActivityThread.main()。 在代码,有：

static class MethodAndArgsCaller implements Runnable { .... public void run() { try { //mMethod为ActivityThread.main()方法。这里调用ActivityThread的main() mMethod.invoke(null, new Object[] { mArgs }); } catch (IllegalAccessException ex) { throw new RuntimeException(ex); } catch (InvocationTargetException ex) { Throwable cause = ex.getCause(); if (cause instanceof RuntimeException) { throw (RuntimeException) cause; } else if (cause instanceof Error) { throw (Error) cause; } throw new RuntimeException(ex); } } .... }

初始化ActivityThread类（进程的入口类） \frameworks\base\core\java\android\app\ActivityThread.java

//ApplicationThread 为 ActivityThread内部类，是binder服务的服务端 final ApplicationThread mAppThread = new ApplicationThread(); public static void main(String[] args) { ... //初始化进程的主线程 Looper Looper.prepareMainLooper(); ... //实例化 ActivityThread 对象 ActivityThread thread = new ActivityThread(); //在attach()方法里进行请求ams绑定当前新建的进程 thread.attach(false, startSeq); ... //loop启动 Looper.loop(); ... }

继续跟进attach() \frameworks\base\core\java\android\app\ActivityThread.java

private void attach(boolean system, long startSeq) { ... //获得ActivityManagerService服务 final IActivityManager mgr = ActivityManager.getService(); //调用ActivityManagerService.attachApplication()，并传入mAppThread。请求关联进程 mgr.attachApplication(mAppThread, startSeq); ... }

zygote进程等待socket消息和处理的简单模型

将上述的代码分析，转成流程图形式： < zygote进程等待socket消息和处理的简单模型>

在这两篇文章里，只对进程的创建做分析。对于APP的启动流程，这里先不做细节分析，后续文章再继续简述APP的启动流程。

来到这里，从 新建一个进程 到 把进程与AMS关联的关键步骤已大概分析介绍。如果有其他疑问或有错误地方可以给我留言哦。