ART

在上文的Android 系统的启动过程中说到Android的虚拟机ART（AndroidRuntime）

ART的主要方法有
- startVM() 启动虚拟机并且初始化
- startReg() 注册一些JNI的方法
- start() 启动Zygote，依次执行 startVM()->startReg()->callMain()
- callMain() 通过反射调用传入的className对象的main函数，如在init.cpp函数里面传入的ZygoteInit对象和RuntimeInit对象，调用callMain方法就会调用对应的main方法。

AppRuntime的主要方法有

setClassNameAndArgs()设置传入的参数
onVmCreated()重载AndroidRuntime方法,调用了FindClass方法，不能再onStarted方法里面调用，因为它创建了一个
bootClassLoader加载器，如果在onStarted里面调用，就无法找到改方法了。
onStarted开启了一个线程池，callMain调用了主函数
onZygoteInit 开启了一个线程池
OnExit 退出对应的线程

Zygote

从上文知道，app_main.cpp里面的main函数通过init.rc传入的参数之后来判断Zygote是通过Zygote模式来启动还是通过非Zygote模式来启动。然后通过AppRuntime调用AndroidRuntime的callMain函数来调用对应的main函数

首先来看ZygoteInit的Main函数

 public static void main(String argv[]) {
       //...
      // android-7.1.2_r36/core/java/com/android/internal/os/ZygoteInit.java

        try {
         //...
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {
                    startSystemServer = true;
                }
               //...
            }
            //...
            registerZygoteSocket(socketName);
       //...
            if (startSystemServer) {
                startSystemServer(abiList, socketName);
            }
            Log.i(TAG, "Accepting command socket connections");
            runSelectLoop(abiList);
            closeServerSocket();
        } catch (MethodAndArgsCaller caller) {
            caller.run();
        } catch (Throwable ex) {
            Log.e(TAG, "Zygote died with exception", ex);
            closeServerSocket();
            throw ex;
        }
    }

ZygoteInit主要做了下面几个事情
- registerZygoteSocket() 创建了一个socket接口，用来和ActivityManagerService通讯
- startSystemServer() 当传入参数start-system-server的时候启动SystemServer组件
- runSelectLoop() 执行一个无限循环，在创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程

registerZygoteSocket详细代码如下：

      //...
      // android-7.1.2_r36/core/java/com/android/internal/os/ZygoteInit.java

 private static void registerZygoteSocket(String socketName) {
        if (sServerSocket == null) {
            int fileDesc;
            final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
            try {
                String env = System.getenv(fullSocketName);
                fileDesc = Integer.parseInt(env);
            } catch (RuntimeException ex) {
                throw new RuntimeException(fullSocketName + " unset or invalid", ex);
            }
            try {
                FileDescriptor fd = new FileDescriptor();
                fd.setInt$(fileDesc);
                sServerSocket = new LocalServerSocket(fd);
            } catch (IOException ex) {
                throw new RuntimeException(
                        "Error binding to local socket '" + fileDesc + "'", ex);
            }
        }
    }

首先获取fullsocketName的值，也就是ANDROID_SOCKET_zygote，然后获取对应的文件描述符fileDesc，通过fileDesc创建了LocalServerSocket对象，这样就可以接收到发送给zygote的消息了。

startSystemServer详细代码如下：

  //...
      // android-7.1.2_r36/core/java/com/android/internal/os/ZygoteInit.java
private static boolean startSystemServer(String abiList, String socketName)
            throws MethodAndArgsCaller, RuntimeException {
         //...
        try {
           //...
            /* Request to fork the system server process */
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }
  if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }
            handleSystemServerProcess(parsedArgs);
        }
        return true;
    }

根据相应的参数创建了SystemService进程。当SystemService进程创建完后，调用handleSystemServerProcess()方法

 // android-7.1.2_r36/core/java/com/android/internal/os/ZygoteInit.java
 private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws ZygoteInit.MethodAndArgsCaller {
        //...
      RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
  //...
}

接下来进入了RuntimeInit.zygoteInit里面

 // android-7.1.2_r36/core/java/com/android/internal/os/RuntimeInit.java
 public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
            throws ZygoteInit.MethodAndArgsCaller {
        //...
        commonInit();
        nativeZygoteInit();
        applicationInit(targetSdkVersion, argv, classLoader);
    }

nativeZygoteInit() 调用AppRuntime.cpp::onZygoteInit()，后续用于Binder通信
applicationInit() 通过反射调用了SystemService.java的Main函数
1. runSelectLoop详细代码如下：

 private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
   //...
        while (true) {
           //...
                if (i == 0) {
                    ZygoteConnection newPeer = acceptCommandPeer(abiList);
                    peers.add(newPeer);
                    fds.add(newPeer.getFileDesciptor());
                } else {
                    boolean done = peers.get(i).runOnce();
                    if (done) {
                        peers.remove(i);
                        fds.remove(i);
                    }
                }
            }
        }
    }

执行一个死循环监听消息，通过acceptCommandPeer()方法可以获取到客户端发送过来的消息，通过ZygoteConnection进行通信，紧接着进入到runOnce()，进行相应的处理，从而创建出来一个新的进程

RuntimeInit的Main函数

       //...
      // android-7.1.2_r36/core/java/com/android/internal/os/RuntimeInit.java
 public static final void main(String[] argv) {
        enableDdms();
     //...
        commonInit();
      //...
        nativeFinishInit();
        if (DEBUG) Slog.d(TAG, "Leaving RuntimeInit!");
    }

RuntimeInit主要做了下面几个事情
- enableDdms() 开启DDMS
- commonInit() 设置线程异常的默认处理，系统时间初始化，初始化日志打印LogManager
- nativeFinishInit() 执行原生代码

总结

通过上文的描述，最终的流程大概如下

Android 系统的Zygote初始化过程

ART

Zygote

总结

猜你喜欢