应用进程是如何创建出来的

0.318字数 1840阅读 981

简介

APP各自运行于自己的进程中,每一个进程中都拥有一个独立的Dalvik虚拟机实例,拥有了Dalvik,Android的Java程序才能运行起来。可以理解为,进程在以隔离了用户环境下运行,使各不干扰。常用的四大组件,要能运行起来,首先就需要APP的进程已准备完毕。

本文的目的,是学习进程是如如何被创建出来的。

note:源码版本为8.0,各版本间有差异,但不影响核心设计

进程启动必要参数准备

如在Activity的启动过程中,当AMS发现此Activity所依赖的应用进程还没有启动起来,则会请求Zygote进程将此应用进程启动起来。
传送门:Activity启动时发生了什么

代码移步ActivityManagerService.AMS.startProcessLocked()

    private final void startProcessLocked(ProcessRecord app, String hostingType,
            String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
            ......
        try {
            ......
            // 进程uid
            int uid = app.uid;
            // GIDS
            int[] gids = null;
            int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
            if(!app.isolated){
            ......
                // 记住资源访问权限
                if (ArrayUtils.isEmpty(permGids)) {
                    gids = new int[3];
                } else {
                    gids = new int[permGids.length + 3];
                    System.arraycopy(permGids, 0, gids, 3, permGids.length);
                }
                gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
                gids[1] = UserHandle.getCacheAppGid(UserHandle.getAppId(uid));
                // shareUserId
                gids[2] = UserHandle.getUserGid(UserHandle.getUserId(uid));
            }
            ......
            // 指明应用程序入口
            if (entryPoint == null) entryPoint = "android.app.ActivityThread";
            if(...){
            
            } else{
                //交给 Zygote 去孵化
                startResult = Process.start(entryPoint,
                        app.processName, uid, uid, gids, debugFlags, mountExternal,
                        app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                        app.info.dataDir, invokeWith, entryPointArgs);
            }
        } 
    }

代码总app为ProcessRecord,ProcessRecord描述了一个进程,与进程相关的信息存于ProcessRecord中,AMS也是通过ProcessRecord才能得知进程状况。

UID

UID标识一个应用进程,应用程序在安装时被分配UID,当此应用程序续存期间(没卸载),UID不变。普通应用程序而言,GID = UID。
通过命令

adb shell ps | grap packageName

可以查看在运行的应用程序信息


查看应用pid.jpg

图中APP使用了多进程,因此根据包名查处了两个进程信息。横行信息依次为 当前用户(UID)、进程ID(PID)、父进程ID(PPID)、进程的虚拟内存大小、实际内存占用大小、进程正在睡眠的内核函数名称。

如所说,无论多少次杀掉此APP进程再重启,UID均不变。

GIDS

GIDS则与Application申请的具体权限有关,申请的相应permission被granted时,则有对应的GIDS,因此,GIDS是关于允许或限制应用程序访问设备资源。比如常在manifest申请访问网络权限

<uses-permission android:name="android.permission.INTERNET"/>

被允许时,组在GIDS中有相应的ID

shareUserId

在GIDS中,shareUserId也比较重要,需简单了解沙箱模型。


沙箱模型1.png

各个应用程序运行与各自的环境中(沙箱),默认情况下,程序间无法交互。运行在沙箱内的应用程序如果没有被分配权限,无法访问系统或资源,因此运行去Dalvik虚拟机的应用程序都能得到同样的安全保护,被限制在各自沙箱内的程序互不干涉,使得对其它或受其它程序的损害降到最低。在沙箱机制下,应用程序间互不信任,相互隔离,各自运行。

沙箱模型2.png

通过shareUserId,可是程序相互信任,公共运行与同一进程空间内,可以像访问自有程序一样访问对方程序资源。
以上二图来源

回到正文,在准备好启动进程的相关数据后,交接给下一节点继续执行。还需注意被赋值为“android.app.ActivityThread”的变量entryPoint,后续会通过此变量启动ActivityThread.main(),也就指定了应用程序的入口。

启动准备

此后调用链路为
Process.start()
-> ZygoteProcess.start()
-> ZygoteProcess.startViaZygote()

    private Process.ProcessStartResult startViaZygote(final String processClass,
       final String niceName,final int uid, final int gid,final int[] gids,
       int debugFlags, int mountExternal, int targetSdkVersion, String seInfo,
       String abi, String instructionSet, String appDataDir, String invokeWith,
       String[] extraArgs) throws ZygoteStartFailedEx {

        // 存储启动参数
        ArrayList<String> argsForZygote = new ArrayList<String>();

        // 以下三参数必有
        argsForZygote.add("--runtime-args");
        argsForZygote.add("--setuid=" + uid);
        argsForZygote.add("--setgid=" + gid);
        // 其它参数看具体情况
        ......
       
        synchronized(mLock) {
            // 获取LocalkSocket以连接Zygote进程,后将参数通过LocalSocket
            // 写入Zygote进程,让Zygote进程进行创建
            return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
        }
       }

视情况准备进程启动需要的参数,再获取用以和进程进行连接的ZygoteState,便可以向Zygote进程写入此次新建进程的请求。

    private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
        Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");

        if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
            try {
                primaryZygoteState = ZygoteState.connect(mSocket);
            } catch (IOException ioe) {
                throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
            }
        }

        if (primaryZygoteState.matches(abi)) {
            return primaryZygoteState;
        }

        // The primary zygote didn't match. Try the secondary.
        if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
            try {
                secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
            } catch (IOException ioe) {
                throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
            }
        }

        if (secondaryZygoteState.matches(abi)) {
            return secondaryZygoteState;
        }

        throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
    }

primaryZygoteState 和 secondaryZygoteState 均为 ZygoteState, Android 5.0以后,Android开始支持64位编译,Zygote进程也随之引入了32/64位的区别。顾名思义,primaryZygoteState为主Zygote,secondaryZygoteState为辅Zygote。至于是32位为主,还是64位辅,就要看具体Zygote文件的配置了。这里以ABI架构类型为引子,找到合适的ZygoteSate。

如果所查找的ZygoteState未创建或连接状态已关闭,则会获取此ZygoteState。
ZYGOTE_SOCKET

        public static ZygoteState connect(String socketAddress) throws IOException {
            DataInputStream zygoteInputStream = null;
            BufferedWriter zygoteWriter = null;
            final LocalSocket zygoteSocket = new LocalSocket();

            try {
                zygoteSocket.connect(new LocalSocketAddress(socketAddress,
                        LocalSocketAddress.Namespace.RESERVED));

                zygoteInputStream = new DataInputStream(zygoteSocket.getInputStream());

                zygoteWriter = new BufferedWriter(new OutputStreamWriter(
                        zygoteSocket.getOutputStream()), 256);
            } catch (IOException ex) {
                try {
                    zygoteSocket.close();
                } catch (IOException ignore) {
                }

                throw ex;
            }

            String abiListString = getAbiList(zygoteWriter, zygoteInputStream);
            Log.i("Zygote", "Process: zygote socket " + socketAddress + " opened, supported ABIS: "
                    + abiListString);

            return new ZygoteState(zygoteSocket, zygoteInputStream, zygoteWriter,
                    Arrays.asList(abiListString.split(",")));
        }

新建的LocalSocket为ZygoteState成员变量,ZygoteState使用的输入流与输出流均从LocalSocket拿到。参数socketAddress为Process创建ZygoteProcess传入的ZYGOTE_SOCKET,即"zygote"。因此LocalSocket.connect()将与Zygote进程中名为“zygote”的Socket进行连接。在有了能与Zygote进程通信的媒介之后,已可以向Zygote进程传入数据或从Zygote进程传输数据。

创建进程

回到
-> ZygoteProcess.startViaZygote()
-> zygoteSendArgsAndGetResult()

    private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
            ZygoteState zygoteState, ArrayList<String> args)
            throws ZygoteStartFailedEx {
            ......
          // 写入启动参数长度
            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();

            // Should there be a timeout on this?
            Process.ProcessStartResult result = new Process.ProcessStartResult();

            // 拿到进程创建的结果
            result.pid = inputStream.readInt();
            result.usingWrapper = inputStream.readBoolean();

            if (result.pid < 0) {
                throw new ZygoteStartFailedEx("fork() failed");
            }
            return result;
        }

通过输出流向Zygote进程写入启动数据后,进入阻塞状态,直到能接受到Zygote进程反馈的数据。拿到了创建的结果,意味着进程创建的结束。

进程创建,简.png

目前来看,Process通过LocalSocket与Zygote进程进行通信,传输关键数据即可创建进程,因此还可对Zygote如何创建进程加以了解。

Zygote进程

简要了解一下Zygote进程的创建,见ZygoteInit.main()

   public static void main(String argv[]) {
        // 创建ZygoteServer
        ZygoteServer zygoteServer = new ZygoteServer();
        ......
        try{
        ......
        // 注册名为 "zygote的socket"
        zygoteServer.registerServerSocket(socketName);
        ......
        // 接收请求
        zygoteServer.runSelectLoop(abiList);
        ......
        }
   }

在Zygote进程创建时,向ZygoteServer注册一个名为"zygote"的服务端Socket,之前所说的新建进程请求到来时,即是与此Socket进行通信。当请求到来,在zygoteServer.runSelectLoop()处接收请求。

    void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
        ......
        boolean done = peers.get(i).runOnce(this);
    }

实际由ZygoteConnection.runOnce()进程处理

    boolean runOnce(ZygoteServer zygoteServer) throws Zygote.MethodAndArgsCaller {
        String args[];
        Arguments parsedArgs = null;
        FileDescriptor[] descriptors;
        
        try {
            // 获取LocalSocket传来的启动参数
            args = readArgumentList();
            descriptors = mSocket.getAncillaryFileDescriptors();
        }
        ......
        tyr{
            // 解析参数
            parsedArgs = new Arguments(args);
            ......
            // frok()
            pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                    parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                    parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.instructionSet,
                    parsedArgs.appDataDir);
        }
        ......
        try{
            // pid = 0 说明创建了进程
            if (pid == 0) {
                // in child
                zygoteServer.closeServerSocket();
                IoUtils.closeQuietly(serverPipeFd);
                serverPipeFd = null;
                handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);

                return true;
            }
        }

在接收并解析出LocalSocket所传输过来的启动参数后,通过Zygote.forkAndSpecialize()让native真正fork()出进程。当PID = 0 时,说明Zygote进程创建出了子进程。

当前情况下,需要Zygote进程孵化出的进程。Zygote进程作为Android进程的母体,包含各应用进程所需要的进程信息和资源信息,因从从Zygote进程fork()出的子进程具有Zygote进程信息如数据段、代码段等,自然也包括Dalvik虚拟机实体。

在进程创建完后,由
ZygoteConnection.handleChildProc()
-> ZygoteInit.zygoteInit() 处理进一步事宜

    public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
        RuntimeInit.redirectLogStreams();

        RuntimeInit.commonInit();
        // 创建Binder线程池
        ZygoteInit.nativeZygoteInit();
        // 当AMS要求新创建线程时,唤醒ActivityThread.main()
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

applicationInit()通过反射唤醒ActivityThread.main(),之前在AMS请求启动新进程时特意调到的entryPoint,也一并通过LocalSocket作为参数之一传入Zygote进程,因此在这里可以知道此唤醒信息。

AMS在请求启动新进程的同时,不会一直等待进程创建,延迟发送消息PROC_START_TIMEOUT_MSG,如果进程为内在PROC_START_TIMEOUT_MSG时间内成功创建,则AMS会认为进程启动失败。因此在,在唤醒ActivityThread.main()后attach()时机,会通知AMS取消PROC_START_TIMEOUT_MSG消息,以后保证后续流程进行。

至此,也就了解了进程时如何被创建出来。

总结

进程创建,完整.png

进程创建如下:
1、AMS启动各类组件发现相应进程没有启动起来时,获取进程启动所需参数,通过Process.start()请求启动进程。
2、Process通过LocalSocket与Zygote进程通信,Zygote进程对应Socket为"zogote",在Zygote进程创建时启动。
3、ZygoteServer收到启动进程请求后,由ZygoteConnection.runOnce()进行处理,交由native进行fork(),在成功创建子进程后,唤醒ActivityThread.main()。
4、AMS不会无限等待进程创建,因此ActivityThread.main()被唤醒后,会告知AMS取消PROC_START_TIMEOUT_MSG,以能进行后续Business。

参考

浅析Android沙箱模型
Android -- 系统进程Zygote的启动分析
Android ABI的浅析

推荐阅读更多精彩内容