夜雨聆风一、往期回顾
在前面的文章中，我们从 Android 系统启动的源头 init 进程 开始，一路跟随着系统启动的脚步，深入分析了 Zygote 的诞生与启动过程。
我们看到，Android 并不是直接创建每一个应用进程，而是通过 Zygote 这个“孵化器”提前完成虚拟机启动、系统资源预加载，并利用 Linux fork 机制快速复制出新的应用进程。
从 ZygoteInit.main() 开始，我们一步步拆解了：
Zygote 为什么需要 preload？ 为什么预加载的类和资源能够被所有应用共享？ SystemServer 是如何由 Zygote fork 出来的？ ZygoteServer 如何通过 Socket 等待 AMS 请求？ 应用启动请求如何经过 processCommand()最终走到forkAndSpecialize()？新应用进程如何进入 ActivityThread.main()，完成 Android 应用世界的第一次启动？
看似简单的一次 App 启动，其背后其实经历了一条完整的系统链路：
init → Zygote → fork → ActivityThread → App进程
理解 Zygote，就像拿到了一把进入 Android Framework 世界的钥匙。
但 Zygote 只是 Android 系统启动过程中的一个重要节点，它负责“创建世界”，真正管理这个 Android 世界运行的核心角色，是后续启动的 SystemServer。
SystemServer 承载了 Android Framework 中大量核心服务：
ActivityManagerService（AMS） WindowManagerService（WMS） PackageManagerService（PMS） PowerManagerService BatteryService 等等数百个系统服务
这一篇，我们将继续深入 Android Framework 的核心：
SystemServer 是如何被 Zygote 创建？又是如何启动整个 Framework 服务体系的？
从一个进程，到一整套 Android 系统能力，这背后还有更多精彩的源码细节等待我们继续探索。
二、前置概念：什么是 SystemServer？
1. Android 两大核心系统进程
- Zygote
：进程孵化器，专门 fork 新进程（系统进程 + 应用进程）
- system_server
：系统服务容器，Android Framework 所有核心服务的运行载体
2. SystemServer 核心职责
Android 几乎所有系统能力都由 system_server 中的系统服务提供：
AMS / ATMS：四大组件、应用进程调度管理
WMS：窗口、动画、屏幕层级、输入法管理
PMS：APK 安装、解析、权限、包管理
Power、Battery、Network、Bluetooth 等硬件服务
简单一句话：Zygote 负责造进程，SystemServer 负责管系统。
三、system_server 进程创建流程（Zygote 孵化）
Zygote 启动完成后，会在 ZygoteInit.main() 中调用 forkSystemServer()，专门孵化出唯一的系统核心进程 system_server。
源码路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
1. forkSystemServer 完整源码（带详细注释）
/*** 由 Zygote 调用：专门 fork 出 system_server 系统进程* 这是系统唯一一次创建 system_server 进程*/privatestatic Runnable forkSystemServer(String abiList, String socketName,ZygoteServer zygoteServer) {// 1. 初始化 system_server 需要的 Linux 特权权能（精细化权限，非root）long capabilities =(1L << OsConstants.CAP_IPC_LOCK) | // 锁定内存，防止系统服务内存被回收(1L << OsConstants.CAP_KILL) | // 允许杀死任意进程（AMS杀进程依赖）(1L << OsConstants.CAP_NET_ADMIN) | // 网络管理权限(1L << OsConstants.CAP_NET_BIND_SERVICE) |(1L << OsConstants.CAP_NET_BROADCAST) |(1L << OsConstants.CAP_NET_RAW) |(1L << OsConstants.CAP_SYS_MODULE) |(1L << OsConstants.CAP_SYS_NICE) | // 调整进程优先级(1L << OsConstants.CAP_SYS_PTRACE) |(1L << OsConstants.CAP_SYS_TIME) |(1L << OsConstants.CAP_SYS_TTY_CONFIG) |(1L << OsConstants.CAP_WAKE_ALARM) |(1L << OsConstants.CAP_BLOCK_SUSPEND);// 容器环境兼容：过滤掉当前系统不支持的权能StructCapUserHeader header = new StructCapUserHeader(OsConstants._LINUX_CAPABILITY_VERSION_3, 0);StructCapUserData[] data;try {data = Os.capget(header);} catch (ErrnoException ex) {throw new RuntimeException("Failed to capget()", ex);}// 只保留系统真实支持的权限capabilities &= Integer.toUnsignedLong(data[0].effective) |(Integer.toUnsignedLong(data[1].effective) << 32);// 2. 硬编码 system_server 启动参数String[] args = {"--setuid=1000", // 运行用户 system(1000)，降权安全机制"--setgid=1000", // 运行组 system(1000)"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,"+ "1024,1032,1065,3001,3002,3003,3005,3006,3007,3009,3010,3011,3012","--capabilities=" + capabilities + "," + capabilities, // 生效权能"--nice-name=system_server", // 进程名(ps可查)"--runtime-args","--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,"com.android.server.SystemServer" // 最终要执行的入口类};ZygoteArguments parsedArgs;int pid;try {// 3. 解析启动参数ZygoteCommandBuffer commandBuffer = new ZygoteCommandBuffer(args);try {parsedArgs = ZygoteArguments.getInstance(commandBuffer);} catch (EOFException e) {throw new AssertionError("Unexpected argument error for forking system server", e);}commandBuffer.close();// 调试属性、包装运行属性初始化Zygote.applyDebuggerSystemProperty(parsedArgs);Zygote.applyInvokeWithSystemProperty(parsedArgs);// 4. 配置内存安全机制 MTE / TBIif (Zygote.nativeSupportsMemoryTagging()) {String mode = SystemProperties.get("persist.arm64.memtag.system_server", "");if (mode.isEmpty()) {mode = SystemProperties.get("persist.arm64.memtag.default", "async");}if (mode.equals("async")) {parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_ASYNC;} else if (mode.equals("sync")) {parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_SYNC;} else if (!mode.equals("off")) {parsedArgs.mRuntimeFlags |= Zygote.nativeCurrentTaggingLevel();Slog.e(TAG, "Unknown memory tag level for the system server: \"" + mode + "\"");}} else if (Zygote.nativeSupportsTaggedPointers()) {// ARMv8 开启指针标记parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_TBI;}// 5. 开启轻量内存检测 GWP-ASanparsedArgs.mRuntimeFlags |= Zygote.GWP_ASAN_LEVEL_LOTTERY;// 6. 开启性能采样 Profilerif (shouldProfileSystemServer()) {parsedArgs.mRuntimeFlags |= Zygote.PROFILE_SYSTEM_SERVER;}// 7. Native层 fork 创建 system_server 子进程pid = Zygote.forkSystemServer(parsedArgs.mUid, parsedArgs.mGid,parsedArgs.mGids,parsedArgs.mRuntimeFlags,null,parsedArgs.mPermittedCapabilities,parsedArgs.mEffectiveCapabilities);} catch (IllegalArgumentException ex) {throw new RuntimeException(ex);}// ========== 子进程逻辑（system_server 进程） ==========if (pid == 0) {// 双架构设备等待副Zygote就绪if (hasSecondZygote(abiList)) {waitForSecondaryZygote(socketName);}// 关键：关闭Zygote监听Socket，system_server不负责孵化应用zygoteServer.closeServerSocket();// 进入system_server后续初始化流程，返回Runnablereturn handleSystemServerProcess(parsedArgs);}// 父Zygote进程直接返回null，继续监听Socketreturn null;}
2. 启动参数逐行解析（核心）
--setuid=1000：进程运行身份为 system 用户，非 root，安全降权
--setgid=1000：归属 system 用户组
--setgroups：挂载存储、网络、蓝牙、相机等附属权限组
--capabilities：赋予 system_server 精细化 Linux 特权
--nice-name=system_server：指定进程名，方便调试查看
com.android.server.SystemServer：最终反射执行的入口类
四、system_server 进程初始化：handleSystemServerProcess
fork 出子进程后，会执行 handleSystemServerProcess，完成类加载器替换、环境初始化、最终返回启动 SystemServer 的 Runnable。
源码路径：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
privatestatic Runnable handleSystemServerProcess(ZygoteArguments parsedArgs) {// 1. 设置文件权限掩码 0077：系统创建文件仅system用户可访问Os.umask(S_IRWXG | S_IRWXO);// 设置进程名if (parsedArgs.mNiceName != null) {Process.setArgV0(parsedArgs.mNiceName);}// 2. 获取 system_server 专属类路径（独立jar，与应用隔离）final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");// 调试机型：开启系统服务性能采样优化if (systemServerClasspath != null) {if (shouldProfileSystemServer() && (Build.IS_USERDEBUG || Build.IS_ENG)) {try {Log.d(TAG, "Preparing system server profile");final String standaloneSystemServerJars =Os.getenv("STANDALONE_SYSTEMSERVER_JARS");final String systemServerPaths = standaloneSystemServerJars != null? String.join(":", systemServerClasspath, standaloneSystemServerJars): systemServerClasspath;prepareSystemServerProfile(systemServerPaths);try {SystemProperties.set("debug.tracing.profile_system_server", "1");} catch (RuntimeException e) {Slog.e(TAG, "Failed to set debug.tracing.profile_system_server", e);}} catch (Exception e) {Log.wtf(TAG, "Failed to set up system server profile", e);}}}// 开启bootclasspath性能采样if (shouldProfileBootClasspath()) {try {SystemProperties.set("debug.tracing.profile_boot_classpath", "1");} catch (RuntimeException e) {Slog.e(TAG, "Failed to set debug.tracing.profile_boot_classpath", e);}}// 3. 调试包装分支（默认不走）if (parsedArgs.mInvokeWith != null) {String[] args = parsedArgs.mRemainingArgs;if (systemServerClasspath != null) {String[] amendedArgs = new String[args.length + 2];amendedArgs[0] = "-cp";amendedArgs[1] = systemServerClasspath;System.arraycopy(args, 0, amendedArgs, 2, args.length);args = amendedArgs;}WrapperInit.execApplication(parsedArgs.mInvokeWith,parsedArgs.mNiceName, parsedArgs.mTargetSdkVersion,VMRuntime.getCurrentInstructionSet(), null, args);throw new IllegalStateException("Unexpected return from WrapperInit.execApplication");} else {// 4. 创建 system_server 专属类加载器ClassLoader cl = getOrCreateSystemServerClassLoader();if (cl != null) {// 替换主线程上下文加载器，保证能加载系统服务类Thread.currentThread().setContextClassLoader(cl);}// 5. 核心：返回Runnable，最终反射执行SystemServer.main()return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,parsedArgs.mDisabledCompatChanges,parsedArgs.mRemainingArgs, cl);}}
五、关键调用链路（百分百准确）
纠正原文错误：system_server 不会返回 MethodAndArgsCaller，而是普通 Runnable
ZygoteInit.main()└── forkSystemServer()└── pid == 0 子进程分支└── handleSystemServerProcess()└── ZygoteInit.zygoteInit() 返回 Runnable└── Runnable.run()└── AndroidRuntime.zygoteInit()└── AndroidRuntime.finishInit()└── AndroidRuntime.start() 【反射核心入口】├── classLoader.loadClass("com.android.server.SystemServer")├── mainMethod.invoke()└── SystemServer.main()└── new SystemServer().run()
六、SystemServer.run() 核心启动流程
真正开启 Android 所有系统服务的核心方法。
publicstaticvoidmain(String[] args) {new SystemServer().run();}privatevoidrun() {TimingsTraceAndSlog t = new TimingsTraceAndSlog();try {t.traceBegin("InitBeforeStartServices");// 1. 初始化主线程Looper，system_server是单主线程模型Looper.prepareMainLooper();Looper.getMainLooper().setSlowLogThresholdMs(SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);// 2. 加载native服务库 libandroid_servers.soSystem.loadLibrary("android_servers");// 3. 创建系统全局上下文（最关键步骤）createSystemContext();// 初始化Mainline模块化服务ActivityThread.initializeMainlineModules();// 注册系统dump服务ServiceManager.addService("system_server_dumper", mDumper);mDumper.addDumpable(this);// 4. 创建系统服务管理器：所有系统服务的统一管理者mSystemServiceManager = new SystemServiceManager(mSystemContext);mSystemServiceManager.setStartInfo(mRuntimeRestart,mRuntimeStartElapsedTime, mRuntimeStartUptime);mDumper.addDumpable(mSystemServiceManager);// 存入LocalServices（本质是ArrayMap，全局可获取）LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);} finally {t.traceEnd();}// ========== 四段式启动所有系统服务 ==========try {t.traceBegin("StartServices");startBootstrapServices(t); // 引导核心服务 AMS/PMS/WMS依赖基础服务startCoreServices(t); // 系统核心服务 电池/统计/日志等startOtherServices(t); // 杂项服务、UI、蓝牙、定位等startApexServices(t); // 启动Mainline可动态更新服务updateWatchdogTimeout(t);CriticalEventLog.getInstance().logSystemServerStarted();} catch (Throwable ex) {throw ex;} finally {t.traceEnd();}// 设置Binder事务异常回调Binder.setTransactionCallback(new IBinderCallback() {@OverridepublicvoidonTransactionError(int pid, int code, int flags, int err) {mActivityManagerService.frozenBinderTransactionDetected(pid, code, flags, err);}});// 开启主线程无限循环，系统服务常驻运行Looper.loop();throw new RuntimeException("Main thread loop unexpectedly exited");}
七、createSystemContext 系统上下文创建
system_server 没有 APK，依靠 framework-res.apk 提供系统资源与上下文。
private void createSystemContext() {// 创建系统专属ActivityThread（区别于普通App）ActivityThread activityThread = ActivityThread.systemMain();// 全局系统上下文：所有系统服务共用mSystemContext = activityThread.getSystemContext();mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);// SystemUI专属上下文：状态栏、通知、锁屏UI使用final Context systemUiContext = activityThread.getSystemUiContext();systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);// 注册性能追踪Trace.registerWithPerfetto();}
systemMain 系统线程初始化
publicstatic ActivityThread systemMain(){ThreadedRenderer.initForSystemProcess();ActivityThread thread = new ActivityThread();// system=true 标记为系统进程thread.attach(true, 0);return thread;}
八、attach() 系统进程专属初始化
system=true 不走 App 注册 AMS 逻辑，属于系统专属分支。
private void attach(boolean system, long startSeq) {sCurrentActivityThread = this;mConfigurationController = new ConfigurationController(this);mSystemThread = system;mStartSeq = startSeq;mDdmSyncStageUpdater.next(Stage.Attach);if (!system) {// 普通APP进程：向AMS注册自己android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",UserHandle.myUserId());RuntimeInit.setApplicationObject(mAppThread.asBinder());final IActivityManager mgr = ActivityManager.getService();try {mgr.attachApplication(mAppThread, startSeq);} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();}// APP内存GC监控：堆内存超过3/4自动回收后台ActivityBinderInternal.addGcWatcher(new Runnable() {@Override public void run() {if (!mSomeActivitiesChanged) return;Runtime runtime = Runtime.getRuntime();long dalvikMax = runtime.maxMemory();long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();if (dalvikUsed > ((3*dalvikMax)/4)) {mSomeActivitiesChanged = false;try {ActivityTaskManager.getService().releaseSomeActivities(mAppThread);} catch (RemoteException e) {throw e.rethrowFromSystemServer();}}}});} else {// 系统进程：不注册应用Binder、不弹崩溃框，挂了直接重启整机android.ddm.DdmHandleAppName.setAppName("system_process",UserHandle.myUserId());initializeSystemThread(this);}// 全局配置变更监听（语言/黑夜/字体/分辨率）ViewRootImpl.ConfigChangedCallback configChangedCallback = (Configuration globalConfig) -> {synchronized (mResourcesManager) {if (mResourcesManager.applyConfigurationToResources(globalConfig,null)) {mConfigurationController.updateLocaleListFromAppContext(mInitialApplication.getApplicationContext());final Configuration updatedConfig =mConfigurationController.updatePendingConfiguration(globalConfig);if (updatedConfig != null) {sendMessage(H.CONFIGURATION_CHANGED, globalConfig);mPendingConfiguration = updatedConfig;}}}};ViewRootImpl.addConfigCallback(configChangedCallback);}
九、四大阶段启动系统服务
1. startBootstrapServices 引导核心服务
最底层、最优先的刚需服务，后续所有服务依赖它。
Watchdog 看门狗（系统卡死重启机制）
Installer APK安装服务
ATMS / AMS 组件管理核心
PMS 包管理服务
2. startCoreServices 核心基础服务
系统运行必备基础能力：电池、统计、GPU、崩溃日志等。
3. startOtherServices 通用服务
WMS、蓝牙、NFC、定位、音量、SystemUI 启动等。
4. startApexServices 模块化服务
Android10+ Mainline 可独立更新服务（WiFi、蓝牙、权限模块），最后启动，保证不依赖冲突。
十、系统服务启动机制原理
所有系统服务，全部由 SystemServiceManager 统一管理
public <T extends SystemService> T startService(Class<T> serviceClass) {// 1. 反射获取构造方法（必须带Context）Constructor<T> constructor = serviceClass.getConstructor(Context.class);// 2. 反射创建服务实例T service = constructor.newInstance(mContext);// 3. 调用onStart()启动服务startService(service);return service;}public void startService(@NonNull final SystemService service) {mServiceClassnames.add(service.getClass().getName());mServices.add(service);// 真正启动服务service.onStart();}
核心机制：反射创建 + 统一生命周期管理
十一、全文最终总结
system_server 由 Zygote 专属 fork 而出，是 Android 系统核心服务进程，运行在 system(1000) 权限，非 root
fork 后会关闭 Zygote Socket，不再负责孵化应用，职责彻底隔离
通过
createSystemContext创建系统全局上下文，依托 framework-res.apk 运行拥有独立 ClassLoader，隔离系统服务与应用类
通过 SystemServiceManager 反射批量启动数百系统服务
四段式启动：引导服务 → 核心服务 → 其他服务 → 模块化Apex服务
主线程开启 Looper.loop()，永久循环，撑起整个 Android 框架运行
