美文网首页Android面试
应用进程是如何创建出来的

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

作者: MxsQ | 来源:发表于2019-06-07 17:46 被阅读805次

    简介

    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的浅析

    相关文章

      网友评论

        本文标题:应用进程是如何创建出来的

        本文链接:https://www.haomeiwen.com/subject/myhvxctx.html