Android系统启动流程(三)——SystemServer的启动流程

527 阅读6分钟

接上篇:Android系统启动流程(二)——Zygote进程的启动流程

启动SystemServer进程是Android系统启动过程中非常重要的一步,我们熟悉的SystemServiceManager以及AMS、WMS等服务都是由SystemServer进程来负责启动的,因此我们有必要来了解一下SystemServer的启动流程。

1.SystemServer进程的创建

SystemServer进程是由Zygote进程来启动的,在执行ZygoteInit.java的main方法时会去启动SystemServer:

源码路径:\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java

    public static void main(String argv[]) {
        ...
        try {
            ...
            boolean startSystemServer = false;
            String socketName = "zygote";
            String abiList = null;
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {
                    startSystemServer = true;//1.如果参数包含"start-system-server",则需要启动SystemServer
                } else if ("--enable-lazy-preload".equals(argv[i])) {
                    enableLazyPreload = 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 (startSystemServer) {
                startSystemServer(abiList, socketName, zygoteServer);//2.启动SystemServer
            }

            ...
        } catch (Zygote.MethodAndArgsCaller caller) {
            caller.run();
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            zygoteServer.closeServerSocket();
            throw ex;
        }
    }

在注释1处,如果参数args中含有"start-system-server"字段,则会在注释2处通过调用startSystemServer方法来启动SystemServer,我们来看一下startSystemServer方法的源码:

    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
       ...
        int pid;

        try {
            ...
            //1.调用Zygote的forkSystemServer方法来创建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进程 */
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket();//关闭从Zygote进程复制而来的Socket
            handleSystemServerProcess(parsedArgs);//2.调用handleSystemServerProcess来初始化SystemServer进程
        }

        return true;
    }

startSystemServer方法的代码比较简单,在注释1处,通过调用Zygote的forkSystemServer来创建了SystemServer进程,然后再注释2出通过调用handleSystemServerProcess来进一步对SystemServer进程进行一些初始化工作。我们先来看一下forkSystemServer的源码:

public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
        VM_HOOKS.preFork();
        // Resets nice priority for zygote process.
        resetNicePriority();
        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 private static int nativeForkSystemServer(int uid, int gid, int[] gids, int debugFlags,
            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);

可以看到,在forkSystemServer方法中调用了native方法nativeForkSystemServer方法来创建SystemServer进程,而nativeForkSystemServer的底层则直接调用了fork方法来创建新的线程。

再来看一下handleSystemServerProcess方法,源码如下:

    private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws Zygote.MethodAndArgsCaller {

        ...

        if (parsedArgs.invokeWith != null) {
           ...
        } else {
            ClassLoader cl = null;
            if (systemServerClasspath != null) {
                //1.创建PathClassLoader
                cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);

                Thread.currentThread().setContextClassLoader(cl);
            }

           //2.调用ZygoteInit.zygoteInit来对SystemServer进行初始化
            ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        }
    }

在注释1处创建了一个PathClassLoader,然后在注释2出调用了ZygoteInit的zygoteInit方法来对SystemServer进行初始化。zygoteInit的源码如下:

源码路径:\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java

    public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
        RuntimeInit.redirectLogStreams();

        RuntimeInit.commonInit();
        ZygoteInit.nativeZygoteInit();//调用nativeZygoteInit
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

    private static final native void nativeZygoteInit();

在zygoteInit方法中又调用了nativeZygoteInit方法,而nativeZygoteInit的作用主要是用来启动Binder线程池的。

2.开启Binder线程池

nativeZygoteInit方法所对应的C++代码如下:

源码位置:\frameworks\base\core\jni\AndroidRuntime.cpp

static AndroidRuntime* gCurRuntime = NULL;

static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
    gCurRuntime->onZygoteInit();
}

该方法直接调用了gCurRuntime对象的onZygoteInit方法,这个gCurRuntime是由AndroidRuntime的子类AppRuntime来实现的,它位于app_main.cpp文件中,我们来看一下AppRuntime的onZygoteInit方法:

源码路径:\frameworks\base\cmds\app_process\app_main.cpp

    virtual void onZygoteInit()
    {
        sp<ProcessState> proc = ProcessState::self();
        ALOGV("App process: starting thread pool.\n");
        proc->startThreadPool();
    }

可以看到,onZygoteInit方法中又调用了ProcessState的startThreadPool来开启线程池,该方法的源码如下:

源码路径:\frameworks\native\libs\binder\ProcessState.cpp

void ProcessState::startThreadPool()
{
    AutoMutex _l(mLock);
    if (!mThreadPoolStarted) {//1.判断线程池是否已经开启
        mThreadPoolStarted = true;
        spawnPooledThread(true);//2.调用spawnPooledThread方法
    }
}

void ProcessState::spawnPooledThread(bool isMain)
{
    if (mThreadPoolStarted) {
        String8 name = makeBinderThreadName();//3.创建Binder线程池的名称
        ALOGV("Spawning new pooled thread, name=%s\n", name.string());
        sp<Thread> t = new PoolThread(isMain);//4.创建线程池对象
        t->run(name.string());//5.运行该线程池
    }
}

String8 ProcessState::makeBinderThreadName() {
    int32_t s = android_atomic_add(1, &mThreadPoolSeq);//编号+1
    pid_t pid = getpid();//获取pid
    String8 name;
    name.appendFormat("Binder:%d_%X", pid, s);//6.拼接Binder线程池名称
    return name;
}

首先在注释1处判断线程池是否已经开启,以此保证Binder线程池只会启动一次,然后在注释2出调用了spawnPooledThread方法来创建线程,并且参数为true。

在注释3初通过makeBinderThreadName方法来创建线程的名称,通过注释6处的代码我们可以得知,Android中Binder线程的名称都是“Binder:”+线程id+“_”+线程编号的形式。

在注释4处创建了线程池中的第一个线程,它是一个PoolThread 对象,isMain为true表示该线程为线程池的主线程,并在注释5出调用了run方法来运行该线程。

我们来看一下PoolThread的源码:

源码路径:\frameworks\native\libs\binder\ProcessState.cpp

class PoolThread : public Thread
{
public:
    explicit PoolThread(bool isMain)
        : mIsMain(isMain)
    {
    }
    
protected:
    virtual bool threadLoop()
    {
        IPCThreadState::self()->joinThreadPool(mIsMain);
        return false;
    }
    
    const bool mIsMain;
};

从上面的代码可以得知,PoolThread继承自Thread类。当运行PoolThread对象的run方法时,会调用该对象的threadLoop方法,并在threadLoop方法中调用IPCThreadState对象的joinThreadPool方法,来将该线程加入到Binder线程池中,至此,SystemServer进程就可以通过Binder与其他进程进行通信了。

3.创建SystemServiceManager及各种系统服务

回到ZygoteInit.java的zygoteInit方法中,在调用nativeZygoteInit来启动线程池后,又调用了RuntimeInit.applicationInit方法,该方法的代码如下:

源码路径:\frameworks\base\core\java\com\android\internal\os\RuntimeInit.java

    protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
       
        ...
        invokeStaticMain(args.startClass, args.startArgs, classLoader);//1.调用invokeStaticMain方法
    }

    private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        Class<?> cl;

        try {
            cl = Class.forName(className, true, classLoader);//2.获取SystemServer对应的Java类
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException(
                    "Missing class when invoking static main " + className,
                    ex);
        }

        Method m;
        try {
            m = cl.getMethod("main", new Class[] { String[].class });//3.找到main方法
        } catch (NoSuchMethodException ex) {
            throw new RuntimeException(
                    "Missing static main on " + className, ex);
        } catch (SecurityException ex) {
            throw new RuntimeException(
                    "Problem getting static main on " + className, ex);
        }

        int modifiers = m.getModifiers();
        if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
            throw new RuntimeException(
                    "Main method is not public and static on " + className);
        }

        /*
         * 4.抛出异常,该异常最终会在ZygoteInit.main中被捕获
         * 使用抛出异常的方法可以直接清理所有栈帧
         */
        throw new Zygote.MethodAndArgsCaller(m, argv);
    }

从注释1处可以看到,applicationInit方法内又调用了invokeStaticMain方法,从invokeStaticMain方法的名字我们就可以猜出,该方法主要是使用反射来调用SystemServer的main方法的。在注释2处通过反射获取到了SystemServer对应的java类,并在注释3出通过反射找到了main方法。不过在invokeStaticMain方法中并没有直接去执行这个main方法,而是在注释4出抛出了一个异常对象Zygote.MethodAndArgsCaller,并将main方法和相关参数封装到了这个异常对象中,这个异常最终会在ZygoteInit.java的main方法中被捕获到,如下:

public static void main(String argv[]) {
        ...

        try {
            ...

            if (startSystemServer) {
                startSystemServer(abiList, socketName, zygoteServer);
            }

           ...
        } catch (Zygote.MethodAndArgsCaller caller) {//1.捕获Zygote.MethodAndArgsCaller异常
            caller.run();  //2.调用异常对象的run方法
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            zygoteServer.closeServerSocket();
            throw ex;
        }
    }

在注释1出捕获到了抛出的Zygote.MethodAndArgsCaller异常,然后在注释2处调用了该对象的run方法,MethodAndArgsCaller的源码如下:

源码路径:\frameworks\base\core\java\com\android\internal\os\Zygote.java

    public static class MethodAndArgsCaller extends Exception
            implements Runnable {

        private final Method mMethod;
        private final String[] mArgs;

        public MethodAndArgsCaller(Method method, String[] args) {
            mMethod = method;
            mArgs = args;
        }

        public void run() {
            try {
                mMethod.invoke(null, new Object[] { mArgs });//执行main方法
            } 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);
            }
        }
    }

可以看到,在MethodAndArgsCaller的run方法中直接通过mMethod.invoke来执行了传入的方法,即SystemServer的main方法,我们再来看SystemServer的main的代码:

源码路径:\frameworks\base\services\java\com\android\server\SystemServer.java

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

    private void run() {
        try {
            ...
            Looper.prepareMainLooper();//1.准备主线程的Looper

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

            performPendingShutdown();

            createSystemContext();//2.创建系统context

            mSystemServiceManager = new SystemServiceManager(mSystemContext);//3.创建SystemServiceManager
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
            SystemServerInitThreadPool.get();
        } finally {
            traceEnd();
        }

        // 开始启动各种服务
        try {
            traceBeginAndSlog("StartServices");
            startBootstrapServices();//4.开启各种引导服务
            startCoreServices();//5.开启各种核心服务
            startOtherServices();//6.开启其他服务
            SystemServerInitThreadPool.shutdown();
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            traceEnd();
        }

        ...

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

在main方法中创建了一个SystemServer对象并直接调用了该对象的run方法。

在注释1处通过调用prepareMainLooper来准备主线程的Looper,在注释2处创建系统context,在注释3处创建了SystemServiceManager对象,该对象用来管理Android系统中的各种服务。

注释4、5、6处都是在启动各种系统服务,Android中的系统服务大致可以分为3类:

  1. 引导服务:如ActivityManagerService(用来管理四大组件)、PowerManagerService(用来处理与手机电量相关的逻辑)、PackageManagerService(用来管理手机上安装的应用)等
  2. 核心服务:如BatteryService等
  3. 其他服务:如InputManagerService(用来处理各种输入事件)、WindowManagerService(用于管理窗口)等

我们以ActivityManagerService为例来看一下这些服务是如何被启动的,先来看一下startBootstrapServices的源码:

源码路径:\frameworks\base\services\java\com\android\server\SystemServer.java

private void startBootstrapServices() {
        ...
        // Activity manager runs the show.
        traceBeginAndSlog("StartActivityManager");

        //通过调用SystemServiceManager对象的startService方法来创建ActivityManagerService
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        traceEnd();
        ...
}

从上面的代码可以看到,ActivityManagerService是由SystemServiceManager对象的startService方法来启动的,startService方法代码如下:

    @SuppressWarnings("unchecked")
    public <T extends SystemService> T startService(Class<T> serviceClass) {
        try {
            ...
            final T service;
            try {
                Constructor<T> constructor = serviceClass.getConstructor(Context.class);//1.获取要启动的service的类的构造方法
                service = constructor.newInstance(mContext);//2.创建服务实例
            } 
            ...

            startService(service);//3.调用另一个重载方法
            return service;
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }
    }

    public void startService(@NonNull final SystemService service) {
        mServices.add(service);//4.将创建的service加入到mServices列表中
        long time = System.currentTimeMillis();
        try {
            service.onStart();//5.调用onStart方法来启动这个服务
        } catch (RuntimeException ex) {
            throw new RuntimeException("Failed to start service " + service.getClass().getName()
                    + ": onStart threw an exception", ex);
        }
        warnIfTooLong(System.currentTimeMillis() - time, service, "onStart");
    }

在注释1处,通过反射获取要启动的服务的构造方法,然后再注释2处创建了一个新的实例。 在注释3处调用了startService的另一个重载方法,并在注释4处将创建好的服务加入到了mServices列表中。 在注释5处通过调用服务的onStart方法来开启了这个服务。

至此SystemServer的启动流程就基本完成了。