Android系统的心脏-Zygote进程启动流程分析

灰太狼 2023-10-17 10:38 22阅读 0赞

### 简介： ###

Android中，Zygote是整个Android系统的核心进程，是Android系统的心脏。所有的Android应用程序，包括Android框架层所在的进程system\_server，都是由Zygote孵化（通过Linux系统调用fork函数创建）出来的。

### Zygote初探： ###

我们说，zygote是整个Android系统的心脏，在zygote被启动的同时，还启动了其它的很多守护进程，有的比zygote启动的还早。 换句话说，在zygote还没有启动时，其实，作为底层的Linux系统已经启动了，标志就是init进程已经启动。

如果我们在adb shell命令行，用kill命令（在root的情况下），居然可以杀死zygote，然后，设备屏幕又会显示“>>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<”，即android系统重启。

zytote是一个实实在在的进程，可以在进程列表中查看到：

> USER PID PPID VSIZE RSS WCHAN PC NAME
> 
> root 1 0 548 196 c00b8c14 0000d5cc S /init
> 
> root 2 0 0 0 c006bf70 00000000 S kthreadd
> 
> ......
> 
> root 724 2 0 0 c0216908 00000000 S mmcqd
> 
> root 726 1 772 180 c019dbc4 afe0c1dc S /system/bin/sh
> 
> system 727 1 840 188 c022d8a0 afe0c47c S /system/bin/servicemanager
> 
> ......
> 
> root 734 1 72000 14172 c00b92b0 afe0c5a4 S **zygote**  
> ......
> 
> system 825 734 574128 28360 ffffffff afe0c47c S **system\_server**  
> ......
> 
> app\_22 890 734 117068 30228 ffffffff afe0d404 S oms.home

可以看到，

**zygote的父进程id是1，即init进程，而且，zygote的权限是root权限；**

system\_server是Android系统框架所在的进程，即AMS，WMS等很多服务所在的就是这个进程。system\_server的父进程就是zygote；

oms.home:是home应用，即手机桌面应用。oms是Ophone系统（中国移动基于Android系统进行定制的一个系统）。作为应用程序，它的父进程也是zygote。

下图，是比较重要的一些进程的相关关系：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16][]

zygote的启动流程简单说明：

>   
> 1）创建Java虚拟机；  
> 2）为Java虚拟机注册native方法；  
> 3）在com.android.internal.os.ZygoteInit中调用java类的主要方法；  
> 4）加载ZygoteInit class；  
> 5）注册zygote socket；  
> 6）加载preload class；  
> 7）加载preload 资源文件；  
> 8）调用Zygote::forkSystemServer，fork一个新的进程，调用SystemServer的main方法，从而进入到java层的system\_server进程的初始化流程中；

**zygote进程初始化源代码分析：**

代码位置：“frameworks/base/core/java/com/android/internal/os/

zygote进程是由init.rc文件中启动的，如下：

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
        class main
        socket zygote stream 660 root system
        onrestart write /sys/android_power/request_state wake
        onrestart write /sys/power/state on
        onrestart restart media
        onrestart restart netd

**app\_process：**

其中app\_process被编译成一个可执行程序，

代码位置：frameworks\\base\\cmds\\app\_process，分析如下：

1）Android.mk:

Android.mk:
    LOCAL_PATH:= $(call my-dir)
    include $(CLEAR_VARS)
     
    LOCAL_SRC_FILES:= \
        app_main.cpp
     
    LOCAL_SHARED_LIBRARIES := \
        libcutils \
        libutils \
        libandroid_runtime
     
    LOCAL_MODULE:= app_process
     
    include $(BUILD_EXECUTABLE)

其中，app\_main.cpp是入口，而且，引用了libandroid\_runtime库。

**2）app\_main.cpp:**

看一下app\_main.cpp的main函数：

int main(int argc, const char* const argv[])
    {
        // These are global variables in ProcessState.cpp
        mArgC = argc;
        mArgV = argv;
     
        mArgLen = 0;
        for (int i=0; i<argc; i++) {
            mArgLen += strlen(argv[i]) + 1;
        }
        mArgLen--;
     
        AppRuntime runtime;
        const char* argv0 = argv[0];
     
        // Process command line arguments
        // ignore argv[0]
        argc--;
        argv++;
     
        // Everything up to '--' or first non '-' arg goes to the vm
     
        int i = runtime.addVmArguments(argc, argv);
     
        // Parse runtime arguments.  Stop at first unrecognized option.
        bool zygote = false;
        bool startSystemServer = false;
        bool application = false;
        const char* parentDir = NULL;
        const char* niceName = NULL;
        const char* className = NULL;
        while (i < argc) {
            const char* arg = argv[i++];
            if (!parentDir) {
                parentDir = arg;
            } else if (strcmp(arg, "--zygote") == 0) {
                zygote = true;
                niceName = "zygote";
            } else if (strcmp(arg, "--start-system-server") == 0) {
                startSystemServer = true;
            } else if (strcmp(arg, "--application") == 0) {
                application = true;
            } else if (strncmp(arg, "--nice-name=", 12) == 0) {
                niceName = arg + 12;
            } else {
                className = arg;
                break;
            }
        }
     
        if (niceName && *niceName) {
            setArgv0(argv0, niceName);
            set_process_name(niceName);
        }
     
        runtime.mParentDir = parentDir;
     
        if (zygote) {
            runtime.start("com.android.internal.os.ZygoteInit",
                    startSystemServer ? "start-system-server" : "");
        } else if (className) {
            // Remainder of args get passed to startup class main()
            runtime.mClassName = className;
            runtime.mArgC = argc - i;
            runtime.mArgV = argv + i;
            runtime.start("com.android.internal.os.RuntimeInit",
                    application ? "application" : "tool");
        } else {
            fprintf(stderr, "Error: no class name or --zygote supplied.\n");
            app_usage();
            LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
            return 10;
        }
    }

分析：

(1)根据输入参数来判断，该如何进行runtime.start参数的配置。在上面的initl.rc中，参数是：

> \-Xzygote /system/bin --zygote --start-system-server

所以 ，有：

> zygote = true;
> 
> startSystemServer = true;

然后，会执行到：

> runtime.start("com.android.internal.os.ZygoteInit",  
> startSystemServer ? "start-system-server" : "");

去通过ZygoteInit来继续进行zygote的初始化流程。

**3）runtime：**

既然ZygoteIni由truntime.start来运行，看一下runtime的实现：

类图：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_10_color_FFFFFF_t_70_g_se_x_16][]

流程图：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_17_color_FFFFFF_t_70_g_se_x_16][]

分析：

如果是“--zygote”，则启动zygote进程相关代码；

否则，会根据参数，启动（创建）参数所在的app。

**4）ZygoteInit：**

在分析完runtime之后，再来看一runtime.start的第一个参数“

com.android.internal.os.ZygoteInit

”的相关实现：

代码位置：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java。

这是个java代码，也就是说，执行了大半天，这时候终于执行到了java代码，有runtime（即dvm虚拟机的runtime运行时库）启动了java代码。看一下这个目录的代码文件（已经是java代码了）：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_13_color_FFFFFF_t_70_g_se_x_16][]

在这个目录下，没有Android.mk文件。这是因为这已经是java层了，而不是native层。对于java层的代码来说，只是说是不是要打包到jar中。而对于C/C++来说，要编译成lib,或者exe。

其中，ZygoteInit的 流程图如下：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

分析：

（1）为zygote注册一个socket，并且保存起来，保存到

sServerSocket  
变量中；这是一个LocalServerSocket类型的socket，详细代码如下：

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

同时，创建了文件描述符FileDescriptor, 即ANDROID\_SOCKET\_ENV环境变量对应的文件描述符FileDescriptor，ANDROID\_SOCKET\_ENV的定义：

private static final String ANDROID\_SOCKET\_ENV = "ANDROID\_SOCKET\_zygote";  
（2）预加载一些class和资源文件。这样的好处是，会加快app的启动。当一个app启动时，就不需要重新加载这些资源了；

（3）孵化（fork）SystemServer进程：Zygote::SystemServer就会通过系统调用fork函数来创建一个新的进程，这个进程就是SystemServer；

（4）然后，执行到SystemServer的main方法，这是一个java类，整个SystemServer的文件中，定义了两个类，如下：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

**5) SystemServer:**

在SystemServer.main方法中，

> System.loadLibrary("android\_servers"); //加载“android\_servers”库  
> init1(args); //这是个jni接口，会再调用到native层的init1方法中。

然后，init1会执行到native层，然后再通过native层调用到java层的init2方法，相关代码流程：

> SystemServer.java -> com\_android\_server\_SystemServer.cpp -> system\_init.cpp ->SystemServer.java

com\_android\_server\_SystemServer.cpp的init1函数:

static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
    {
        system_init();
    }
    system_init的实现（在system_init.cpp文件中）：
    
    extern "C" status_t system_init()
    {
        ALOGI("Entered system_init()");
     
        sp<ProcessState> proc(ProcessState::self());
     
        sp<IServiceManager> sm = defaultServiceManager();
        ALOGI("ServiceManager: %p\n", sm.get());
     
        sp<GrimReaper> grim = new GrimReaper();
        sm->asBinder()->linkToDeath(grim, grim.get(), 0);
     
        char propBuf[PROPERTY_VALUE_MAX];
        property_get("system_init.startsurfaceflinger", propBuf, "1");
        if (strcmp(propBuf, "1") == 0) {
            // Start the SurfaceFlinger
            SurfaceFlinger::instantiate();
        }
     
        property_get("system_init.startsensorservice", propBuf, "1");
        if (strcmp(propBuf, "1") == 0) {
            // Start the sensor service
            SensorService::instantiate();
        }
     
        // And now start the Android runtime.  We have to do this bit
        // of nastiness because the Android runtime initialization requires
        // some of the core system services to already be started.
        // All other servers should just start the Android runtime at
        // the beginning of their processes's main(), before calling
        // the init function.
        ALOGI("System server: starting Android runtime.\n");
        AndroidRuntime* runtime = AndroidRuntime::getRuntime();
     
        ALOGI("System server: starting Android services.\n");
        JNIEnv* env = runtime->getJNIEnv();
        if (env == NULL) {
            return UNKNOWN_ERROR;
        }
        jclass clazz = env->FindClass("com/android/server/SystemServer");
        if (clazz == NULL) {
            return UNKNOWN_ERROR;
        }
        jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");
        if (methodId == NULL) {
            return UNKNOWN_ERROR;
        }
        env->CallStaticVoidMethod(clazz, methodId);
     
        ALOGI("System server: entering thread pool.\n");
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
        ALOGI("System server: exiting thread pool.\n");
     
        return NO_ERROR;
    }

**分析：**

在init1函数，启动一写service（如果没有启动的话）；然后，创建一个runtime，由runtime去调用到java层的SystemServer类的init2方法；最后，将其加入线程池。

那好，我嗯再回到SystemServer类的init2方法，如下：

public static final void init2() {
            Slog.i(TAG, "Entered the Android system server!");
            Thread thr = new ServerThread();
            thr.setName("android.server.ServerThread");
            thr.start();
        }

在init2中，启动了ServerThread。

**6）ServerThread:**

所以，整个SystemServer其实，最关键的实体是这个ServerThread线程。我们之间看run函数的实现：

@Override
        public void run() {
            
            Looper.prepare();
     
            android.os.Process.setThreadPriority(
                    android.os.Process.THREAD_PRIORITY_FOREGROUND);
     
            BinderInternal.disableBackgroundScheduling(true);
            android.os.Process.setCanSelfBackground(false);
     
            
            LightsService lights = null;
            PowerManagerService power = null;
            BatteryService battery = null;
            VibratorService vibrator = null;
            AlarmManagerService alarm = null;
            NetworkManagementService networkManagement = null;
            NetworkStatsService networkStats = null;
            NetworkPolicyManagerService networkPolicy = null;
            ConnectivityService connectivity = null;
            
            ......
     
            // Critical services...
            try {
                Slog.i(TAG, "Entropy Mixer");
                ServiceManager.addService("entropy", new EntropyMixer());
     
                Slog.i(TAG, "Power Manager");
                power = new PowerManagerService();
                ServiceManager.addService(Context.POWER_SERVICE, power);
     
                ......
     
                pm = PackageManagerService.main(context,
                        factoryTest != SystemServer.FACTORY_TEST_OFF,
                        onlyCore);
                boolean firstBoot = false;
                try {
                    firstBoot = pm.isFirstBoot();
                } catch (RemoteException e) {
                }
     
                ActivityManagerService.setSystemProcess();
     
                mContentResolver = context.getContentResolver();
     
                // The AccountManager must come before the ContentService
                try {
                    Slog.i(TAG, "Account Manager");
                    ServiceManager.addService(Context.ACCOUNT_SERVICE,
                            new AccountManagerService(context));
                } catch (Throwable e) {
                    Slog.e(TAG, "Failure starting Account Manager", e);
                }
     
                ......
     
            } catch (RuntimeException e) {
                Slog.e("System", "******************************************");
                Slog.e("System", "************ Failure starting core service", e);
            }
     
            DevicePolicyManagerService devicePolicy = null;
            StatusBarManagerService statusBar = null;
            InputMethodManagerService imm = null;
            AppWidgetService appWidget = null;
            NotificationManagerService notification = null;
            WallpaperManagerService wallpaper = null;
            LocationManagerService location = null;
            CountryDetectorService countryDetector = null;
            TextServicesManagerService tsms = null;
            LockSettingsService lockSettings = null;
            DreamManagerService dreamy = null;
     
            // Bring up services needed for UI.
            if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
                try {
                    Slog.i(TAG, "Input Method Service");
                    imm = new InputMethodManagerService(context, wm);
                    ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm);
                } catch (Throwable e) {
                    reportWtf("starting Input Manager Service", e);
                }
     
                try {
                    Slog.i(TAG, "Accessibility Manager");
                    ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,
                            new AccessibilityManagerService(context));
                } catch (Throwable e) {
                    reportWtf("starting Accessibility Manager", e);
                }
            }
     
            try {
                wm.displayReady();
            } catch (Throwable e) {
                reportWtf("making display ready", e);
            }
     
            try {
                pm.performBootDexOpt();
            } catch (Throwable e) {
                reportWtf("performing boot dexopt", e);
            }
     
            try {
                ActivityManagerNative.getDefault().showBootMessage(
                        context.getResources().getText(
                                com.android.internal.R.string.android_upgrading_starting_apps),
                                false);
            } catch (RemoteException e) {
            }
     
            if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
                MountService mountService = null;
                if (!"0".equals(SystemProperties.get("system_init.startmountservice"))) {
                    try {
                        /*
                         * NotificationManagerService is dependant on MountService,
                         * (for media / usb notifications) so we must start MountService first.
                         */
                        Slog.i(TAG, "Mount Service");
                        mountService = new MountService(context);
                        ServiceManager.addService("mount", mountService);
                    } catch (Throwable e) {
                        reportWtf("starting Mount Service", e);
                    }
                }
     
                try {
                    Slog.i(TAG,  "LockSettingsService");
                    lockSettings = new LockSettingsService(context);
                    ServiceManager.addService("lock_settings", lockSettings);
                } catch (Throwable e) {
                    reportWtf("starting LockSettingsService service", e);
                }
     
                try {
                    Slog.i(TAG, "Device Policy");
                    devicePolicy = new DevicePolicyManagerService(context);
                    ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, devicePolicy);
                } catch (Throwable e) {
                    reportWtf("starting DevicePolicyService", e);
                }
     
                ......
            }
     
            
     
            // These are needed to propagate to the runnable below.
            final Context contextF = context;
            final BatteryService batteryF = battery;
            final NetworkManagementService networkManagementF = networkManagement;
            final NetworkStatsService networkStatsF = networkStats;
            final NetworkPolicyManagerService networkPolicyF = networkPolicy;
            final ConnectivityService connectivityF = connectivity;
            final DockObserver dockF = dock;
            final UsbService usbF = usb;
     
            ......
     
            
            Looper.loop();
            Slog.d(TAG, "System ServerThread is exiting!");
        }

说明：

在这个run方法中，初始化了Android系统框架层的各种service，包括：

> PowerManagerService：电源管理服务
> 
> BatteryService：电池服务
> 
> PackageManagerService：包管理服务
> 
> ActivityManagerService：activity管理服务
> 
> NetworkStatsService：网络状态服务
> 
> ......

这样，Android系统框架层的SystemServer进程启动完毕，许多srevice组件也都初始化好了。

至此，整个zygote就完成了它的使命，最终把Android系统框架层的SystemServer进程启动完毕做为结束点。

**7）runSelectLoopMode函数:**

在初始化完的SystemServer进程后，就进入一个循环中，即runSelectLoopMode函数的执行。等待客户端的请求事件，如果有请求事件，就去创建进程，这就涉及到应用进程的创建了，这部分内容在下一节讨论。

[Android系统的心脏-Zygote进程如何fork一个新的应用进程][Android_-Zygote_fork]

--------------------

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/6e392f487b754716a1a0b714b44af9d0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_10_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/ba0488fa1ffb4a3e824915c4aa255158.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_10,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_17_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/26a6208aaa8840f4acc38f9c4a9951bb.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_17,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_13_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/8fc72b05707349ada26483e58b2cbeaa.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_13,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/d4867359f70b463ea8d19be21aa91588.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/f316cc69ba364d3fbe0de1408f63ab82.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[Android_-Zygote_fork]: https://blog.csdn.net/liranke/article/details/5602763