导航号,我的单页导航
文章目录

前言

今天简单的记录一下App进程的启动过程。

继之前startActivity的分析(《startActivity源码分析1》和《startActivity源码分析2》)中的进程启动是一带而过的,聪明的你会发现,进程启动的大部分跟《Zygote的启动之二ZygoteInit》重合了。

正文

回到《startActivity源码分析1》文章末尾的startProcessLocked()。

ActivityManagerService.java

PS: 大部分内容都略了

startProcessLocked()
@GuardedBy("this")
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
        boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
        boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
        String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
    //略
    final boolean success = startProcessLocked(app, hostingType, hostingNameStr, abiOverride);
    //略
}
startProcessLocked()
@GuardedBy("this")
private final boolean startProcessLocked(ProcessRecord app,
        String hostingType, String hostingNameStr, String abiOverride) {
    return startProcessLocked(app, hostingType, hostingNameStr,
            false /* disableHiddenApiChecks */, abiOverride);
}
startProcessLocked()
@GuardedBy("this")
private final boolean startProcessLocked(ProcessRecord app, String hostingType,
        String hostingNameStr, boolean disableHiddenApiChecks, String abiOverride) {
    //日志显示,前面几个startProcessLocked()会被调用2次
    //第一次app.pendingStart=false;第二次app.pendingStart=true;
    //因此第二次直接返回
    if (app.pendingStart) {
        return true;
    }
    //略
    try {
        try {
            final int userId = UserHandle.getUserId(app.uid);
            //PackageManagerService.java中检测
            //(1)判断是否存在(2)判断是否安装等,如果有问题就抛出异常
            AppGlobals.getPackageManager().checkPackageStartable(app.info.packageName, userId);
        } catch (RemoteException e) {
            throw e.rethrowAsRuntimeException();
        }
        //略
        //false
        if (!app.isolated) {
        }
        //略
        //注意,这里传入了android.app.ActivityThread
        final String entryPoint = "android.app.ActivityThread";
        //进入下一个startProcessLocked()
        return startProcessLocked(hostingType, hostingNameStr, entryPoint, app, uid, gids,
                runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
                startTime);
    } catch (RuntimeException e) {
        forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid), false,
                false, true, false, false, UserHandle.getUserId(app.userId), "start failure");
        return false;
    }
}

这里有个重点,参数中传入了entryPoint,而entryPoint是

final String entryPoint = "android.app.ActivityThread";

fork出子进程后会启动android.app.ActivityThread

startProcessLocked()
@GuardedBy("this")
private boolean startProcessLocked(String hostingType, String hostingNameStr, String entryPoint,
        ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
        String seInfo, String requiredAbi, String instructionSet, String invokeWith,
        long startTime) {
    //略
    //异步启动 true
    if (mConstants.FLAG_PROCESS_START_ASYNC) {
        //使用Handler的post,也就是异步执行。
        //会先返回return
        mProcStartHandler.post(() -> {
            try {
                synchronized (ActivityManagerService.this) {
                    final String reason = isProcStartValidLocked(app, startSeq);
                    //reason为null
                    if (reason != null) {
                        app.pendingStart = false;
                        return;
                    }
                    app.usingWrapper = invokeWith != null
                            || SystemProperties.get("wrap." + app.processName) != null;
                    mPendingStarts.put(startSeq, app);
                }
                //启动进程startProcess,关键点
                final ProcessStartResult startResult = startProcess(app.hostingType, entryPoint,
                        app, app.startUid, gids, runtimeFlags, mountExternal, app.seInfo,
                        requiredAbi, instructionSet, invokeWith, app.startTime);
                synchronized (ActivityManagerService.this) {
                    handleProcessStartedLocked(app, startResult, startSeq);
                }
            } catch (RuntimeException e) {
                synchronized (ActivityManagerService.this) {
                    mPendingStarts.remove(startSeq);
                    app.pendingStart = false;
                    forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid),
                            false, false, true, false, false,
                            UserHandle.getUserId(app.userId), "start failure");
                }
            }
        });
        return true;
    } else {
        try {
            final ProcessStartResult startResult = startProcess(hostingType, entryPoint, app,
                    uid, gids, runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet,
                    invokeWith, startTime);
            handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
                    startSeq, false);
        } catch (RuntimeException e) {
            app.pendingStart = false;
            forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid),
                    false, false, true, false, false,
                    UserHandle.getUserId(app.userId), "start failure");
        }
        return app.pid > 0;
    }
}
startProcess()
private ProcessStartResult startProcess(String hostingType, String entryPoint,
        ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
        String seInfo, String requiredAbi, String instructionSet, String invokeWith,
        long startTime) {
    try {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
                app.processName);
        //hostingType这里是启动activity,
        if (hostingType.equals("webview_service")) {
            startResult = startWebView(entryPoint,
                    app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                    app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                    app.info.dataDir, null,
                    new String[] {PROC_START_SEQ_IDENT + app.startSeq});
        } else {
            //走这里,进入了Process
            startResult = Process.start(entryPoint,
                    app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                    app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                    app.info.dataDir, invokeWith,
                    new String[] {PROC_START_SEQ_IDENT + app.startSeq});
        }
        checkTime(startTime, "startProcess: returned from zygote!");
        return startResult;
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    }
}

Process.java

start()
public static final ProcessStartResult start(final String processClass,
                              final String niceName,
                              int uid, int gid, int[] gids,
                              int runtimeFlags, int mountExternal,
                              int targetSdkVersion,
                              String seInfo,
                              String abi,
                              String instructionSet,
                              String appDataDir,
                              String invokeWith,
                              String[] zygoteArgs) {
    return zygoteProcess.start(processClass, niceName, uid, gid, gids,
                runtimeFlags, mountExternal, targetSdkVersion, seInfo,
                abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
}

ZygoteProcess.java

start()
public final Process.ProcessStartResult start(final String processClass,
                                              final String niceName,
                                              int uid, int gid, int[] gids,
                                              int runtimeFlags, int mountExternal,
                                              int targetSdkVersion,
                                              String seInfo,
                                              String abi,
                                              String instructionSet,
                                              String appDataDir,
                                              String invokeWith,
                                              String[] zygoteArgs) {
    try {
        return startViaZygote(processClass, niceName, uid, gid, gids,
                runtimeFlags, mountExternal, targetSdkVersion, seInfo,
                abi, instructionSet, appDataDir, invokeWith, false /* startChildZygote */,
                zygoteArgs);
    } catch (ZygoteStartFailedEx ex) {
        throw new RuntimeException(
                "Starting VM process through Zygote failed", ex);
    }
}
startViaZygote()
private Process.ProcessStartResult startViaZygote(final String processClass,
                                                  final String niceName,
                                                  final int uid, final int gid,
                                                  final int[] gids,
                                                  int runtimeFlags, int mountExternal,
                                                  int targetSdkVersion,
                                                  String seInfo,
                                                  String abi,
                                                  String instructionSet,
                                                  String appDataDir,
                                                  String invokeWith,
                                                  boolean startChildZygote,
                                                  String[] extraArgs)
                                                  throws ZygoteStartFailedEx {
    ArrayList<String> argsForZygote = new ArrayList<String>();
    //argsForZygote保存相关信息,进程uid,gid等等
    argsForZygote.add("--runtime-args");
    argsForZygote.add("--setuid=" + uid);
    argsForZygote.add("--setgid=" + gid);
    argsForZygote.add("--runtime-flags=" + runtimeFlags);
    if (mountExternal == Zygote.MOUNT_EXTERNAL_DEFAULT) {
        argsForZygote.add("--mount-external-default");
    } else if (mountExternal == Zygote.MOUNT_EXTERNAL_READ) {
        argsForZygote.add("--mount-external-read");
    } else if (mountExternal == Zygote.MOUNT_EXTERNAL_WRITE) {
        argsForZygote.add("--mount-external-write");
    }
    argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
    if (gids != null && gids.length > 0) {
        StringBuilder sb = new StringBuilder();
        sb.append("--setgroups=");
        int sz = gids.length;
        for (int i = 0; i < sz; i++) {
            if (i != 0) {
                sb.append(',');
            }
            sb.append(gids[i]);
        }
        argsForZygote.add(sb.toString());
    }
    //niceName是应用包名
    if (niceName != null) {
        argsForZygote.add("--nice-name=" + niceName);
    }
    if (seInfo != null) {
        argsForZygote.add("--seinfo=" + seInfo);
    }
    if (instructionSet != null) {
        argsForZygote.add("--instruction-set=" + instructionSet);
    }
    if (appDataDir != null) {
        argsForZygote.add("--app-data-dir=" + appDataDir);
    }
    //invokeWith为null
    if (invokeWith != null) {
        argsForZygote.add("--invoke-with");
        argsForZygote.add(invokeWith);
    }
    //startChildZygote = false
    if (startChildZygote) {
        argsForZygote.add("--start-child-zygote");
    }
    argsForZygote.add(processClass);
    if (extraArgs != null) {
        for (String arg : extraArgs) {
            argsForZygote.add(arg);
        }
    }
    synchronized(mLock) {
        //abi是平台架构类型,比如arm64-v8a,x86等,我这里是arm64-v8a
        //[重]openZygoteSocketIfNeeded()
        //[重]zygoteSendArgsAndGetResult()进程跟Zygote数据传输和读取返回结果
        return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
    }
}
openZygoteSocketIfNeeded()
@GuardedBy("mLock")
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
    Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");
    //primaryZygoteState不为null
    if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
        try {
            //看过Zygote启动的知道,Zygote存在主辅模式
            //比如我设备是以Zygote64位主(secondary),Zygote32位辅(secondary)模式
            //连接socket,这个是Zygote中创建的,
            primaryZygoteState = ZygoteState.connect(mSocket);
        } catch (IOException ioe) {
            throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
        }
        maybeSetApiBlacklistExemptions(primaryZygoteState, false);
        maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState);
    }
    //具体使用哪种模式,跟abi有关
    if (primaryZygoteState.matches(abi)) {
        return primaryZygoteState;
    }
    //下面类型,但如果上面符合,就不会执行下面了。
    if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
        try {
            secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
        } catch (IOException ioe) {
            throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
        }
        maybeSetApiBlacklistExemptions(secondaryZygoteState, false);
        maybeSetHiddenApiAccessLogSampleRate(secondaryZygoteState);
    }
    if (secondaryZygoteState.matches(abi)) {
        return secondaryZygoteState;
    }
    throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}

回归一下之前介绍的,不同设备使用的配置不一样。

下面是几个zygote相关的rc文件。

  1. init.zygote32.rc

    Zygote 进程对应的执行程序是 app_process,也就是纯32位模式。

  2. init.zygote32_64.rc

    启动两个 Zygote 进程(zygote 和 zygote_secondary),对应的执行程序分别是 app_process32(主模式)和app_process64。

  3. init.zygote64.rc

    Zygote 进程对应的执行程序是app_process64,也就是纯64位模式

  4. init.zygote64_32.rc

    启动两个 Zygote 进程(zygote 和 zygote_secondary),对应的执行程序分别是 app_process64(主模式)和app_process32。

会根据primaryZygoteState和secondaryZygoteState的初始化,进程判断,如果都不满足(启动失败了或重启中),就抛出异常!

理论上,至少有一个满足条件。

因此,经过上面执行,已建成跟Zygote进行通信了,并返回ZygoteState。

zygoteSendArgsAndGetResult()
@GuardedBy("mLock")
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
        ZygoteState zygoteState, ArrayList<String> args)
        throws ZygoteStartFailedEx {
    try {
        //略
        //ZygoteState就是上面openZygoteSocketIfNeeded()获取的
        //获取writer和inputStream
        final BufferedWriter writer = zygoteState.writer;
        final DataInputStream inputStream = zygoteState.inputStream;
        //写启动上面组合的启动参数信息
        //此时就进入ZygoteServer.java中runSelectLoop()的死循环中啦
        writer.write(Integer.toString(args.size()));
        writer.newLine();
        for (int i = 0; i < sz; i++) {
            String arg = args.get(i);
            writer.write(arg);
            writer.newLine();
        }
        writer.flush();
        //创建ProcessStartResult对象
        Process.ProcessStartResult result = new Process.ProcessStartResult();
        //等待,zygote启动进程结构
        result.pid = inputStream.readInt();
        result.usingWrapper = inputStream.readBoolean();
        if (result.pid < 0) {
            throw new ZygoteStartFailedEx("fork() failed");
        }
        return result;
    } catch (IOException ex) {
        zygoteState.close();
        throw new ZygoteStartFailedEx(ex);
    }
}

上面就是通过socket进程传输启动应用的新,因此,进入了ZygoteServer.java中runSelectLoop()中。

对于Zygote的socket的那块,推荐可以看参考文,之前我有跟过。

ZygoteServer.java

通过socket发送消息,runSelectLoop()会一直不断的循环并进行处理。

runSelectLoop()
Runnable runSelectLoop(String abiList) {
    //这部分第一次进入才执行,后面的进入了死循环了。
    //死循环
    while (true) {
        //略
        for (int i = pollFds.length - 1; i >= 0; --i) {
            //采用I/O多路复用机制,当客户端发出连接请求或者数据处理请求时,则执行continue
            if ((pollFds[i].revents & POLLIN) == 0) {
                continue;
            }
            if (i == 0) {
               //有socket客户端连接上
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
            } else {
                try {
                    //客户端发送了请求,获取connection
                    ZygoteConnection connection = peers.get(i);
                    //[重]处理发送来的消息,其实这里就处理fork出子进程
                    //切记,返回的是Runnable,这里进入
                    final Runnable command = connection.processOneCommand(this);
                  //这里要对fork有一定了解,创建子进程就是Zygote的分裂
                  //下面的if语句都会执行
                  //一个是走父进程流程关闭socket;一个是子进程流程,启动进程ActivityThread
                    if (mIsForkChild) {
                        //如果在子进程,command不为null
                        if (command == null) {
                            throw new IllegalStateException("command == null");
                        }
                        return command;
                    } else {
                        //父进程,command为null
                        if (command != null) {
                            throw new IllegalStateException("command != null");
                        }
                        //关闭socket等
                        if (connection.isClosedByPeer()) {
                            connection.closeSocket();
                            peers.remove(i);
                            fds.remove(i);
                        }
                    }
                } catch (Exception e) {
                    //略
                } finally {
                    mIsForkChild = false;
                }
            }
        }
    }
}

从socket中接收消息,然后进程fork出子进程(也就是从zygote中分裂而来)。

然后主进程流程关闭socket,子进程流程启动ActivityThread。

我们先挂住processOneCommand()这块。

ZygoteConnection.java

processOneCommand()
Runnable processOneCommand(ZygoteServer zygoteServer) {
    String args[];
    Arguments parsedArgs = null;
    FileDescriptor[] descriptors;
    try {
        //从socket读取命令
        args = readArgumentList();
        descriptors = mSocket.getAncillaryFileDescriptors();
    } catch (IOException ex) {
        throw new IllegalStateException("IOException on command socket", ex);
    }
    //如果没有参数,直接结束
    if (args == null) {
        isEof = true;
        return null;
    }
    int pid = -1;
    FileDescriptor childPipeFd = null;
    FileDescriptor serverPipeFd = null;
    //创建Arguments对象,这里会解析args中的命令
    parsedArgs = new Arguments(args);
    //根据参数值进行处理
    if (parsedArgs.abiListQuery) {
        handleAbiListQuery();
        return null;
    }
    //略
    //fork出子进程
    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);
    try {
        if (pid == 0) {
            //子进程流程
            zygoteServer.setForkChild();
            zygoteServer.closeServerSocket();
            IoUtils.closeQuietly(serverPipeFd);
            serverPipeFd = null;
            //[重]返回Runnable
            return handleChildProc(parsedArgs, descriptors, childPipeFd,
                    parsedArgs.startChildZygote);
        } else {
            IoUtils.closeQuietly(childPipeFd);
            childPipeFd = null;
            //如果是父进程流程
            handleParentProc(pid, descriptors, serverPipeFd);
            return null;
        }
    } finally {
        IoUtils.closeQuietly(childPipeFd);
        IoUtils.closeQuietly(serverPipeFd);
    }
}
handleChildProc()
private Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,
        FileDescriptor pipeFd, boolean isZygote) {
    //关闭socket
    closeSocket();
    //根据之前传入参数,invokeWith=null
    if (parsedArgs.invokeWith != null) {
        WrapperInit.execApplication(parsedArgs.invokeWith,
                parsedArgs.niceName, parsedArgs.targetSdkVersion,
                VMRuntime.getCurrentInstructionSet(),
                pipeFd, parsedArgs.remainingArgs);
        throw new IllegalStateException("WrapperInit.execApplication unexpectedly returned");
    } else {
        //走这里
        //isZygote为false,是依赖parsedArgs.startChildZygote
        if (!isZygote) {
            return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs,
                    null /* classLoader */);
        } else {
            return ZygoteInit.childZygoteInit(parsedArgs.targetSdkVersion,
                    parsedArgs.remainingArgs, null /* classLoader */);
        }
    }
}

ZygoteInit.java

zygoteInit()
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
    //这参数是ActivityManagerService.java中startProcessLocked()中[上面倒数第二个]传入的
    //argv中带有android.app.ActivityThread参数。
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
    RuntimeInit.redirectLogStreams();
    RuntimeInit.commonInit();
    ZygoteInit.nativeZygoteInit();
    return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}

RuntimeInit.java

applicationInit()
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
        ClassLoader classLoader) {
    nativeSetExitWithoutCleanup(true);
    VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
    VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
    final Arguments args = new Arguments(argv);
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    //[重]看方法名就知道,找到main方法入口
    //args.startClass = android.app.ActivityThread
    return findStaticMain(args.startClass, args.startArgs, classLoader);
}
findStaticMain()
protected static Runnable findStaticMain(String className, String[] argv,
        ClassLoader classLoader) {
    Class<?> cl;
    //是不是很熟悉,反射
    try {
        cl = Class.forName(className, true, classLoader);
    } catch (ClassNotFoundException ex) {
        throw new RuntimeException(
                "Missing class when invoking static main " + className,
                ex);
    }
    Method m;
    try {
        //查找main函数入口
        m = cl.getMethod("main", new Class[] { String[].class });
    } catch (NoSuchMethodException ex) {
        throw new RuntimeException(
                "Missing static main on " + className, ex);
    } catch (SecurityException ex) {
        throw new RuntimeException(
                "Problem getting static main on " + className, ex);
    }
    int modifiers = m.getModifiers();
    if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
        throw new RuntimeException(
                "Main method is not public and static on " + className);
    }
    //创建MethodAndArgsCaller,MethodAndArgsCaller实现于Runnable
    return new MethodAndArgsCaller(m, argv);
}
MethodAndArgsCaller
static class MethodAndArgsCaller implements Runnable {
    private final Method mMethod;
    private final String[] mArgs;
    public MethodAndArgsCaller(Method method, String[] args) {
        mMethod = method;
        mArgs = args;
    }
    public void run() {
        try {
            //Method = com.android.server.SystemServer的main函数
            //这里会启动ActivityThread并执行main()方法
            mMethod.invoke(null, new Object[] { mArgs });
        } catch (IllegalAccessException ex) {
            //略
        }
    }
}

到这里,Runnable已经创建了,但之前仅仅是创建了Runnable,但没有执行run(),因此我们要回到runSelectLoop()中。

ZygoteServer.java

再次回答runSelectLoop()中,里面有这段代码[只是部分]

try {
    //客户端发送了请求,获取connection
    ZygoteConnection connection = peers.get(i);
    //[重]处理发送来的消息,其实这里就处理fork出子进程
    //切记,返回的是Runnable,这里进入
    final Runnable command = connection.processOneCommand(this);
    //这里要对fork有一定了解,创建子进程就是Zygote的分裂
    //下面的if语句都会执行
    //一个是走父进程流程关闭socket;一个是子进程流程,启动进程ActivityThread
    if (mIsForkChild) {
        //如果在子进程,command不为null
        if (command == null) {
            throw new IllegalStateException("command == null");
        }
        return command;
    } else {
        //父进程,command为null
        if (command != null) {
            throw new IllegalStateException("command != null");
        }
        //关闭socket等
        if (connection.isClosedByPeer()) {
            connection.closeSocket();
            peers.remove(i);
            fds.remove(i);
        }
    }
} catch (Exception e) {
    //略
} finally {
    mIsForkChild = false;
}

上面也说了fork后,会有两个执行流程,一个是父进程流程,一个是子进程流程。我们关注子进程流程。

也就是mIsForkChild为true时,此时command不为null,而是

command = new MethodAndArgsCaller(m, argv);

也就是runSelectLoop()执行结束,并返回Runnable。

fork是把父类所有的资源都拷贝一份给子进程,因此,上面退出的runSelectLoop()循环是子类的。

子类用户父类Zygote一样的代码流程。ZygoteInit.java是进入Java世界的第一扇大门!

runSelectLoop()也是在ZygoteInit.java中main()方法中的。

ZygoteInit.java

public static void main(String argv[]) {
    //创建ZygoteServer
    ZygoteServer zygoteServer = new ZygoteServer();
    final Runnable caller;
    try {
        //略
        //[重]循环中。对于zygote不会退出,至于fork的子进程,是会退出的
        caller = zygoteServer.runSelectLoop(abiList);
    } catch (Throwable ex) {
        throw ex;
    } finally {
        //关闭socket
        zygoteServer.closeServerSocket();
    }
    //子进程退出的caller不为null
    if (caller != null) {
        caller.run();
    }
}

fork出的子进程才会退出runSelectLoop()循环,因此上面的call就是返回的Runnable对象,也就是这里main()方法结束后执行了

MethodAndArgsCaller.run();

然后进入了ActivityThread.java的main(),至于后面的,可以看《startActivity源码分析2》。

参考文章

  1. Zygote的启动之二ZygoteInit

  2. Zygote的启动之一app_main

  3. startActivity源码分析1

  4. startActivity源码分析2

  5. 《Android进阶解密-刘望舒》

© 版权声明
导航号,我的单页导航

暂无评论

暂无评论...