為什麼Activity生命周期函數是運行在UI線程

這是我自己給自己提的問題，或者說是Activity的生命周期函數是怎樣運行在主線程的？下面簡單分析一下，討論的問題其實遠遠不止於這個問題。會涉及到進程的啟動，Binder的線程池，ActivityThread中的消息處理。

進程開啟

我們最開始接觸Android的時候，都知道主線程和非主線程區別，我們可以用Handler來將代碼運行在主線程中。而主線程是如何開啟的呢？在ActivityThread當中有個公有靜態main方法，每次ActivityManagerService請求Zygote進程fork一個新的進程的時候，ActivityManagerService會同時發送一個指定新進程啟動哪一個類的參數，ActivityManagerService指定的就是android.app.ActivityThread類。看看ActivityManagerService啟動新進程的代碼:

if (entryPoint == null) entryPoint = "android.app.ActivityThread";
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
       app.processName);
checkTime(startTime, "startProcess: asking zygote to start proc");
Process.ProcessStartResult startResult = Process.start(entryPoint,
       app.processName, uid, uid, gids, debugFlags, mountExternal,
       app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
       app.info.dataDir, entryPointArgs);

裡面的entryPoint就是指定了zygote會啟動的類。Process.start的第一個參數。可以看看Process.start函數，它會直接調用Process的startViaZygote私有靜態方法，兩個方法的參數是一致的:

private static ProcessStartResult startViaZygote(final String processClass,
                             final String niceName,
                             final int uid, final int gid,
                             final int[] gids,
                             int debugFlags, int mountExternal,
                             int targetSdkVersion,
                             String seInfo,
                             String abi,
                             String instructionSet,
                             String appDataDir,
                             String[] extraArgs)
                             throws ZygoteStartFailedEx {
   synchronized(Process.class) {
       ArrayList argsForZygote = new ArrayList();

       // --runtime-args, --setuid=, --setgid=,
       // and --setgroups= must go first
       argsForZygote.add("--runtime-args");
       argsForZygote.add("--setuid=" + uid);
       argsForZygote.add("--setgid=" + gid);
       if ((debugFlags & Zygote.DEBUG_ENABLE_JNI_LOGGING) != 0) {
           argsForZygote.add("--enable-jni-logging");
       }
       if ((debugFlags & Zygote.DEBUG_ENABLE_SAFEMODE) != 0) {
           argsForZygote.add("--enable-safemode");
       }
       if ((debugFlags & Zygote.DEBUG_ENABLE_DEBUGGER) != 0) {
           argsForZygote.add("--enable-debugger");
       }
       if ((debugFlags & Zygote.DEBUG_ENABLE_CHECKJNI) != 0) {
           argsForZygote.add("--enable-checkjni");
       }
       if ((debugFlags & Zygote.DEBUG_ENABLE_JIT) != 0) {
           argsForZygote.add("--enable-jit");
       }
       if ((debugFlags & Zygote.DEBUG_GENERATE_DEBUG_INFO) != 0) {
           argsForZygote.add("--generate-debug-info");
       }
       if ((debugFlags & Zygote.DEBUG_ENABLE_ASSERT) != 0) {
           argsForZygote.add("--enable-assert");
       }
       if (mountExternal == Zygote.MOUNT_EXTERNAL_DEFAULT) {
           argsForZygote.add("--mount-external-default");
       } else if (mountExternal == Zygote.MOUNT_EXTERNAL_READ) {
           argsForZygote.add("--mount-external-read");
       } else if (mountExternal == Zygote.MOUNT_EXTERNAL_WRITE) {
           argsForZygote.add("--mount-external-write");
       }
       argsForZygote.add("--target-sdk-version=" + targetSdkVersion);

       //TODO optionally enable debuger
       //argsForZygote.add("--enable-debugger");

       // --setgroups is a comma-separated list
       if (gids != null && gids.length > 0) {
           StringBuilder sb = new StringBuilder();
           sb.append("--setgroups=");
           int sz = gids.length;
           for (int i = 0; i < sz; i++) {
               if (i != 0) {
                   sb.append(',');
               }
               sb.append(gids[i]);
           }
           argsForZygote.add(sb.toString());
       }
       if (niceName != null) {
           argsForZygote.add("--nice-name=" + niceName);
       }
       if (seInfo != null) {
           argsForZygote.add("--seinfo=" + seInfo);
       }
       if (instructionSet != null) {
           argsForZygote.add("--instruction-set=" + instructionSet);
       }
       if (appDataDir != null) {
           argsForZygote.add("--app-data-dir=" + appDataDir);
       }
       argsForZygote.add(processClass);
       if (extraArgs != null) {
           for (String arg : extraArgs) {
               argsForZygote.add(arg);
           }
       }
       return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
   }
}

為了節省空間，我把一些空格給去掉了。這個方法就是將參數組裝到argsForZygote當中，存到數組裡面。而zygoteSendArgsAndGetResult方法則是通過socket將這些內容發送給Zygote進程：

/**
* Sends an argument list to the zygote process, which starts a new child
* and returns the child's pid. Please note: the present implementation
* replaces newlines in the argument list with spaces.
*
* @throws ZygoteStartFailedEx if process start failed for any reason
*/
private static ProcessStartResult zygoteSendArgsAndGetResult(
       ZygoteState zygoteState, ArrayList args)
       throws ZygoteStartFailedEx {
   try {
       /**
        * See com.android.internal.os.ZygoteInit.readArgumentList()
        * Presently the wire format to the zygote process is:
        * a) a count of arguments (argc, in essence)
        * b) a number of newline-separated argument strings equal to count
        *
        * After the zygote process reads these it will write the pid of
        * the child or -1 on failure, followed by boolean to
        * indicate whether a wrapper process was used.
        */
       final BufferedWriter writer = zygoteState.writer;
       final DataInputStream inputStream = zygoteState.inputStream;

       writer.write(Integer.toString(args.size()));
       writer.newLine();

       int sz = args.size();
       for (int i = 0; i < sz; i++) {
           String arg = args.get(i);
           if (arg.indexOf('\n') >= 0) {
               throw new ZygoteStartFailedEx(
                       "embedded newlines not allowed");
           }
           writer.write(arg);
           writer.newLine();
       }

       writer.flush();

       // Should there be a timeout on this?
       ProcessStartResult result = new ProcessStartResult();
       result.pid = inputStream.readInt();
       if (result.pid < 0) {
           throw new ZygoteStartFailedEx("fork() failed");
       }
       result.usingWrapper = inputStream.readBoolean();
       return result;
   } catch (IOException ex) {
       zygoteState.close();
       throw new ZygoteStartFailedEx(ex);
   }
}

上面就是跟zygote進行socket通信的部分，相信用過socket的看著都非常熟悉。關於zygote啟動，並且ActivityManagerService如何建立通信的，當然直接看源碼是最合適的。

而zygote如何回應的？看看zygote部分啟動一個新進程後的代碼，zygote中fork之後，子進程會調用RuntimeInit.zygoteInit方法，所以直接從RuntimeInit.zygoteInit開始看。

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

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

   commonInit();
   nativeZygoteInit();
   applicationInit(targetSdkVersion, argv, classLoader);
}

nativeZygoteInit方法會調用ProcessState開啟Binder線程池，供與Binder驅動通信使用。而applicationInit會調用invokeStaticMain方法調用ActivityManagerService傳入的ActivityThread類的main方法。

其實整個流程就跟我們使用java命令運行程序是一樣的。

main方法裡面會設置主線程loop，然後調用Looper.loop()處理消息:

public static void main(String[] args) {
   Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
   SamplingProfilerIntegration.start();

   // CloseGuard defaults to true and can be quite spammy.  We
   // disable it here, but selectively enable it later (via
   // StrictMode) on debug builds, but using DropBox, not logs.
   CloseGuard.setEnabled(false);

   Environment.initForCurrentUser();

   // Set the reporter for event logging in libcore
   EventLogger.setReporter(new EventLoggingReporter());

   AndroidKeyStoreProvider.install();

   // Make sure TrustedCertificateStore looks in the right place for CA certificates
   final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
   TrustedCertificateStore.setDefaultUserDirectory(configDir);

   Process.setArgV0("");

   Looper.prepareMainLooper();

   ActivityThread thread = new ActivityThread();
   thread.attach(false);

   if (sMainThreadHandler == null) {
       sMainThreadHandler = thread.getHandler();
   }

   if (false) {
       Looper.myLooper().setMessageLogging(new
               LogPrinter(Log.DEBUG, "ActivityThread"));
   }

   // End of event ActivityThreadMain.
   Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
   Looper.loop();  //消息loop

   throw new RuntimeException("Main thread loop unexpectedly exited");
}

Handler機制的使用

而ActivityManagerService使用binder機制(IApplicationThread)調用某個進程的四大組件時，ActivityThread部分，一開始是運行在Binder線程池的，然後通過Handler機制發送消息給主線程，運行相關內容，比如說啟動Activity，IApplicationThread的方法scheduleLaunchActivity實現就如此：

private class ApplicationThread extends ApplicationThreadNative {



@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
       ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
       CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
       int procState, Bundle state, PersistableBundle persistentState,
       List pendingResults, List pendingNewIntents,
       boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {

   updateProcessState(procState, false);

   ActivityClientRecord r = new ActivityClientRecord();

   r.token = token;
   r.ident = ident;
   r.intent = intent;
   r.referrer = referrer;
   r.voiceInteractor = voiceInteractor;
   r.activityInfo = info;
   r.compatInfo = compatInfo;
   r.state = state;
   r.persistentState = persistentState;

   r.pendingResults = pendingResults;
   r.pendingIntents = pendingNewIntents;

   r.startsNotResumed = notResumed;
   r.isForward = isForward;

   r.profilerInfo = profilerInfo;

   r.overrideConfig = overrideConfig;
   updatePendingConfiguration(curConfig);

   sendMessage(H.LAUNCH_ACTIVITY, r);
}

}

最終消息處理的地方是在類ActivityThread.H（Handler的子類）的handleMessage方法中，ActivityThread.H的looper就是主線程的looper，這裡就已經是運行在主線程了：

public void handleMessage(Message msg) {
   if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
   switch (msg.what) {
       case LAUNCH_ACTIVITY: {
           Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
           final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

           r.packageInfo = getPackageInfoNoCheck(
                   r.activityInfo.applicationInfo, r.compatInfo);
           handleLaunchActivity(r, null);
           Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
       } break;

}

其他的四大組件也是一樣的