Android 系统启动流程Init、Zygote、SystemService、ServiceManager
Android系统启动流程
操作系统本身也是一个程序，只是这个程序是用来管理我们 App 应用程序的。 从系统的角度上来讲，Android系统的启动过程可以分为 bootloader 引导，装载和启动 linux内核，启动Android系统。
Android 系统虽然也是基于 Linux 系统的，但是由于 Android 属于移动设备，并没有像 PC 那样的 BIOS 程序， 取而代之的是 BootLoader (系统启动加载器)。 Bootloader 相当于电脑上的Bios 他的主要作用就是初始化基本的硬件设备，建立内存空间映射，为装载linux内核准备好运行环境，当linux内核加载完毕之后，bootloder就会从内存中清除。在 Android 里没有硬盘，而是 ROM，它类似于硬盘存放操作系统，用户程序等。 ROM 跟硬盘一样也会划分为不同的区域，用于放置不同的程序。当 Linux 内核启动后会初始化各种软硬件环境，加载驱动程序，挂载根文件系统，Linux 内核加载的准备完毕后就开始加载一些特定的程序(进程)了。
具体流程，可以参考下流程图：
对于纯Android应用层开发来讲，了解一些Android的启动流程的知识并不会直接提高自己的代码质量。但是作为整个Android系统的开端，这部分的流程时刻影响着应用层的方方面面。这些知识也是作为Android开发进阶必须要了解的一部分。对于前面的bootloader引导也好，装载启动linux文件都是很底层的东西，感兴趣的可以自行了解一下，我们从启动androng系统开始分析，第一个加载的就是 init 进程。
一：init进程
我们应该都知道不管是 Java 还是 C/C++ 去运行某一个程序(进程)都是 XXX.xxx 的 main 方法作为入口，相信有很多大佬都跟我一样，App 开发做久了渐渐就忘记了还有个 main 方法。因此我们找到 /system/core/init/Init.cpp 的 main() 方法：
int main(int argc,char ** argv){
...
if(is_first_stage){
//创建和挂在启动所需要的文件目录
mount("tmpfs","/dev","tmpfs",MS_NOSUID,"mode=0755");
mkdir("/dev/pts",0755);
//创建和挂在很多...
...
}
...
//对属性服务进行初始化
property_init();
...
//用于设置子进程信号处理函数（如Zygote），如果子进程异常退出，init进程会调用该函数中设定的信号处理函数来处理
signal_handler_init();
...
//启动属性服务
start_property_service();
...
//解析init.rc配置文件
parser.ParseConfig("/init.rc");
}
main 方法里面有 148 行代码（不包括子函数代码）具体分为四个步骤：1.创建目录,挂载分区，2.解析启动脚本，3.启动解析的服务，4.守护解析的服务。init.rc 文件是 Android 系统的重要配置文件，位于 /system/core/rootdir/init.rc
import /init.environ.rc
import /init.usb.rc
// 当前硬件版本的脚本
import /init.${ro.hardware}.rc
import /init.${ro.zygote}.rc
import /init.trace.rc
on early-init
...
on init
...
// 服务 服务名称 执行文件路径 执行参数
// 有几个重要的服务
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
service servicemanager /system/bin/servicemanager
service surfaceflinger /system/bin/surfaceflinger
service media /system/bin/mediaserver
service installd /system/bin/installd
在处理了繁多的任务后，init进程会进行最关键的一部操作: 启动Zygote
至此 init 进程已全部分析完毕，有四个步骤：1. 创建目录,挂载分区，2. 解析启动脚本，3. 启动解析的服务，4. 守护解析的服务。最需要注意的是 init 创建了 zygote(创建 App 应用的服务)、servicemanager (client 与 service 通信管理的服务)、surfaceflinger(显示渲染服务) 和 media(多媒体服务) 等 service 进程。
二：Zygote
Zygote 进程是由 init 进程通过解析 init.rc 文件而创建的。
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
socket zygote stream 666
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
对应找到 /frameworks/base/cmds/app_process/app_main.cpp 源码文件中的 main 方法
int main(int argc, char* const argv[])
{
// AppRuntime 继承 AndoirdRuntime
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
// 过滤第一个参数
argc--;
argv++;
...
bool zygote = false;
bool startSystemServer = false;
bool application = false;
String8 niceName;
String8 className;
++i; // Skip unused "parent dir" argument.
// 解析参数
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {
zygote = true;
niceName = ZYGOTE_NICE_NAME;
} 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.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);
break;
} else {
--i;
break;
}
}
...
//设置进程名
if (!niceName.isEmpty()) {
runtime.setArgv0(niceName.string());
set_process_name(niceName.string());
}
// 如果 zygote ，AndroidRuntime 执行 com.android.internal.os.ZygoteInit
// 看上面解析的脚本参数执行的是这里。
if (zygote) {
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
} else if (className) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
} 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;
}
}
上面首先是解析参数，然后来到 /frameworks/base/core/jni/AndroidRuntime.cpp 中的 start 方法：
/*
* Start the Android runtime. This involves starting the virtual machi 相信很多人都跟我一样，刚开始看这样的代码有一定的难度，毕竟都是大学时期学的，不涉及底层开发的，看起来有些吃力，但是仔细阅读之后，或者通过命名，都可以大致看得懂流程。
Zygote 进程是由 init 进程解析 init.rc 脚本创建的，其具体的执行源码是在 App_main.main 方法，首先会创建一个虚拟机实例，然后注册 JNI 方法，最后通过 JNI 调用进入 Java 世界来到 ZygoteInit.main 方法。在 Java 世界中我们会为 Zygote 注册 socket 用于进程间通信，预加载一些通用的类和资源，启动 system_server 进程，循环等待孵化创建新的进程。总结一下ZygoteInit的main方法都做了哪些事情：
1.创建了一个Server端的Socket
2.预加载类和资源
3.启动了SystemServer进程
4.等待AMS请求创建新的应用程序进程
Zygote进程启动后，总共做了哪几件事：
1.创建AndroidRuntime并调用其start方法，启动Zygote进程。
2.创建Java虚拟机并为Java虚拟机注册JNI方法。
3.通过JNI调用ZygoteInit的main函数进入Zygote的java框架层。
4.通过registerZygoteSocket方法创建服务端Socket，并通过runSelectLoop方法等待AMS的请求来创建新的应用程序进程。
5.启动SystemServer。
三：SystemService
Zygote 进程的启动过程中会调用 startSystemServer 方法来启动 SystemServer 进程：
private static boolean startSystemServer(String abiList, String socketName) throws MethodAndArgsCaller, RuntimeException {
...
// 设置一些参数
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",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
...
// fork 创建 system_server 进程，后面会具体分析
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 代表子进程，也就是 system_server 进程
if (pid == 0) {
// 执行初始化 system_server 进程
handleSystemServerProcess(parsedArgs);
}
return true;
}
1. 启动 SystemServer
public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
VM_HOOKS.preFork();
int pid = nativeForkSystemServer(uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
// Enable tracing as soon as we enter the system_server.
if (pid == 0) {
Trace.setTracingEnabled(true);
}
VM_HOOKS.postForkCommon();
return pid;
}
// 调用的 native 方法去创建的，nativeForkSystemServer() 方法在 AndroidRuntime.cpp 中注册的，调用 com_android_internal_os_Zygote.cpp 中的 com_android_internal_os_Zygote_nativeForkSystemServer() 方法
native private static int nativeForkSystemServer(int uid, int gid, int[] gids, int debugFlags,int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);
static jint com_android_internal_os_Zygote_nativeForkSystemServer(
JNIEnv* env, jclass, uid_t uid, gid_t gid, jintArray gids,
jint debug_flags, jobjectArray rlimits, jlong permittedCapabilities,
jlong effectiveCapabilities) {
// fork 创建 systemserver 进程
pid_t pid = ForkAndSpecializeCommon(env, uid, gid, gids,
debug_flags, rlimits, permittedCapabilities, effectiveCapabilities,
MOUNT_EXTERNAL_DEFAULT, NULL, NULL, true, NULL,NULL, NULL);
// pid > 0 是父进程执行的逻辑
if (pid > 0) {
// waitpid 等待 SystemServer 进程的退出，如果退出了重启 zygote 进程
if (waitpid(pid, &status, WNOHANG) == pid) {
RuntimeAbort(env);
}
}
return pid;
}
static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids, jint debug_flags, jobjectArray javaRlimits, jlong permittedCapabilities, jlong effectiveCapabilities, jint mount_external, jstring java_se_info, jstring java_se_name, bool is_system_server, jintArray fdsToClose, jstring instructionSet, jstring dataDir) {
//设置子进程的 signal 信号处理函数
SetSigChldHandler();
// fork 子进程(SystemServer)
pid_t pid = fork();
if (pid == 0) {
// 进入子进程
...
// gZygoteClass = com/android/internal/os/Zygote
// gCallPostForkChildHooks = GetStaticMethodIDOrDie(env, gZygoteClass, "callPostForkChildHooks", "(ILjava/lang/String;)V");
// 等价于调用 Zygote.callPostForkChildHooks()
env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, debug_flags,is_system_server ? NULL : instructionSet);
...
} else if (pid > 0) {
// the parent process
}
return pid;
}
private static void handleSystemServerProcess( ZygoteConnection.Arguments parsedArgs) throws ZygoteInit.MethodAndArgsCaller {
...
if (parsedArgs.invokeWith != null) {
...
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) {
// 创建类加载器，并赋予当前线程
cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
Thread.currentThread().setContextClassLoader(cl);
}
// RuntimeInit.zygoteInit
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
}
public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller {
...
// 通用的一些初始化
commonInit();
// 这个方法是 native 方法，主要是打开 binder 驱动，启动 binder 线程，后面分析 binder 驱动的时候再详解。
nativeZygoteInit();
// 应用初始化
applicationInit(targetSdkVersion, argv, classLoader);
}
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller {
...
final Arguments args;
try {
// 解析参数 Arguments
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
return;
}
...
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller {
Class<?> cl = Class.forName(className, true, classLoader);
...
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
...
} catch (SecurityException ex) {
...
}
...
// 通过抛出异常，回到了 ZygoteInit.main()
// try{} catch (MethodAndArgsCaller caller) {caller.run();}
throw new ZygoteInit.MethodAndArgsCaller(m, argv);
}
绕了一大圈我们发现是通过抛异常回到了 ZygoteInit.main() 方法中的 try…catch(){MethodAndArgsCaller.run() }
2. 创建 SystemServer
public static class MethodAndArgsCaller extends Exception implements Runnable {
...
public void run() {
try {
// 根据传递过来的参数可知，此处通过反射机制调用的是 SystemServer.main() 方法
mMethod.invoke(null, new Object[] { mArgs });
} catch (IllegalAccessException ex) {
...
}
}
public final class SystemServer {
...
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
// 主线程 looper
Looper.prepareMainLooper();
// 初始化系统上下文
createSystemContext();
// 创建系统服务管理
mSystemServiceManager = new SystemServiceManager(mSystemContext);
// 将 mSystemServiceManager 添加到本地服务的成员 sLocalServiceObjects，sLocalServiceObjects 里面是一个静态的 map 集合
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
//启动各种系统服务
try {
// 启动引导服务
startBootstrapServices();
// 启动核心服务
startCoreServices();
// 启动其他服务
startOtherServices();
} catch (Throwable ex) {
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
}
// 一直循环执行
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
private void createSystemContext() {
// 创建系统进程的上下文信息，这个在进程启动再详解
ActivityThread activityThread = ActivityThread.systemMain();
mSystemContext = activityThread.getSystemContext();
...
}
private void startBootstrapServices() {
// 阻塞等待与 installd 建立 socket 通道
Installer installer = mSystemServiceManager.startService(Installer.class);
// 启动服务 ActivityManagerService
mActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
// 启动服务 PackageManagerService
mPackageManagerService = PackageManagerService.main(mSystemContext, installer, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
mPackageManager = mSystemContext.getPackageManager();
// 设置 AMS , 把自己交给 ServiceManager. addService 去管理
mActivityManagerService.setSystemProcess();
...
}
private void startCoreServices() {
...
}
private void startOtherServices() {
// 启动闹钟服务
mSystemServiceManager.startService(AlarmManagerService.class);
// 初始化 Watchdog
final Watchdog watchdog = Watchdog.getInstance();
watchdog.init(context, mActivityManagerService);
// 输入管理的 service
inputManager = new InputManagerService(context);
// WindowManagerService
wm = WindowManagerService.main(...);
// InputManagerService 和 WindowManagerService 都交给 ServiceManager 管理
ServiceManager.addService(Context.WINDOW_SERVICE, wm);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
// 启动input
inputManager.start();
// 显示启动界面
ActivityManagerNative.getDefault().showBootMessage(...);
// 状态栏管理
statusBar = new StatusBarManagerService(context, wm);
// JobSchedulerService
mSystemServiceManager.startService(JobSchedulerService.class);
...
// 准备好了 wms, pms, ams 服务
wm.systemReady();
mPackageManagerService.systemReady();
mActivityManagerService.systemReady();
}
...
}
我们可以看到SystemServer在启动后，陆续启动了各项服务，包括ActivityManagerService，PowerManagerService，PackageManagerService等等，而这些服务的父类都是SystemService。
最后总结一下SystemServer进程：
1.启动Binder线程池
2.创建了SystemServiceManager（用于对系统服务进行创建、启动和生命周期管理）
3.启动了各种服务
3. 管理 SystemServer
系统服务启动后都会交给 ServiceManager 来管理，无论是 mSystemServiceManager.startService 还是 ServiceManager.addService 都是走的 ServiceManager.addService() 方法：
public static void addService(String name, IBinder service) {
try {
getIServiceManager().addService(name, service, false);
} catch (RemoteException e) {
Log.e(TAG, "error in addService", e);
}
}
private static IServiceManager getIServiceManager() {
if (sServiceManager != null) {
return sServiceManager;
}
sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());
return sServiceManager;
}
public abstract class ServiceManagerNative extends Binder implements IServiceManager {
static public IServiceManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IServiceManager in =(IServiceManager)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}
// 创建 ServiceManagerProxy 对象
return new ServiceManagerProxy(obj);
}
}
class ServiceManagerProxy implements IServiceManager {
private IBinder mRemote;
public ServiceManagerProxy(IBinder remote) {
mRemote = remote;
}
...
// IPC binder 驱动
public void addService(String name, IBinder service, boolean allowIsolated)
throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IServiceManager.descriptor);
data.writeString(name);
data.writeStrongBinder(service);
data.writeInt(allowIsolated ? 1 : 0);
// mRemote 是 IBinder 对象
mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0);
reply.recycle();
data.recycle();
}
}
最后我们再来总结一下：SystemServer 进程是由 Zygote 进程 fork 创建的，SystemServer 进程创建后会创建启动引导服务、核心服务和其他服务，并且将所创建的服务，通过跨进程通信交给 ServiceManager 进程来管理。
哈哈，看完这么多，是不是感觉有点了解，然后又不是特别了解，有一定的了解，就会想去深入了解，花点时间，慢慢去消化，主体流程了解，具体的底层实现，有兴趣可以多了解。
