App啓動流程

時間 2020-01-24

標籤 app 啓動流程简体版

原文原文鏈接

目錄介紹

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源碼)；php

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

而後經過調用startSystemServer開啓SystemServer服務，這個是重點html

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進程註冊socketjava

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進程linux

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類型的，因此咱們通常不能重寫或者繼承。

3.3 查看run方法

代碼以下所示android

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

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

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

而後下面的代碼是：github

// 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進程，在成功鏈接以後纔會開始啓動其餘服務。

4.2 啓動服務流程源碼分析

首先看一下startBootstrapServices方法：web

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 segmentfault

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方法初始化服務的相關變量；
服務對象都有本身的異步消息對象，並運行在單獨的線程中；