（注：以下代码分析基于android-10.0.0_r30）

一概述

之前介绍Zygote进程启动的时候说到了Zygote会启动SystemServer，当时因为篇幅有限所以并没有深究，现在就来深入了解一下，Zygote启动SystemServer的细节，以及SystemServer启动之后又做了那些事

源码目录

frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
frameworks/base/services/java/com/android/server/SystemServer.java

二 SystemServer的启动

关于forkSystemServer这个方法，之前Zygote的启动里面已经有说明了，这里我们只关注两个方法

forkSystemServer
handleSystemServerProcess

[ZygoteInit.java]

private static Runnable forkSystemServer(String abiList, String socketName,
        ZygoteServer zygoteServer) {
    ...

    try {
        //方法1
        pid = Zygote.forkSystemServer(
                parsedArgs.mUid, parsedArgs.mGid,
                parsedArgs.mGids,
                parsedArgs.mRuntimeFlags,
                null,
                parsedArgs.mPermittedCapabilities,
                parsedArgs.mEffectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        throw new RuntimeException(ex);
    }

    if (pid == 0) {
        if (hasSecondZygote(abiList)) {
            waitForSecondaryZygote(socketName);
        }

        zygoteServer.closeServerSocket();
        //方法2
        return handleSystemServerProcess(parsedArgs);
    }

    return null;
}

首先是方法1：这个方法是一个native方法，它最终会调用到native层，进行ForkCommon，并且将SystemServer的生死和Zygote进行绑定（见Zygote的启动篇）

然后是方法2：这个方法处理的是SystemServer进程创建之后的一些事情

2.1 handleSystemServerProcess

[ZygoteInit.java]

private static Runnable handleSystemServerProcess(ZygoteArguments parsedArgs) {
    // 设置权限
    Os.umask(S_IRWXG | S_IRWXO);
    ...

    //找到SystemServer的ClassPath
    final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
    if (systemServerClasspath != null) {
        ...
    }

    if (parsedArgs.mInvokeWith != null) {
        ...
    } else {
        //构建cl
        createSystemServerClassLoader();
        ClassLoader cl = sCachedSystemServerClassLoader;
        if (cl != null) {
            Thread.currentThread().setContextClassLoader(cl);
        }

        //将cl传递进去
        return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
                parsedArgs.mRemainingArgs, cl);
    }
}

关于handleSystemServerProcess，主要就是构建SystemServer的参数，并传递到ZygoteInit.zygoteInit中，关于zygoteInit这个方法，主要会做三件事，然后最后调用到参数类的main方法（见Zygote的工作原理），因为这里的参数是SystemServer，所以会调用到SystemServer的main方法

三 SystemServer.java

3.1 main

[SystemServer.java]

public static void main(String[] args) {
    new SystemServer().run();
}

3.2 run

关于SystemServer的run方法，里面做的事情比较多，不过因为都比较重要，所以这里没有省略，尽量每一行代码都添加了作用的注释，对于这个方法所做的事情如下

做一些信息的保存
做一些属性的设置
做一些虚拟机的设置
做一些binder相关的设置
加载android_servers的so库
创建SystemServiceManager并注册binder
开始分批启动服务
进入loop循环

[SystemServer.java]

private void run() {
    try {
        traceBeginAndSlog("InitBeforeStartServices");

        // 将启动时的一些信息保存
        SystemProperties.set(SYSPROP_START_COUNT, String.valueOf(mStartCount));
        SystemProperties.set(SYSPROP_START_ELAPSED, String.valueOf(mRuntimeStartElapsedTime));
        SystemProperties.set(SYSPROP_START_UPTIME, String.valueOf(mRuntimeStartUptime));

        EventLog.writeEvent(EventLogTags.SYSTEM_SERVER_START,
                mStartCount, mRuntimeStartUptime, mRuntimeStartElapsedTime);

        //如果系统时钟在1970年之前(时间戳小于0)，那么就伪造一个时间
        if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
            Slog.w(TAG, "System clock is before 1970; setting to 1970.");
            SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
        }

        //如果没有时区，就设置一个默认时区GMT
        String timezoneProperty = SystemProperties.get("persist.sys.timezone");
        if (timezoneProperty == null || timezoneProperty.isEmpty()) {
            Slog.w(TAG, "Timezone not set; setting to GMT.");
            SystemProperties.set("persist.sys.timezone", "GMT");
        }

        //如果系统设置了persist.sys.language，就将其替换为persist.sys.locale
        if (!SystemProperties.get("persist.sys.language").isEmpty()) {
            final String languageTag = Locale.getDefault().toLanguageTag();

            SystemProperties.set("persist.sys.locale", languageTag);
            SystemProperties.set("persist.sys.language", "");
            SystemProperties.set("persist.sys.country", "");
            SystemProperties.set("persist.sys.localevar", "");
        }

        //系统服务器绝不能进行非单向调用
        Binder.setWarnOnBlocking(true);
        //系统服务器应始终加载安全标签
        PackageItemInfo.forceSafeLabels();

        // 设置默认值
        SQLiteGlobal.sDefaultSyncMode = SQLiteGlobal.SYNC_MODE_FULL;

        //停用SQLiteCompatibilityWalFlags等到程序初始化
        SQLiteCompatibilityWalFlags.init(null);

        // 开始android system server，之前都是一些配置，可以不关心
        Slog.i(TAG, "Entered the Android system server!");
        int uptimeMillis = (int) SystemClock.elapsedRealtime();
        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
        if (!mRuntimeRestart) {
            MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
        }

        // 切换虚拟机库
        SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

        // 启动时为了效率，清除内存上限
        VMRuntime.getRuntime().clearGrowthLimit();

        // 设置内存使用效率
        VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

        //有些设备依赖运行时指纹生成，所以在进一步启动之前定义它。
        Build.ensureFingerprintProperty();

        //系统服务内，访问环境变量时需要明确指定用户
        Environment.setUserRequired(true);

        //系统服务器内，所有传入的捆绑包都需要被解除，避免BadParcelableException
        BaseBundle.setShouldDefuse(true);

        //系统服务器内，打包异常时需要包含堆栈信息
        Parcel.setStackTraceParceling(true);

        // 确保binder调用时处于前台优先级
        BinderInternal.disableBackgroundScheduling(true);

        // 设置最大的binder线程数，值是31
        BinderInternal.setMaxThreads(sMaxBinderThreads);

        // 准备主线程looper.
        android.os.Process.setThreadPriority(
                android.os.Process.THREAD_PRIORITY_FOREGROUND);
        android.os.Process.setCanSelfBackground(false);
        Looper.prepareMainLooper();
        Looper.getMainLooper().setSlowLogThresholdMs(
                SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);

        // 加载so库
        System.loadLibrary("android_servers");

        // debug相关
        if (Build.IS_DEBUGGABLE) {
            initZygoteChildHeapProfiling();
        }

        //检查上次关机是否失败
        performPendingShutdown();

        //初始化系统上下文
        createSystemContext();

        // 创建SystemServiceManager
        mSystemServiceManager = new SystemServiceManager(mSystemContext);
        mSystemServiceManager.setStartInfo(mRuntimeRestart,
                mRuntimeStartElapsedTime, mRuntimeStartUptime);
        //注册SystemServiceManager
        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
        //准备任务的线程池
        SystemServerInitThreadPool.get();
    } finally {
        traceEnd();  // InitBeforeStartServices
    }

    // Start services.
    try {
        //开始分批启动服务
        traceBeginAndSlog("StartServices");
        //boot服务
        startBootstrapServices();
        //核心服务
        startCoreServices();
        //其他服务
        startOtherServices();
        //干掉线程池
        SystemServerInitThreadPool.shutdown();
    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    } finally {
        traceEnd();
    }
    //严苛模式（这玩意我们也可以用）
    StrictMode.initVmDefaults(null);

    //如果服务没有启动，打印一些日志
    if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
        int uptimeMillis = (int) SystemClock.elapsedRealtime();
        MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
        final int MAX_UPTIME_MILLIS = 60 * 1000;
        if (uptimeMillis > MAX_UPTIME_MILLIS) {
            Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
                    "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
        }
    }

    //保证系统处于正常状态
    if (!VMRuntime.hasBootImageSpaces()) {
        Slog.wtf(TAG, "Runtime is not running with a boot image!");
    }

    // 开始loop循环
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

四服务的分批启动

4.1 startBootstrapServices

[SystemServer.java]

private void startBootstrapServices() {
    //Watchdog 性能检测
    final Watchdog watchdog = Watchdog.getInstance();
    watchdog.start();
    traceEnd();

    //SystemConfig
    final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
    traceBeginAndSlog(TAG_SYSTEM_CONFIG);
    SystemServerInitThreadPool.get().submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
    traceEnd();

    // Installer
    traceBeginAndSlog("StartInstaller");
    Installer installer = mSystemServiceManager.startService(Installer.class);
    traceEnd();

    // DeviceIdentifiersPolicyService
    traceBeginAndSlog("DeviceIdentifiersPolicyService");
    mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
    traceEnd();

    // UriGrantsManagerService
    traceBeginAndSlog("UriGrantsManagerService");
    mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class);
    traceEnd();

    // ActivityTaskManagerService
    // ActivityManagerService
    traceBeginAndSlog("StartActivityManager");
    // TODO: Might need to move after migration to WM.
    ActivityTaskManagerService atm = mSystemServiceManager.startService(
            ActivityTaskManagerService.Lifecycle.class).getService();
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(
            mSystemServiceManager, atm);
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    mWindowManagerGlobalLock = atm.getGlobalLock();
    traceEnd();

    // PowerManagerService
    traceBeginAndSlog("StartPowerManager");
    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
    traceEnd();

    //ThermalManagerService
    traceBeginAndSlog("StartThermalManager");
    mSystemServiceManager.startService(ThermalManagerService.class);
    traceEnd();

    // 初始化 PowerManager
    traceBeginAndSlog("InitPowerManagement");
    mActivityManagerService.initPowerManagement();
    traceEnd();

    // RecoverySystemService
    traceBeginAndSlog("StartRecoverySystemService");
    mSystemServiceManager.startService(RecoverySystemService.class);
    traceEnd();

    // 
    RescueParty.noteBoot(mSystemContext);

    // LightsService
    traceBeginAndSlog("StartLightsService");
    mSystemServiceManager.startService(LightsService.class);
    traceEnd();

    //SidekickService
    traceBeginAndSlog("StartSidekickService");
    // Package manager isn't started yet; need to use SysProp not hardware feature
    if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false)) {
        mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS);
    }
    traceEnd();

    // DisplayManagerService
    traceBeginAndSlog("StartDisplayManager");
    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
    traceEnd();

    //使用默认显示
    traceBeginAndSlog("WaitForDisplay");
    mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
    traceEnd();

    // 当设备正在加密时，仅运行核心app
    String cryptState = VoldProperties.decrypt().orElse("");
    if (ENCRYPTING_STATE.equals(cryptState)) {
        Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
        mOnlyCore = true;
    } else if (ENCRYPTED_STATE.equals(cryptState)) {
        Slog.w(TAG, "Device encrypted - only parsing core apps");
        mOnlyCore = true;
    }

    // PackageManagerService
    if (!mRuntimeRestart) {
        MetricsLogger.histogram(null, "boot_package_manager_init_start",
                (int) SystemClock.elapsedRealtime());
    }
    traceBeginAndSlog("StartPackageManagerService");
    try {
        Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain");
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    } finally {
        Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain");
    }
    mFirstBoot = mPackageManagerService.isFirstBoot();
    mPackageManager = mSystemContext.getPackageManager();
    traceEnd();

    if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
        MetricsLogger.histogram(null, "boot_package_manager_init_ready",
                (int) SystemClock.elapsedRealtime());
    }
    // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
    // A/B artifacts after boot, before anything else might touch/need them.
    // Note: this isn't needed during decryption (we don't have /data anyways).
    if (!mOnlyCore) {
        boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
                false);
        if (!disableOtaDexopt) {
            traceBeginAndSlog("StartOtaDexOptService");
            try {
                Watchdog.getInstance().pauseWatchingCurrentThread("moveab");
                OtaDexoptService.main(mSystemContext, mPackageManagerService);
            } catch (Throwable e) {
                reportWtf("starting OtaDexOptService", e);
            } finally {
                Watchdog.getInstance().resumeWatchingCurrentThread("moveab");
                traceEnd();
            }
        }
    }

    // UserManagerService
    traceBeginAndSlog("StartUserManagerService");
    mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
    traceEnd();

    // 初始化 AttributeCache
    traceBeginAndSlog("InitAttributerCache");
    AttributeCache.init(mSystemContext);
    traceEnd();

    // 为系统进程设置Application实例
    traceBeginAndSlog("SetSystemProcess");
    mActivityManagerService.setSystemProcess();
    traceEnd();

    // watchdog 性能监控
    traceBeginAndSlog("InitWatchdog");
    watchdog.init(mSystemContext, mActivityManagerService);
    traceEnd();

    // DisplayManagerService需要设置调度相关政策
    mDisplayManagerService.setupSchedulerPolicies();

    // OverlayManagerService
    traceBeginAndSlog("StartOverlayManagerService");
    mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));
    traceEnd();

    //SensorPrivacyService
    traceBeginAndSlog("StartSensorPrivacyService");
    mSystemServiceManager.startService(new SensorPrivacyService(mSystemContext));
    traceEnd();

    if (SystemProperties.getInt("persist.sys.displayinset.top", 0) > 0) {
        // DisplayManager needs the overlay immediately.
        mActivityManagerService.updateSystemUiContext();
        LocalServices.getService(DisplayManagerInternal.class).onOverlayChanged();
    }

    // 因为传感器服务依赖一些其他的服务，所以之后再启动它
    mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
        TimingsTraceLog traceLog = new TimingsTraceLog(
                SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
        traceLog.traceBegin(START_SENSOR_SERVICE);
        //启动传感器服务
        startSensorService();
        traceLog.traceEnd();
    }, START_SENSOR_SERVICE);
}

4.2 startCoreServices

[SystemServer.java]

private void startCoreServices() {
    // BatteryService
    traceBeginAndSlog("StartBatteryService");
    mSystemServiceManager.startService(BatteryService.class);
    traceEnd();

    // UsageStatsService
    traceBeginAndSlog("StartUsageService");
    mSystemServiceManager.startService(UsageStatsService.class);
    mActivityManagerService.setUsageStatsManager(
            LocalServices.getService(UsageStatsManagerInternal.class));
    traceEnd();

    // WebViewUpdateService
    if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
        traceBeginAndSlog("StartWebViewUpdateService");
        mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
        traceEnd();
    }

    // CachedDeviceStateService 磁盘缓存状态
    traceBeginAndSlog("StartCachedDeviceStateService");
    mSystemServiceManager.startService(CachedDeviceStateService.class);
    traceEnd();

    // BinderCallsStatsService
    traceBeginAndSlog("StartBinderCallsStatsService");
    mSystemServiceManager.startService(BinderCallsStatsService.LifeCycle.class);
    traceEnd();

    // LooperStatsService
    traceBeginAndSlog("StartLooperStatsService");
    mSystemServiceManager.startService(LooperStatsService.Lifecycle.class);
    traceEnd();

    // RollbackManagerService
    traceBeginAndSlog("StartRollbackManagerService");
    mSystemServiceManager.startService(RollbackManagerService.class);
    traceEnd();

    // BugreportManagerService 这个是bugreport，一般我们获取日志会用到
    traceBeginAndSlog("StartBugreportManagerService");
    mSystemServiceManager.startService(BugreportManagerService.class);
    traceEnd();

    // GpuService
    traceBeginAndSlog("GpuService");
    mSystemServiceManager.startService(GpuService.class);
    traceEnd();
}

4.3 startOtherServices的第一部分

startOtherServices的总代码比较长，这里就不全部列举了，它主要做了两件事情，第一件事情就是启动各种系统服务

[SystemServer.java]

//启动其他服务，总共代码约1400行，这里就不详细说明了，只简单列举几个
private void startOtherServices() {
    ...

    try {
        ...

        //钥匙串服务
        traceBeginAndSlog("StartKeyChainSystemService");
        mSystemServiceManager.startService(KeyChainSystemService.class);
        traceEnd();
        ...

        // AccountManager 账号管理
        traceBeginAndSlog("StartAccountManagerService");
        mSystemServiceManager.startService(ACCOUNT_SERVICE_CLASS);
        traceEnd();

        // AlarmManagerService 时钟管理
        traceBeginAndSlog("StartAlarmManagerService");
        mSystemServiceManager.startService(new AlarmManagerService(context));
        traceEnd();

        //InputManagerService 输入
        traceBeginAndSlog("StartInputManagerService");
        inputManager = new InputManagerService(context);
        traceEnd();

        // WMS 最重要的服务之一
        traceBeginAndSlog("StartWindowManagerService");
        wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
                new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);
        ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
                DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
        ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
                /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
        traceEnd();

        ...

        if (mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL) {
            Slog.i(TAG, "No Bluetooth Service (factory test)");
        } else if (!context.getPackageManager().hasSystemFeature
                (PackageManager.FEATURE_BLUETOOTH)) {
            Slog.i(TAG, "No Bluetooth Service (Bluetooth Hardware Not Present)");
        } else {
            //BluetoothService 蓝牙
            traceBeginAndSlog("StartBluetoothService");
            mSystemServiceManager.startService(BluetoothService.class);
            traceEnd();
        }

        ...
}

4.4 startOtherServices

第二部分就是调用AMS的systemReady，关于桌面的启动，也是和这个AMS的systemReady相关的，因为桌面的启动又是一个较长的流程，所以放在之后再进行说明

[SystemServer.java]

//启动其他服务，总共代码约1400行，这里就不详细说明了，只列举一些我们常见的
private void startOtherServices() {
        ...

        // 所有的服务都启动完毕，开始启动桌面
        mActivityManagerService.systemReady(() -> {
            Slog.i(TAG, "Making services ready");
            traceBeginAndSlog("StartActivityManagerReadyPhase");
            mSystemServiceManager.startBootPhase(
                    SystemService.PHASE_ACTIVITY_MANAGER_READY);
            traceEnd();

            //监控native crash
            traceBeginAndSlog("StartObservingNativeCrashes");
            try {
                mActivityManagerService.startObservingNativeCrashes();
            } catch (Throwable e) {
                reportWtf("observing native crashes", e);
            }
            traceEnd();

            // 启动webview
            final String WEBVIEW_PREPARATION = "WebViewFactoryPreparation";
            Future<?> webviewPrep = null;
            if (!mOnlyCore && mWebViewUpdateService != null) {
                webviewPrep = SystemServerInitThreadPool.get().submit(() -> {
                    Slog.i(TAG, WEBVIEW_PREPARATION);
                    TimingsTraceLog traceLog = new TimingsTraceLog(
                            SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
                    traceLog.traceBegin(WEBVIEW_PREPARATION);
                    ConcurrentUtils.waitForFutureNoInterrupt(mZygotePreload, "Zygote preload");
                    mZygotePreload = null;
                    mWebViewUpdateService.prepareWebViewInSystemServer();
                    traceLog.traceEnd();
                }, WEBVIEW_PREPARATION);
            }

            if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
                traceBeginAndSlog("StartCarServiceHelperService");
                mSystemServiceManager.startService(CAR_SERVICE_HELPER_SERVICE_CLASS);
                traceEnd();
            }

            //启动SystemUI
            traceBeginAndSlog("StartSystemUI");
            try {
                startSystemUi(context, windowManagerF);
            } catch (Throwable e) {
                reportWtf("starting System UI", e);
            }
            traceEnd();

            //执行networkManagementF.systemReady()
            traceBeginAndSlog("MakeNetworkManagementServiceReady");
            try {
                if (networkManagementF != null) {
                    networkManagementF.systemReady();
                }
            } catch (Throwable e) {
                reportWtf("making Network Managment Service ready", e);
            }
            CountDownLatch networkPolicyInitReadySignal = null;
            if (networkPolicyF != null) {
                networkPolicyInitReadySignal = networkPolicyF
                        .networkScoreAndNetworkManagementServiceReady();
            }
            traceEnd();

            //执行ipSecServiceF.systemReady()
            traceBeginAndSlog("MakeIpSecServiceReady");
            try {
                if (ipSecServiceF != null) {
                    ipSecServiceF.systemReady();
                }
            } catch (Throwable e) {
                reportWtf("making IpSec Service ready", e);
            }
            traceEnd();
            //还有一系列的systemReady
            ...

            // 等待所有的appdata准备好
            mPackageManagerService.waitForAppDataPrepared();

            //让系统服务启动三方三方代码
            traceBeginAndSlog("PhaseThirdPartyAppsCanStart");
            // confirm webview completion before starting 3rd party
            if (webviewPrep != null) {
                ConcurrentUtils.waitForFutureNoInterrupt(webviewPrep, WEBVIEW_PREPARATION);
            }
            mSystemServiceManager.startBootPhase(
                    SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
            traceEnd();

            ...

            //接下来就是一系列的systemRunning
            traceBeginAndSlog("MakeLocationServiceReady");
            try {
                if (locationF != null) {
                    locationF.systemRunning();
                }
            } catch (Throwable e) {
                reportWtf("Notifying Location Service running", e);
            }
            traceEnd();
            traceBeginAndSlog("MakeCountryDetectionServiceReady");
            try {
                if (countryDetectorF != null) {
                    countryDetectorF.systemRunning();
                }
            } catch (Throwable e) {
                reportWtf("Notifying CountryDetectorService running", e);
            }
            traceEnd();
            ...
            //systemRunning结束
        }, BOOT_TIMINGS_TRACE_LOG);
    }
}

五总结

SystemServer作为Zygote启动流程中，最重要的一个进程，甚至生死和都和Zygote绑定，可见它的作用是非常重要的。
在SystemServer启动时，会通过main方法调用到run方法，并且在run方法中做一系列的初始化操作，包括信息保存，属性设置，虚拟机设置，binder设置，so库加载，注册SystemServiceManager，并且分批启动服务
SystemServer的分批启动服务主要分为三个阶段，Boot（引导服务），Core（核心服务），Other（其他服务），这样做主要是为了解决服务启动过程中的依赖问题
启动服务结束后会进入loop循环

注意，并不是所有的服务都是通过SystemServer启动的，由SystemServer启动的服务属于SystemServer进程，还有一些服务是拥有着自己独立的进程，那些服务是通过配置在rc文件中进行启动的，也就是说，如果我们想开发一个系统级的服务，要么就通过配置在rc文件中启动，单独一个进程，要么就通过SystemServer进行启动，和SystemServer处于同一个进程。当然，这两种服务的区别还有很多，以后再详细说明。到此，SystemServer的启动算是结束了，接下来就是桌面Launch的启动

SystemServer的启动

一 概述

源码目录

二 SystemServer的启动

2.1 handleSystemServerProcess

三 SystemServer.java

3.1 main

3.2 run

四 服务的分批启动

4.1 startBootstrapServices

4.2 startCoreServices

4.3 startOtherServices的第一部分

4.4 startOtherServices

五 总结

一概述

四服务的分批启动

五总结