App啓動流程

原創 楊充 2019-02-22 20:25

目錄介紹

  • 1.什麼是Zygote進程
    • 1.1 簡單介紹
    • 1.2 各個進程的先後順序
    • 1.3 進程作用說明
  • 2.Zygote進程的啓動流程
    • 2.1 源碼位置
    • 2.2 ZygoteInit類的main方法
    • 2.3 registerZygoteSocket(socketName)分析
    • 2.4 preLoad()方法分析
    • 2.5 startSystemServer()啓動進程
  • 3.SystemServer進程啓動流程
    • 3.1 SystemServer進程簡介
    • 3.2 SystemServer的main方法
    • 3.3 查看run方法
    • 3.4 run方法中createSystemContext()解析
    • 3.5 mSystemServiceManager的創建
  • 4.啓動服務
    • 4.1 啓動哪些服務
    • 4.2 啓動服務流程源碼分析
    • 4.3 啓動部分服務

好消息

  • 博客筆記大彙總【16年3月到至今】，包括Java基礎及深入知識點，Android技術博客，Python學習筆記等等，還包括平時開發中遇到的bug彙總，當然也在工作之餘收集了大量的面試題，長期更新維護並且修正，持續完善……開源的文件是markdown格式的！同時也開源了生活博客，從12年起，積累共計47篇[近20萬字]，轉載請註明出處，謝謝！
  • 鏈接地址：https://github.com/yangchong211/YCBlogs
  • 如果覺得好，可以star一下，謝謝！當然也歡迎提出建議，萬事起於忽微，量變引起質變！

1.什麼是Zygote進程

1.1 簡單介紹

  • Zygote進程是所有的android進程的父進程，包括SystemServer和各種應用進程都是通過Zygote進程fork出來的。Zygote（孵化）進程相當於是android系統的根進程，後面所有的進程都是通過這個進程fork出來的
  • 雖然Zygote進程相當於Android系統的根進程，但是事實上它也是由Linux系統的init進程啓動的。

1.2 各個進程的先後順序

  • init進程 --> Zygote進程 --> SystemServer進程 -->各種應用進程

1.3 進程作用說明

  • init進程：linux的根進程，android系統是基於linux系統的，因此可以算作是整個android操作系統的第一個進程；
  • Zygote進程：android系統的根進程，主要作用：可以作用Zygote進程fork出SystemServer進程和各種應用進程；
  • SystemService進程：主要是在這個進程中啓動系統的各項服務，比如ActivityManagerService，PackageManagerService，WindowManagerService服務等等；
  • 各種應用進程：啓動自己編寫的客戶端應用時，一般都是重新啓動一個應用進程，有自己的虛擬機與運行環境；

2.Zygote進程的啓動流程

2.1 源碼位置

  • 位置：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
  • Zygote進程mian方法主要執行邏輯：
    • 初始化DDMS；
    • 註冊Zygote進程的socket通訊；
    • 初始化Zygote中的各種類，資源文件，OpenGL，類庫，Text資源等等；
    • 初始化完成之後fork出SystemServer進程；
    • fork出SystemServer進程之後，關閉socket連接；

2.2 ZygoteInit類的main方法

  • init進程在啓動Zygote進程時一般都會調用ZygoteInit類的main方法，因此這裏看一下該方法的具體實現(基於android23源碼)；

    • 調用enableDdms()，設置DDMS可用，可以發現DDMS啓動的時機還是比較早的，在整個Zygote進程剛剛開始要啓動額時候就設置可用。
    • 之後初始化各種參數
    • 通過調用registerZygoteSocket方法，註冊爲Zygote進程註冊Socket
    • 然後調用preload方法實現預加載各種資源

    • 然後通過調用startSystemServer開啓SystemServer服務，這個是重點

      public static void main(String argv[]) {
try {
    //設置ddms可以用
    RuntimeInit.enableDdms();
    SamplingProfilerIntegration.start();
    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;
        } 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.");
    }

    registerZygoteSocket(socketName);
    EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
        SystemClock.uptimeMillis());
    preload();
    EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
        SystemClock.uptimeMillis());
    SamplingProfilerIntegration.writeZygoteSnapshot();

    gcAndFinalize();
    Trace.setTracingEnabled(false);

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

    Log.i(TAG, "Accepting command socket connections");
    runSelectLoop(abiList);

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

2.3 registerZygoteSocket(socketName)分析

  • 調用registerZygoteSocket（String socketName）爲Zygote進程註冊socket

    private static void registerZygoteSocket(String socketName) {
    if (sServerSocket == null) {
        int fileDesc;
        final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
        try {
            String env = System.getenv(fullSocketName);
            fileDesc = Integer.parseInt(env);
        } catch (RuntimeException ex) {
            throw new RuntimeException(fullSocketName + " unset or invalid", ex);
        }

        try {
            FileDescriptor fd = new FileDescriptor();
            fd.setInt$(fileDesc);
            sServerSocket = new LocalServerSocket(fd);
        } catch (IOException ex) {
            throw new RuntimeException(
                    "Error binding to local socket '" + fileDesc + "'", ex);
        }
    }
}

2.4 preLoad()方法分析

  • 源碼如下所示 
    static void preload() {
    Log.d(TAG, "begin preload");
    preloadClasses();
    preloadResources();
    preloadOpenGL();
    preloadSharedLibraries();
    preloadTextResources();
    // Ask the WebViewFactory to do any initialization that must run in the zygote process,
    // for memory sharing purposes.
    WebViewFactory.prepareWebViewInZygote();
    Log.d(TAG, "end preload");
}
  • 大概操作是這樣的：
    • preloadClasses()用於初始化Zygote中需要的class類；
    • preloadResources()用於初始化系統資源；
    • preloadOpenGL()用於初始化OpenGL；
    • preloadSharedLibraries()用於初始化系統libraries；
    • preloadTextResources()用於初始化文字資源；
    • prepareWebViewInZygote()用於初始化webview;

2.5 startSystemServer()啓動進程

  • 這段邏輯的執行邏輯就是通過Zygote fork出SystemServer進程

    private static boolean startSystemServer(String abiList, String socketName)
        throws MethodAndArgsCaller, RuntimeException {
    long capabilities = posixCapabilitiesAsBits(
        OsConstants.CAP_BLOCK_SUSPEND,
        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
    );
    /* Hardcoded command line to start the system server */
    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 {
        parsedArgs = new ZygoteConnection.Arguments(args);
        ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
        ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

        /* Request to fork the system server process */
        pid = Zygote.forkSystemServer(
                parsedArgs.uid, parsedArgs.gid,
                parsedArgs.gids,
                parsedArgs.debugFlags,
                null,
                parsedArgs.permittedCapabilities,
                parsedArgs.effectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        throw new RuntimeException(ex);
    }

    /* For child process */
    if (pid == 0) {
        if (hasSecondZygote(abiList)) {
            waitForSecondaryZygote(socketName);
        }

        handleSystemServerProcess(parsedArgs);
    }

    return true;
}

3.SystemServer進程啓動流程

3.1 SystemServer進程簡介

  • SystemServer進程主要的作用是在這個進程中啓動各種系統服務，比如ActivityManagerService，PackageManagerService，WindowManagerService服務，以及各種系統性的服務其實都是在SystemServer進程中啓動的，而當我們的應用需要使用各種系統服務的時候其實也是通過與SystemServer進程通訊獲取各種服務對象的句柄的。

3.2 SystemServer的main方法

  • 如下所示，比較簡單，只是new出一個SystemServer對象並執行其run方法，查看SystemServer類的定義我們知道其實final類型的，所以我們一般不能重寫或者繼承。
  • image

3.3 查看run方法

  • 代碼如下所示

    • 首先判斷系統當前時間，若當前時間小於1970年1月1日，則一些初始化操作可能會處所，所以當系統的當前時間小於1970年1月1日的時候，設置系統當前時間爲該時間點。
    • 然後是設置系統的語言環境等

    • 接着設置虛擬機運行內存，加載運行庫，設置SystemServer的異步消息

      private void run() {
if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
    Slog.w(TAG, "System clock is before 1970; setting to 1970.");
    SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
}

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", "");
}

Slog.i(TAG, "Entered the Android system server!");
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, SystemClock.uptimeMillis());

SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

if (SamplingProfilerIntegration.isEnabled()) {
    SamplingProfilerIntegration.start();
    mProfilerSnapshotTimer = new Timer();
    mProfilerSnapshotTimer.schedule(new TimerTask() {
        @Override
        public void run() {
            SamplingProfilerIntegration.writeSnapshot("system_server", null);
        }
    }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
}

// Mmmmmm... more memory!
VMRuntime.getRuntime().clearGrowthLimit();

// The system server has to run all of the time, so it needs to be
// as efficient as possible with its memory usage.
VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

// Some devices rely on runtime fingerprint generation, so make sure
// we've defined it before booting further.
Build.ensureFingerprintProperty();

// Within the system server, it is an error to access Environment paths without
// explicitly specifying a user.
Environment.setUserRequired(true);

// Ensure binder calls into the system always run at foreground priority.
BinderInternal.disableBackgroundScheduling(true);

// Prepare the main looper thread (this thread).
android.os.Process.setThreadPriority(
        android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
Looper.prepareMainLooper();

// Initialize native services.
System.loadLibrary("android_servers");

// Check whether we failed to shut down last time we tried.
// This call may not return.
performPendingShutdown();

// Initialize the system context.
createSystemContext();

// Create the system service manager.
mSystemServiceManager = new SystemServiceManager(mSystemContext);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

// Start services.
try {
    startBootstrapServices();
    startCoreServices();
    startOtherServices();
} catch (Throwable ex) {
    Slog.e("System", "******************************************");
    Slog.e("System", "************ Failure starting system services", ex);
    throw ex;
}

// For debug builds, log event loop stalls to dropbox for analysis.
if (StrictMode.conditionallyEnableDebugLogging()) {
    Slog.i(TAG, "Enabled StrictMode for system server main thread.");
}

// Loop forever.
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}

  • 然後下面的代碼是：

    // Initialize the system context.
createSystemContext();

// Create the system service manager.
mSystemServiceManager = new SystemServiceManager(mSystemContext);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

// Start services.
try {
    startBootstrapServices();
    startCoreServices();
    startOtherServices();
} catch (Throwable ex) {
    Slog.e("System", "******************************************");
    Slog.e("System", "************ Failure starting system services", ex);
    throw ex;
}

3.4 run方法中createSystemContext()解析

  • 調用createSystemContext()方法：
    • 可以看到在SystemServer進程中也存在着Context對象，並且是通過ActivityThread.systemMain方法創建context的，這一部分的邏輯以後會通過介紹Activity的啓動流程來介紹，這裏就不在擴展，只知道在SystemServer進程中也需要創建Context對象。 
      private void createSystemContext() {
ActivityThread activityThread = ActivityThread.systemMain();
mSystemContext = activityThread.getSystemContext();
mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);
}

3.5 mSystemServiceManager的創建

  • 看run方法中，通過SystemServiceManager的構造方法創建了一個新的SystemServiceManager對象，我們知道SystemServer進程主要是用來構建系統各種service服務的，而SystemServiceManager就是這些服務的管理對象。
  • 然後調用：
    • 將SystemServiceManager對象保存SystemServer進程中的一個數據結構中。 
      LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
  • 最後開始執行： 
    // Start services.
try {
    startBootstrapServices();
    startCoreServices();
    startOtherServices();
} catch (Throwable ex) {
    Slog.e("System", "******************************************");
    Slog.e("System", "************ Failure starting system services", ex);
    throw ex;
}
    • 裏面主要涉及了是三個方法：
      • startBootstrapServices() 主要用於啓動系統Boot級服務
      • startCoreServices() 主要用於啓動系統核心的服務
      • startOtherServices() 主要用於啓動一些非緊要或者是非需要及時啓動的服務

4.啓動服務

4.1 啓動哪些服務

  • 在開始執行啓動服務之前總是會先嚐試通過socket方式連接Zygote進程，在成功連接之後纔會開始啓動其他服務。
  • image

4.2 啓動服務流程源碼分析

  • 首先看一下startBootstrapServices方法：

    private void startBootstrapServices() {
    Installer installer = mSystemServiceManager.startService(Installer.class);

    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);

    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

    mActivityManagerService.initPowerManagement();

    // Manages LEDs and display backlight so we need it to bring up the display.
    mSystemServiceManager.startService(LightsService.class);

    // Display manager is needed to provide display metrics before package manager
    // starts up.
    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

    // We need the default display before we can initialize the package manager.
    mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

    // Only run "core" apps if we're encrypting the device.
    String cryptState = SystemProperties.get("vold.decrypt");
    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;
    }

    // Start the package manager.
    Slog.i(TAG, "Package Manager");
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    mFirstBoot = mPackageManagerService.isFirstBoot();
    mPackageManager = mSystemContext.getPackageManager();

    Slog.i(TAG, "User Service");
    ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());

    // Initialize attribute cache used to cache resources from packages.
    AttributeCache.init(mSystemContext);

    // Set up the Application instance for the system process and get started.
    mActivityManagerService.setSystemProcess();

    // The sensor service needs access to package manager service, app ops
    // service, and permissions service, therefore we start it after them.
    startSensorService();
}
  • 先執行： 
    Installer installer = mSystemServiceManager.startService(Installer.class);

  • mSystemServiceManager是系統服務管理對象，在main方法中已經創建完成，這裏我們看一下其startService方法的具體實現：

    • 可以看到通過反射器構造方法創建出服務類，然後添加到SystemServiceManager的服務列表數據中，最後調用了service.onStart()方法，因爲傳遞的是Installer.class 

      public <T extends SystemService> T startService(Class<T> serviceClass) {
final String name = serviceClass.getName();
Slog.i(TAG, "Starting " + name);

// Create the service.
if (!SystemService.class.isAssignableFrom(serviceClass)) {
    throw new RuntimeException("Failed to create " + name
            + ": service must extend " + SystemService.class.getName());
}
final T service;
try {
    Constructor<T> constructor = serviceClass.getConstructor(Context.class);
    service = constructor.newInstance(mContext);
} catch (InstantiationException ex) {
    throw new RuntimeException("Failed to create service " + name
            + ": service could not be instantiated", ex);
} catch (IllegalAccessException ex) {
    throw new RuntimeException("Failed to create service " + name
            + ": service must have a public constructor with a Context argument", ex);
} catch (NoSuchMethodException ex) {
    throw new RuntimeException("Failed to create service " + name
            + ": service must have a public constructor with a Context argument", ex);
} catch (InvocationTargetException ex) {
    throw new RuntimeException("Failed to create service " + name
            + ": service constructor threw an exception", ex);
}

// Register it.
mServices.add(service);

// Start it.
try {
    service.onStart();
} catch (RuntimeException ex) {
    throw new RuntimeException("Failed to start service " + name
            + ": onStart threw an exception", ex);
}
return service;
}
  • 看一下Installer的onStart方法：
    • 很簡單就是執行了mInstaller的waitForConnection方法，這裏簡單介紹一下Installer類，該類是系統安裝apk時的一個服務類，繼承SystemService（系統服務的一個抽象接口），需要在啓動完成Installer服務之後才能啓動其他的系統服務。 
      @Override
public void onStart() {
Slog.i(TAG, "Waiting for installd to be ready.");
mInstaller.waitForConnection();
}
  • 然後查看waitForConnection（）方法：
    • 通過追蹤代碼可以發現，其在不斷的通過ping命令連接Zygote進程（SystemServer和Zygote進程通過socket方式通訊，其他進程通過Binder方式通訊） 
      public void waitForConnection() {
for (;;) {
    if (execute("ping") >= 0) {
        return;
    }
    Slog.w(TAG, "installd not ready");
    SystemClock.sleep(1000);
}
}
  • 繼續看startBootstrapServices方法：
    • 這段代碼主要是用於啓動ActivityManagerService服務，併爲其設置SysServiceManager和Installer。ActivityManagerService是系統中一個非常重要的服務，Activity，service，Broadcast，contentProvider都需要通過其餘系統交互。 
      // Activity manager runs the show.
mActivityManagerService = mSystemServiceManager.startService(
    ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);

  • 首先看一下Lifecycle類的定義：

    • 可以看到其實ActivityManagerService的一個靜態內部類，在其構造方法中會創建一個ActivityManagerService，通過剛剛對Installer服務的分析我們知道，SystemServiceManager的startService方法會調用服務的onStart()方法，而在Lifecycle類的定義中我們看到其onStart（）方法直接調用了mService.start()方法，mService是Lifecycle類中對ActivityManagerService的引用

      public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;

public Lifecycle(Context context) {
    super(context);
    mService = new ActivityManagerService(context);
}

@Override
public void onStart() {
    mService.start();
}

public ActivityManagerService getService() {
    return mService;
}
}

4.3 啓動部分服務

  • 啓動PowerManagerService服務：
    • 啓動方式跟上面的ActivityManagerService服務相似都會調用其構造方法和onStart方法，PowerManagerService主要用於計算系統中和Power相關的計算，然後決策系統應該如何反應。同時協調Power如何與系統其它模塊的交互，比如沒有用戶活動時，屏幕變暗等等。 
      mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
    • 然後是啓動LightsService服務
      • 主要是手機中關於閃光燈，LED等相關的服務；也是會調用LightsService的構造方法和onStart方法； 
        mSystemServiceManager.startService(LightsService.class);
    • 然後是啓動DisplayManagerService服務
      • 主要是手機顯示方面的服務 
        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
  • 然後是啓動PackageManagerService，該服務也是android系統中一個比較重要的服務
    • 包括多apk文件的安裝，解析，刪除，卸載等等操作。
    • 可以看到PackageManagerService服務的啓動方式與其他服務的啓動方式有一些區別，直接調用了PackageManagerService的靜態main方法 
      Slog.i(TAG, "Package Manager");
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
    mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
mFirstBoot = mPackageManagerService.isFirstBoot();
mPackageManager = mSystemContext.getPackageManager();
    • 看一下其main方法的具體實現：
      • 可以看到也是直接使用new的方式創建了一個PackageManagerService對象，並在其構造方法中初始化相關變量，最後調用了ServiceManager.addService方法，主要是通過Binder機制與JNI層交互 
        public static PackageManagerService main(Context context, Installer installer,
boolean factoryTest, boolean onlyCore) {
PackageManagerService m = new PackageManagerService(context, installer,
    factoryTest, onlyCore);
ServiceManager.addService("package", m);
return m;
}

  • 然後查看startCoreServices方法：

    • 可以看到這裏啓動了BatteryService（電池相關服務），UsageStatsService，WebViewUpdateService服務等。

      private void startCoreServices() {
// Tracks the battery level.  Requires LightService.
mSystemServiceManager.startService(BatteryService.class);

// Tracks application usage stats.
mSystemServiceManager.startService(UsageStatsService.class);
mActivityManagerService.setUsageStatsManager(
        LocalServices.getService(UsageStatsManagerInternal.class));
// Update after UsageStatsService is available, needed before performBootDexOpt.
mPackageManagerService.getUsageStatsIfNoPackageUsageInfo();

// Tracks whether the updatable WebView is in a ready state and watches for update installs.
mSystemServiceManager.startService(WebViewUpdateService.class);
}

總結：

  • SystemServer進程是android中一個很重要的進程由Zygote進程啓動；
  • SystemServer進程主要用於啓動系統中的服務；
  • SystemServer進程啓動服務的啓動函數爲main函數；
  • SystemServer在執行過程中首先會初始化一些系統變量，加載類庫，創建Context對象，創建SystemServiceManager對象等之後纔開始啓動系統服務；
  • SystemServer進程將系統服務分爲三類：boot服務，core服務和other服務，並逐步啓動
  • SertemServer進程在嘗試啓動服務之前會首先嚐試與Zygote建立socket通訊，只有通訊成功之後纔會開始嘗試啓動服務；
  • 創建的系統服務過程中主要通過SystemServiceManager對象來管理，通過調用服務對象的構造方法和onStart方法初始化服務的相關變量；
  • 服務對象都有自己的異步消息對象，並運行在單獨的線程中；

參考博客

關於其他內容介紹

01.關於博客彙總鏈接

02.關於我的博客

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

創建一個成功的App前要考慮的5個要點

要不要晴天 2019-02-23 00:35:09

零基礎實現網易雲音樂播放器（3）

麪包理想 2019-02-23 00:25:45

FineReport如何手動推送APP消息

雄霸天下啦 2019-02-22 23:34:29

Oracle 11g-oracle 啓動與關閉

Z細銘 2019-02-23 13:04:30

如何將U盤製作成啓動盤

51CTOYoung 2019-02-23 13:00:58

系統啓動常見問題

剛剛 2019-02-23 12:57:19

oracle的啓動和關閉

dingjibin 2019-02-23 00:34:27

nginx

自由人jeep 2019-02-23 00:28:31

linux啓動過程

AlibaP5 2019-02-23 00:10:42

電腦硬件啓動順序

daihk924 2019-02-23 00:06:37

Linux自啓動設置詳解

zyl520cyp 2019-02-23 00:02:52

RHEL6開機流程

sharkyan 2019-02-22 23:51:38

Linux下， 啓動、重啓、停止， 服務的命令是多少？

堅持30天 2019-02-22 23:42:51

Nginx 的啓動、停止、平滑重啓、信號控制和平滑升級

運動軒 2019-02-22 23:38:01

安裝hadoop和配置hadoop，啓動namenode和設置免密登錄的詳細解析！

神蹟難覓 2019-02-22 23:33:27