Android Framework 学习
Zygote和SystemServer进程的执行过程
android系统的Zygote进程是所有android进程的父进程，包括SystemServer和各种应用进程都是通过Zygote进程fork出来的。Zygote（孵化）进程相当于是android系统的根进程，后面所有的进程都是通过这个进程fork出来的，而Zygote进程则是通过linux系统的init进程启动的
Zygote进程由init进程启动，SystemServer进程和应用进程由Zygote进程启动。
Zyogteinit
public static void main(String argv[]) {
...
try {
//设置DDMS可用
RuntimeInit.enableDdms(); //1
//初始化启动参数
boolean startSystemServer = false;
String socketName = "zygote";
String abiList = null;
//2
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
if (abiList == null) {
throw new RuntimeException("No ABI list supplied.");
}
//注册Zygote用的Socket
registerZygoteSocket(socketName); //3
//预加载类和资源
preload(); //4
...
//启动SystemServer进程
if (startSystemServer) {
startSystemServer(abiList, socketName); //5
}
//监听socket,启动新的应用进程
runSelectLoop(abiList); //6
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
//通过反射调用SystemServer#main()
caller.run();
} catch (RuntimeException ex) {
Log.e(TAG, "Zygote died with exception", ex);
closeServerSocket();
throw ex;
}
}
DDMS
DDMS 全称是 Dalvik Debug Monitor Server
作用：
查看实时 Logcat 日志（类似 adb logcat）
线程与堆内存监控（Thread、Heap）
强制 GC（垃圾回收）
查看进程信息
屏幕截图
模拟电话、短信、GPS 坐标等
端口转发和网络流量监控
- 在zygote启动过程中，首先会去检测DDMS是否可用。
//设置DDMS可用
RuntimeInit.enableDdms(); //1
- 其次是android系统中进程之间通讯的方式是Binder，但是有一个例外是SystemServer进程与Zygote进程之间是通过Socket的方式进行通讯的，所以会去解析main方法的参数获取是否需要启动SystemService进程，获取abi列表，获取scoket连接名称
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
registerZygoteSocket函数来创建一个Server端的Socket，这个name为”zygote”的Socket用来等待ActivityManagerService来请求Zygote来创建新的应用程序进程。
//注册Zygote用的Socket
registerZygoteSocket(socketName); //3
同时还包含了预加载类和资源
//预加载类和资源
preload(); //4
...
static void preload() {
beginIcuCachePinning();
preloadClasses(); //加载所需的各种class文件
preloadResources(); //加载资源文件
preloadOpenGL(); //初始化OpenGL
}
从这里开始对于SystemServer，开始起服务了
if (startSystemServer) {
startSystemServer(abiList, socketName); //5
}
private static boolean startSystemServer(String abiList, String socketName)
throws MethodAndArgsCaller, RuntimeException {
long capabilities = posixCapabilitiesAsBits(
OsConstants.CAP_IPC_LOCK,
OsConstants.CAP_KILL,
OsConstants.CAP_NET_ADMIN,
OsConstants.CAP_NET_BIND_SERVICE,
OsConstants.CAP_NET_BROADCAST,
OsConstants.CAP_NET_RAW,
OsConstants.CAP_SYS_MODULE,
OsConstants.CAP_SYS_NICE,
OsConstants.CAP_SYS_RESOURCE,
OsConstants.CAP_SYS_TIME,
OsConstants.CAP_SYS_TTY_CONFIG
);
/* Containers run without this capability, so avoid setting it in that case */
if (!SystemProperties.getBoolean(PROPERTY_RUNNING_IN_CONTAINER, false)) {
capabilities |= posixCapabilitiesAsBits(OsConstants.CAP_BLOCK_SUSPEND);
}
/* Hardcoded command line to start the system server */
/* 1 */
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
/* 2 */
parsedArgs = new ZygoteConnection.Arguments(args);
/** 打开系统调试属性*/
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
/* 3 */
// 请求fork SystemServer进程
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
// pid为0表示子进程，即SystemServer进程，从此SystemServer进程与Zygote进程分道扬镳
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
handleSystemServerProcess(parsedArgs); //4
}
return true;
}
这里我们能够看到socket的请求参数在args数组中，这些是zygote创建的socket的请求参数，之后SystemServer进程服务就被fork出来了。
至于在startSystemServer里面是怎么去启动SystemServer服务的，实际上是通过反射调用的形式去实现的启动服务。
public static class MethodAndArgsCaller extends Exception
implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs }); //这里进行反射调用
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex);
} catch (InvocationTargetException ex) {
Throwable cause = ex.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
} else if (cause instanceof Error) {
throw (Error) cause;
}
throw new RuntimeException(ex);
}
}
}
注释1处通过反射调用了com.android.server.SystemServer#main(String[] args)。至此，Zygote进程fork出SystemServer进程，并成功调用SystemServer#main()。
而在SystemServer#main(）中
SystemServer#main()
public static void main(String[] args) {
new SystemServer().run(); //1
}
private void run() {
...
System.loadLibrary("android_servers");//1
...
mSystemServiceManager = new SystemServiceManager(mSystemContext);//2
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
...
try {
Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartServices");
startBootstrapServices();//3
//启动服务
startCoreServices();//4
startOtherServices();//5
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
...
}
在startBootstrapServices()的位置startBootstrapServices函数中用SystemServiceManager启动了ActivityManagerService(AMS)、PowerManagerService、PackageManagerService(PMS)等服务
在startCoreServices()启动了BatteryService、UsageStatsService和WebViewUpdateService等服务
startOtherServices函数中则启动了CameraService、AlarmManagerService、VrManagerService等服务，这些服务的父类为SystemService。
Launcher服务
当我们启动了SyetemServer之后，SystemServer进程会主要用于启动系统的各种服务，其中就包含了Launcher服务，LauncherAppService
这个服务会去启动Android默认的第一个应用程序：
Home应用程序，这个应用程序用来显示系统中已经安装的应用程序，这个Home应用程序就叫做Launcher。应用程序Launcher在启动过程中会请求PackageManagerService返回系统中已经安装的应用程序的信息，并将这些信息封装成一个快捷图标列表显示在系统屏幕上，这样用户可以通过点击这些快捷图标来启动相应的应用程序。
而Launcher服务就是通过在SystemServer中的startOtherServices()启动起来的服务。
startOtherServices()——> mActivityManagerService.systemReady()—————————>startHomeActivityLocked(currentUserId, "systemReady");
在startHomeActivityLocked（）中开始了对于launcher服务的启动，从此launcher桌面服务启动。
launcher辅导的安装过程：
Zygote进程启动SystemServer进程，SystemServer启动PackageManagerService服务，从这里开始PMS开始扫描系统目录解析对应APK文件，获取对应的信息，例如应用程序的组件Package、Activity、Service、Broadcast Receiver和Content Provider等信息，保存到PackageManagerService的mPackages、mActivities、mServices、mReceivers等成员变量，至此完成下载安装工作。
类似于安装下载之后，相当于在PackageManagerService服务注册好了，程序启动则需要Home应用程序（Launcher），负责从PackageManagerService服务中把这些安装好的应用程序取出来，并以友好的方式在桌面上展现出来。完整的流程下来一个应用程序算是安装下来了。
应用程序启动流程
当我们从利用launcher来实现通过桌面点击应用程序进行程序执行。
首先去调用的是Launcher的startActivitySafely方法。
startActivitySafely() ** ——> (Launcher)startActivity(v, intent, tag)** ——> (Activity)startActivity(intent, optsBundle); ——> startActivityForResult(intent, -1, options) ——>Instrumentation#execStartActivity()
在Instrumentation#execStartActivity()中
public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) {
...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
//1
int result = ActivityManagerNative.getDefault().startActivity(whoThread, who.getBasePackageName(), intent, intent.resolveTypeIfNeeded(who.getContentResolver()), token, target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
static public IActivityManager getDefault() {
return gDefault.get();
}
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
IBinder b = ServiceManager.getService("activity"); //1 获取Binder
IActivityManager am = asInterface(b); //2 获取proxy
return am;
}
};
static public IActivityManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IActivityManager in =
(IActivityManager)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}
return new ActivityManagerProxy(obj);
}
这里是利用的Binder机制去调用的AMP类下的startActivity
调用——>ActivityManagerProxy#startActivity()——>ActivityManagerNative#onTransact()
AMS继承了AMN，这里会去调用AMS的startActivity方法
@Override
public final int startActivity(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, UserHandle.getCallingUserId()); //1
}
——>startActivityAsUser()——>ActivityStarter的startActivityMayWait()——>doPendingActivityLaunchesLocked()——>startActivityUnchecked()——>resumeFocusedStackTopActivityLocked()
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
//1
ProcessRecord app = mService.getProcessRecordLocked(r.processName, r.info.applicationInfo.uid, true);
r.task.stack.setLaunchTime(r);
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0 || !"android".equals(r.info.packageName)) {
app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode, mService.mProcessStats);
}
realStartActivityLocked(r, app, andResume, checkConfig); //2
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity " + r.intent.getComponent().flattenToShortString(), e);
}
}
//3
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true);
}
- 在注释一的位置获取当前Activity所在的进程的ProcessRecord
- 如果进程已经启动了，会执行注释2处的代码。否则执行注释3的代码。
- 注释2处调用realStartActivityLocked来启动应用程序
- 注释3处调用AMS的startProcessLocked来启动应用程序进程，注意这里是应用程序进程，只有应用程序进程起来了，才能起应用程序。
- 先启进程再启程序
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException {
...
//1
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration), new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results, newIntents, !andResume,mService.isNextTransitionForward(), profilerInfo);
...
return true;
}
这里的app.thread指的是IApplicationThread，它的实现是ActivityThread的内部类ApplicationThread，其中ApplicationThread继承了ApplicationThreadNative，而ApplicationThreadNative继承了Binder并实现了IApplicationThread接口。
ActivityThread
ActivityThread启动Application和Activity 在应用程序进程启动时会创建ActivityThread实例。
ActivityThread#handleLaunchActivity()
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
...
Activity a = performLaunchActivity(r, customIntent); //1
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
//2
handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
if (!r.activity.mFinished && r.startsNotResumed) {
performPauseActivityIfNeeded(r, reason);
if (r.isPreHoneycomb()) {
r.state = oldState;
}
}
} else {
try {
//3
ActivityManagerNative.getDefault() .finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
注释1处的performLaunchActivity方法用来启动Activity。 注释2处的代码用来执行Activity的onResume方法，将Activity的状态置为Resume。 注释3如果该Activity为null则会通知ActivityManager停止启动Activity。
-
-
🔍 Android 冷启动流程详细解读
1. Launcher 通过 Binder 向 AMS 发起启动目标 Activity 的请求
- 过程：用户点击桌面图标，Launcher 通过
startActivity()发起启动请求。 - 实质：通过 Binder 调用
ActivityManagerService.startActivity()。 - 关键类：
Launcher -> ActivityTaskManagerService -> ActivityStartController
2. AMS 将 Launcher 栈顶的 Activity 置为 onPause 状态
- 过程：为了切换到新的 Activity，旧的 Activity（Launcher）需先暂停。
- 实质：通过
ActivityStack.resumeTopActivityInnerLocked()驱动生命周期状态切换。 - 方式：调用 Launcher 的
ApplicationThread.schedulePauseActivity()（也是 Binder）。
3. AMS 检查目标应用是否存在进程，若无：
- 过程：AMS 判断目标应用是否已经运行。
- 查找机制：通过
ProcessRecord查进程是否存在（mLruProcesses列表）。 - 结果：如果没找到进程，则需要启动新进程。
4. AMS 通过 Socket 通知 Zygote fork 出新的应用进程
- 过程：AMS 通过
Process.start()->ZygoteProcess.startViaZygote()建立 Socket 通信。 - Zygote 是干啥的？
- Android 所有应用进程都是从 Zygote 进程 fork 出来的。
- Zygote 维护一个 socket server，等待 fork 请求。
5. Zygote fork 出新进程，并执行 ActivityThread.main()
- 过程：Zygote 调用
fork()，创建出新进程（用户应用）。 - fork 后：
- 子进程执行
RuntimeInit.commonInit()→ActivityThread.main()。
- 子进程执行
- main() 做了啥？
- 初始化 Looper（消息循环）。
- 创建
ActivityThread实例，并调用attach()。
6. 在 main() 中，启动消息循环（Looper），并调用 ActivityThread.attach()
ActivityThread.attach()- 是关键：告诉系统“我已经启动完成，可以收指令了”。
- 通过 Binder 把
ApplicationThread（内部类）传给 AMS。
7. ActivityThread 通过 Binder 将自身的 ApplicationThread 传给 AMS
ApplicationThread是IApplicationThread的 Binder 实现。- 作用：AMS 以后就可以通过这个 Binder 接口，让应用执行生命周期（如启动 Activity）。
8. AMS 通过 ApplicationThread.scheduleLaunchActivity() 通知启动 Activity
- 过程：AMS 发起启动请求，调用
scheduleLaunchActivity()。 - 类型：这是 跨进程调用，属于 Binder IPC。
- 目的：告诉应用“该启动你自己的 Activity 了”。
9. ActivityThread 接收消息，执行 handleLaunchActivity()
scheduleLaunchActivity()实际是发消息给主线程 Handler →H.handleMessage()handleLaunchActivity()具体做了这些事：- 从 PackageManager 中加载应用代码和资源 →
LoadedApk - 调用
makeApplication()创建 Application 实例（只创建一次） - 调用
Application.onCreate()
- 从 PackageManager 中加载应用代码和资源 →
10. ActivityThread 通过反射加载目标 Activity 类
Instrumentation.newActivity()通过类加载器 + 反射方式创建目标 Activity 实例。- 反射优势：动态加载、延迟创建、无需提前声明类。
11. 调用 Activity.attach() 完成 Activity 环境绑定
Activity.attach()是内部绑定逻辑：- 绑定 Window、Context、Token、Application、FragmentManager 等。
- 此时 Activity 还没有走到生命周期回调，仅做了环境搭建。
12. 调用 Instrumentation.callActivityOnCreate()
Instrumentation.callActivityOnCreate()是生命周期桥梁。- 会调用：
Activity.performCreate()→ 系统层做准备Activity.onCreate()→ 调用开发者写的业务代码（布局加载、初始化等）
- 过程：用户点击桌面图标，Launcher 通过
-
缩减执行流程：
- 点击桌面程序
- 将Activity顶上第一个设置为暂停状态，等待启动的应用
- 判断进程，先进程再程序
- 通过Zygote开始fork()应用程序进程了
- 执行ActivityThread.main()
- ActivityThread 通过 Binder 将自身的 ApplicationThread 传给 AMS，方便AMS通过ActivityThread启动应用
- AMS 通过 ApplicationThread.scheduleLaunchActivity() 通知启动 Activity
- ActivityThread 通过反射加载目标 Activity 类
- 调用 Instrumentation.callActivityOnCreate()，执行程序的OnCreate()函数
应用的真正启动是 ActivityThread 执行的，但整个过程是由 AMS 控制调度的，双方通过 Binder 建立通信桥梁。
应用程序进程启动流程
-
🧠 应用程序进程启动过程解析
🔸 1. Launcher 启动应用：用户点击桌面图标
- Launcher 调用
startActivity()启动目标 Activity。 - 最终调用系统服务
ActivityTaskManagerService→ActivityManagerService（AMS）来管理启动流程。 - 注意：此时应用还没有进程。
🔸 2. AMS 判断是否已有目标应用进程
- 查询是否有已有进程（
ProcessRecord）。 - 如果没有，则通过
Process.start()启动一个新进程。 - 重点：进程的创建是 AMS 负责的，不是应用自己控制的。
🔸 3. AMS 通过 Zygote 创建新进程
- Zygote 是系统中负责 fork 的进程，预加载了系统类和资源。
- AMS 调用
ZygoteProcess.start()：- 通过 Socket 通信，发送
fork请求给 Zygote。 - 请求包含要启动的类名（通常是
android.app.ActivityThread）和进程信息。
- 通过 Socket 通信，发送
🔸 4. Zygote 收到请求后执行 fork()
- Zygote 中的
ZygoteConnection处理 Socket 请求。 - 调用
Zygote.forkAndSpecialize()：- 使用
fork()系统调用创建子进程。
- 使用
- fork 后的子进程正式成为目标应用的进程。
🔸 5. 子进程中调用 ActivityThread.main()
- fork 出来的子进程会执行
ActivityThread.main()。 - 这是 Java 主线程的入口：
- 设置
Looper，准备主线程消息循环。 - 创建
ActivityThread实例。 - 调用
attach()绑定到 AMS。
- 设置
🔸 6. ActivityThread.attach() 通知系统“我准备好了”
- 通过 Binder 调用
AMS.attachApplication()。 - 传入自己（
ApplicationThread）的 Binder 实例。 - 这意味着：应用进程正式向 AMS 注册自己，准备收指令。
🔸 7. AMS 启动目标 Activity
- AMS 接收到
attachApplication()，会调用ApplicationThread.scheduleLaunchActivity()。 - 启动目标 Activity 进入前台。
- Launcher 调用
-
Launcher 启动 Activity，通过 Binder 通知 AMS。
-
AMS 判断是否有进程，没有则开始启动新进程。
-
AMS 通过 Socket 通知 Zygote fork 进程。
-
Zygote fork 出子进程，执行
ActivityThread.main()。 -
ActivityThread.attach() 通过 Binder 通知 AMS，传入 ApplicationThread。
-
AMS 通过 ApplicationThread 回调 scheduleLaunchActivity()。
-
ActivityThread 创建 Application（如首次）并调用 onCreate()。
-
反射加载 Activity 实例，执行 attach() 绑定环境。
-
Instrumentation 调用 Activity.onCreate()，正式进入业务逻辑
AMS启动流程
在frameworks/base/services/java/com/android/server/SystemServer.java这里
private void run() {
...
System.loadLibrary("android_servers");//1
...
mSystemServiceManager = new SystemServiceManager(mSystemContext);//2
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
...
try {
Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartServices");
startBootstrapServices();
/*
startBootstrapServices函数中用SystemServiceManager启动了ActivityManagerService、PowerManagerService、PackageManagerService等服务。
*/
startCoreServices();//4
startOtherServices();//5
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
...
}
在 startBootstrapServices()的位置开始启动服务，ActivityManagerService、PowerManagerService、PackageManagerService等服务。
private void startBootstrapServices() {
Installer installer = mSystemServiceManager.startService(Installer.class);
// Activity manager runs the show.
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();//1
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
...
mActivityManagerService.setSystemProcess(); //2
}
AMS从这里开始启动
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();//1
浙公网安备 33010602011771号