理解Android進程創建流程

基於Android 6.0的源碼剖析，分析Android進程是如何一步步創建的，本文涉及到的源碼：

/frameworks/base/core/java/android/os/Process.java
/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
/frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java

/frameworks/base/core/java/com/android/internal/os/Zygote.java
/frameworks/base/core/jni/com_android_internal_os_Zygote.cpp

/frameworks/base/cmds/app_process/App_main.cpp （內含AppRuntime類）
/frameworks/base/core/jni/AndroidRuntime.cpp

/libcore/dalvik/src/main/java/dalvik/system/ZygoteHooks.java
/art/runtime/native/dalvik_system_ZygoteHooks.cc
/art/runtime/Runtime.cc
/art/runtime/Thread.cc
/art/runtime/signal_catcher.cc

概述

本文要介紹的是進程的創建，先簡單說說進程與線程的區別。

進程：每個App在啓動前必須先創建一個進程，該進程是由Zygote fork出來的，進程具有獨立的資源空間，用於承載App上運行的各種Activity/Service等組件。進程對於上層應用來說是完全透明的，這也是google有意爲之，讓App程序都是運行在Android Runtime。大多數情況一個App就運行在一個進程中，除非在AndroidManifest.xml中配置Android:process屬性，或通過native代碼fork進程。

線程：線程對應用開發者來說非常熟悉，比如每次new Thread().start()都會創建一個新的線程，該線程並沒有自己獨立的地址空間，而是與其所在進程之間資源共享。從Linux角度來說進程與線程都是一個task_struct結構體，除了是否共享資源外，並沒有其他本質的區別。

對於大多數的應用開發者來說創建線程比較熟悉，而對於創建進程並沒有太多的概念。對於系統工程師或者高級開發者，還是有很必要了解Android系統是如何一步步地創建出一個進程的。先來看一張進程創建過程的簡要圖：

圖解：

App發起進程：當從桌面啓動應用，則發起進程便是Launcher所在進程；當從某App內啓動遠程進程，則發送進程便是該App所在進程。發起進程先通過binder發送消息給system_server進程；
system_server進程：調用Process.start()方法，通過socket向zygote進程發送創建新進程的請求；
zygote進程：在執行ZygoteInit.main()後便進入runSelectLoop()循環體內，當有客戶端連接時便會執行ZygoteConnection.runOnce()方法，再經過層層調用後fork出新的應用進程；
新進程：執行handleChildProc方法，最後調用ActivityThread.main()方法。

可能朋友不是很瞭解system_server進程和Zygote進程，下面簡要說說：

system_server進程：是用於管理整個Java framework層，包含ActivityManager，PowerManager等各種系統服務;
Zygote進程：是Android系統的首個Java進程，Zygote是所有Java進程的父進程，包括 system_server進程以及所有的App進程都是Zygote的子進程，注意這裏說的是子進程，而非子線程。

如果想更進一步瞭解system_server進程和Zygote進程在整個Android系統所處的地位，可查看我的另一個文章Android系統-開篇。

接下來從Android 6.0源碼，展開講解進程創建是一個怎樣的過程。

1. Process.start

public static final ProcessStartResult start(final String processClass,
                              final String niceName,
                              int uid, int gid, int[] gids,
                              int debugFlags, int mountExternal,
                              int targetSdkVersion,
                              String seInfo,
                              String abi,
                              String instructionSet,
                              String appDataDir,
                              String[] zygoteArgs) {
    try {
         //【見流程2】
        return startViaZygote(processClass, niceName, uid, gid, gids,
                debugFlags, mountExternal, targetSdkVersion, seInfo,
                abi, instructionSet, appDataDir, zygoteArgs);
    } catch (ZygoteStartFailedEx ex) {
        throw new RuntimeException("");
    }
}

2. startViaZygote

[-> Process.java]

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<String> argsForZygote = new ArrayList<String>();

        argsForZygote.add("--runtime-args");
        argsForZygote.add("--setuid=" + uid);
        argsForZygote.add("--setgid=" + gid);
        argsForZygote.add("--target-sdk-version=" + targetSdkVersion);

        if (niceName != null) {
            argsForZygote.add("--nice-name=" + niceName);
        }
        if (appDataDir != null) {
            argsForZygote.add("--app-data-dir=" + appDataDir);
        }
        argsForZygote.add(processClass);

        if (extraArgs != null) {
            for (String arg : extraArgs) {
                argsForZygote.add(arg);
            }
        }
         //【見流程3】
        return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
    }
}

該過程主要工作是生成argsForZygote數組，該數組保存了進程的uid、gid、groups、target-sdk、nice-name等一系列的參數。

3. zygoteSendArgsAndGetResult

[-> Process.java]

Step 3-1. openZygoteSocketIfNeeded

private static ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
    if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
        try {
            primaryZygoteState = ZygoteState.connect(ZYGOTE_SOCKET);
        } catch (IOException ioe) {
            throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
        }
    }

    if (primaryZygoteState.matches(abi)) {
        return primaryZygoteState;
    }

    //當主zygote沒能匹配成功，則嘗試第二個zygote
    if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
        try {
        secondaryZygoteState = ZygoteState.connect(SECONDARY_ZYGOTE_SOCKET);
        } catch (IOException ioe) {
            throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
        }
    }

    if (secondaryZygoteState.matches(abi)) {
        return secondaryZygoteState;
    }

    throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}

openZygoteSocketIfNeeded(abi)方法是根據當前的abi來選擇與zygote還是zygote64來進行通信。

Step 3-2. zygoteSendArgsAndGetResult

private static ProcessStartResult zygoteSendArgsAndGetResult(
        ZygoteState zygoteState, ArrayList<String> args)
        throws ZygoteStartFailedEx {
    try {
        //
        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();

        ProcessStartResult result = new ProcessStartResult();
        //等待socket服務端（即zygote）返回新創建的進程pid;
        //對於等待時長問題，Google正在考慮此處是否應該有一個timeout，但目前是沒有的。
        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);
    }
}

這個方法的主要功能是通過socket通道向Zygote進程發送一個參數列表，然後進入阻塞等待狀態，直到遠端的socket服務端發送回來新創建的進程pid才返回。

既然system_server進程通過socket向Zygote進程發送消息，這是便會喚醒Zygote進程，來響應socket客戶端的請求（即system_server端），接下來的操作便是在Zygote進程中執行。

4. runSelectLoop

[–>ZygoteInit.java]

public static void main(String argv[]) {
    try {
        runSelectLoop(abiList);
        ....
    } catch (MethodAndArgsCaller caller) {
        caller.run(); //【見流程13】
    } catch (RuntimeException ex) {
        closeServerSocket();
        throw ex;
    }
}

後續會講到runSelectLoop()方法會拋出異常MethodAndArgsCaller，從而進入caller.run()方法。

[-> ZygoteInit.java]

private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
    ...

    ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
    while (true) {
        for (int i = pollFds.length - 1; i >= 0; --i) {
            //採用I/O多路複用機制，當客戶端發出連接請求或者數據處理請求時，跳過continue，執行後面的代碼
            if ((pollFds[i].revents & POLLIN) == 0) {
                continue;
            }
            if (i == 0) {
                //創建客戶端連接
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
            } else {
                //處理客戶端數據事務 【見流程5】
                boolean done = peers.get(i).runOnce();
                if (done) {
                    peers.remove(i);
                    fds.remove(i);
                }
            }
        }
    }
}

沒有連接請求時會進入休眠狀態，當有創建新進程的連接請求時，喚醒Zygote進程，創建Socket通道ZygoteConnection，然後執行ZygoteConnection的runOnce()方法。

5. runOnce

[-> ZygoteConnection.java]

boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {

    String args[];
    Arguments parsedArgs = null;
    FileDescriptor[] descriptors;

    try {
        //讀取socket客戶端發送過來的參數列表
        args = readArgumentList(); 
        descriptors = mSocket.getAncillaryFileDescriptors();
    } catch (IOException ex) {
        closeSocket();
        return true;
    }

    PrintStream newStderr = null;
    if (descriptors != null && descriptors.length >= 3) {
        newStderr = new PrintStream(new FileOutputStream(descriptors[2]));
    }

    int pid = -1;
    FileDescriptor childPipeFd = null;
    FileDescriptor serverPipeFd = null;

    try {
        //將binder客戶端傳遞過來的參數，解析成Arguments對象格式
        parsedArgs = new Arguments(args);
        ...

        int [] fdsToClose = { -1, -1 };

        FileDescriptor fd = mSocket.getFileDescriptor();
        if (fd != null) {
            fdsToClose[0] = fd.getInt$();
        }

        fd = ZygoteInit.getServerSocketFileDescriptor();
        if (fd != null) {
            fdsToClose[1] = fd.getInt$();
        }
        fd = null;
        【見流程6】
        pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
                parsedArgs.appDataDir);
    } catch (Exception e) {
        ...
    }

    try {
        if (pid == 0) {
            //子進程執行
            IoUtils.closeQuietly(serverPipeFd);
            serverPipeFd = null;
            【見流程7】
            handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);

            // 不應到達此處，子進程預期的是拋出異常ZygoteInit.MethodAndArgsCaller或者執行exec().
            return true;
        } else {
            //父進程執行
            IoUtils.closeQuietly(childPipeFd);
            childPipeFd = null;
            return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
        }
    } finally {
        IoUtils.closeQuietly(childPipeFd);
        IoUtils.closeQuietly(serverPipeFd);
    }
}

6. forkAndSpecialize

[-> Zygote.java]

public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
      int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
      String instructionSet, String appDataDir) {
    VM_HOOKS.preFork(); 【見流程6-1】
    int pid = nativeForkAndSpecialize(
              uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
              instructionSet, appDataDir); 【見流程6-2】
    ...
    VM_HOOKS.postForkCommon(); 【見流程6-3】
    return pid;
}

這裏VM_HOOKS是做什麼的呢？

先說說Zygote進程，如下圖：

從圖中可知Zygote進程有4個子線程，分別是ReferenceQueueDaemon、FinalizerDaemon、FinalizerWatchdogDaemon、HeapTaskDaemon，此處稱爲爲Zygote的4個Daemon子線程。圖中線程名顯示的並不完整是由於底層的進程結構體task_struct是由長度爲16的char型數組保存，超過15個字符便會截斷。

可能有人會問zygote64進程不是還有system_server，com.android.phone等子線程，怎麼會只有4個呢？那是因爲這些並不是Zygote子線程，而是Zygote的子進程。在圖中用紅色圈起來的是進程的VSIZE，virtual size)，代表的是進程虛擬地址空間大小。線程與進程的最爲本質的區別便是是否共享內存空間，圖中VSIZE和Zygote進程相同的纔是Zygote的子線程，否則就是Zygote的子進程。

6-1 preFork

[-> ZygoteHooks.java]

 public void preFork() {
    Daemons.stop(); //停止4個Daemon子線程【見流程6-1-1】
    waitUntilAllThreadsStopped(); //等待所有子線程結束【見流程6-1-2】
    token = nativePreFork(); //完成gc堆的初始化工作【見流程6-1-3】
}

Step 6-1-1. Daemons.stop

public static void stop() {
    HeapTaskDaemon.INSTANCE.stop(); //Java堆整理線程
    ReferenceQueueDaemon.INSTANCE.stop(); //引用隊列線程
    FinalizerDaemon.INSTANCE.stop(); //析構線程
    FinalizerWatchdogDaemon.INSTANCE.stop(); //析構監控線程
}

Step 6-1-2. waitUntilAllThreadsStopped

private static void waitUntilAllThreadsStopped() {
    File tasks = new File("/proc/self/task");
    // 當/proc中線程數大於1，就出讓CPU直到只有一個線程，才退出循環
    while (tasks.list().length > 1) {
        Thread.yield(); 
    }
}

Step 6-1-3. nativePreFork

nativePreFork通過JNI最終調用的是dalvik_system_ZygoteHooks.cc中的ZygoteHooks_nativePreFork()方法，如下：

static jlong ZygoteHooks_nativePreFork(JNIEnv* env, jclass) {
    Runtime* runtime = Runtime::Current();
    CHECK(runtime->IsZygote()) << "runtime instance not started with -Xzygote";
    runtime->PreZygoteFork(); 【見流程6-1-3-1】
    if (Trace::GetMethodTracingMode() != TracingMode::kTracingInactive) {
      Trace::Pause();
    }
    //將線程轉換爲long型並保存到token，該過程是非安全的
    return reinterpret_cast<jlong>(ThreadForEnv(env));
}

Step 6-1-3-1. PreZygoteFork

void Runtime::PreZygoteFork() {
    // 堆的初始化工作。這裏就不繼續再往下追了，等後續有空專門謝謝關於art虛擬機
    heap_->PreZygoteFork(); 
}

VM_HOOKS.preFork()的主要功能便是停止Zygote的4個Daemon子線程的運行，等待並確保Zygote是單線程（用於提升fork效率），並等待這些線程的停止，初始化gc堆的工作。

6-2 nativeForkAndSpecialize

nativeForkAndSpecialize()通過JNI最終調用的是com_android_internal_os_Zygote.cpp中的com_android_internal_os_Zygote_nativeForkAndSpecialize()方法，如下：

[-> com_android_internal_os_Zygote.cpp]

static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(
    JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
    jint debug_flags, jobjectArray rlimits,
    jint mount_external, jstring se_info, jstring se_name,
    jintArray fdsToClose, jstring instructionSet, jstring appDataDir) {
    // 將CAP_WAKE_ALARM賦予藍牙進程
    jlong capabilities = 0;
    if (uid == AID_BLUETOOTH) {
        capabilities |= (1LL << CAP_WAKE_ALARM);
    }
    【見流程6-2-1】
    return ForkAndSpecializeCommon(env, uid, gid, gids, debug_flags,
            rlimits, capabilities, capabilities, mount_external, se_info,
            se_name, false, fdsToClose, instructionSet, appDataDir);
}

Step 6-2-1.ForkAndSpecializeCommon

[-> com_android_internal_os_Zygote.cpp]

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) {
  SetSigChldHandler(); //設置子進程的signal信號處理函數
  pid_t pid = fork(); //fork子進程 【見流程6-2-1-1】
  if (pid == 0) {
    //進入子進程
    DetachDescriptors(env, fdsToClose); //關閉並清除文件描述符

    if (!is_system_server) {
        //對於非system_server子進程，則創建進程組
        int rc = createProcessGroup(uid, getpid());
    }
    SetGids(env, javaGids); //設置設置group
    SetRLimits(env, javaRlimits); //設置資源limit

    int rc = setresgid(gid, gid, gid);
    rc = setresuid(uid, uid, uid);

    SetCapabilities(env, permittedCapabilities, effectiveCapabilities);
    SetSchedulerPolicy(env); //設置調度策略

     //selinux上下文
    rc = selinux_android_setcontext(uid, is_system_server, se_info_c_str, se_name_c_str);

    if (se_info_c_str == NULL && is_system_server) {
      se_name_c_str = "system_server";
    }
    if (se_info_c_str != NULL) {
      SetThreadName(se_name_c_str); //設置線程名爲system_server，方便調試
    }
    UnsetSigChldHandler(); //設置子進程的signal信號處理函數爲默認函數
    //等價於調用zygote.callPostForkChildHooks() 【見流程6-2-2-1】
    env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, debug_flags,
                              is_system_server ? NULL : instructionSet);
    ...

  } else if (pid > 0) {
    //進入父進程，即Zygote進程
  }
  return pid;
}

Step 6-2-1-1. fork()

fork()採用copy on write技術，這是linux創建進程的標準方法，調用一次，返回兩次，返回值有3種類型。

父進程中，fork返回新創建的子進程的pid;
子進程中，fork返回0；
當出現錯誤時，fork返回負數。（當進程數超過上限或者系統內存不足時會出錯）

fork()的主要工作是尋找空閒的進程號pid，然後從父進程拷貝進程信息，例如數據段和代碼段空間等，當然也包含拷貝fork()代碼之後的要執行的代碼到新的進程。

下面，說說zygote的fork()過程：

Zygote進程是所有Android進程的母體，包括system_server進程以及App進程都是由Zygote進程孵化而來。zygote利用fork()方法生成新進程，對於新進程A複用Zygote進程本身的資源，再加上新進程A相關的資源，構成新的應用進程A。何爲copy on write(寫時複製)？當進程A執行修改某個內存數據時（這便是on write時機），才發生缺頁中斷，從而分配新的內存地址空間（這便是copy操作），對於copy on write是基於內存頁，而不是基於進程的。關於Zygote進程的libc、vm、preloaded classes、preloaded resources是如何生成的，可查看另一個文章Android系統啓動-zygote篇。

Step 6-2-2-1. Zygote.callPostForkChildHooks

private static void callPostForkChildHooks(int debugFlags, boolean isSystemServer,
        String instructionSet) {
    VM_HOOKS.postForkChild(debugFlags, isSystemServer, instructionSet);
}

public void postForkChild(int debugFlags, String instructionSet) {
    【見流程6-2-2-1-1】
    nativePostForkChild(token, debugFlags, instructionSet);
    Math.setRandomSeedInternal(System.currentTimeMillis());
}

在這裏，設置了新進程Random隨機數種子爲當前系統時間，也就是在進程創建的那一刻就決定了未來隨機數的情況，也就是僞隨機。

Step 6-2-2-1-1. nativePostForkChild

最終調用dalvik_system_ZygoteHooks的ZygoteHooks_nativePostForkChild

[-> dalvik_system_ZygoteHooks.cc]

static void ZygoteHooks_nativePostForkChild(JNIEnv* env, jclass, jlong token, jint debug_flags,
                                            jstring instruction_set) {
    Thread* thread = reinterpret_cast<Thread*>(token);
    //設置新進程的主線程id
    thread->InitAfterFork();
    ..
    if (instruction_set != nullptr) {
      ScopedUtfChars isa_string(env, instruction_set);
      InstructionSet isa = GetInstructionSetFromString(isa_string.c_str());
      Runtime::NativeBridgeAction action = Runtime::NativeBridgeAction::kUnload;
      if (isa != kNone && isa != kRuntimeISA) {
        action = Runtime::NativeBridgeAction::kInitialize;
      }
      【見流程6-2-2-1-1-1】
      Runtime::Current()->DidForkFromZygote(env, action, isa_string.c_str());
    } else {
      Runtime::Current()->DidForkFromZygote(env, Runtime::NativeBridgeAction::kUnload, nullptr);
    }
}

Step 6-2-2-1-1-1. DidForkFromZygote

[-> Runtime.cc]

void Runtime::DidForkFromZygote(JNIEnv* env, NativeBridgeAction action, const char* isa) {
  is_zygote_ = false;
  if (is_native_bridge_loaded_) {
    switch (action) {
      case NativeBridgeAction::kUnload:
        UnloadNativeBridge(); //卸載用於跨平臺的橋連庫
        is_native_bridge_loaded_ = false;
        break;
      case NativeBridgeAction::kInitialize:
        InitializeNativeBridge(env, isa);//初始化用於跨平臺的橋連庫
        break;
    }
  }
  //創建Java堆處理的線程池
  heap_->CreateThreadPool();
  //重置gc性能數據，以保證進程在創建之前的GCs不會計算到當前app上。
  heap_->ResetGcPerformanceInfo();
  if (jit_.get() == nullptr && jit_options_->UseJIT()) {
    //當flag被設置，並且還沒有創建JIT時，則創建JIT
    CreateJit();
  }
  //設置信號處理函數
  StartSignalCatcher();
  //啓動JDWP線程，當命令debuger的flags指定"suspend=y"時，則暫停runtime
  Dbg::StartJdwp();
}

關於信號處理過程，其代碼位於signal_catcher.cc文件中，後續會單獨講解。

6-3 postForkCommon

[-> ZygoteHooks.java]

public void postForkCommon() {
    Daemons.start(); 【見流程6-3-1】
}

Step 6-3-1. Daemons.start

public static void start() {
    ReferenceQueueDaemon.INSTANCE.start();
    FinalizerDaemon.INSTANCE.start();
    FinalizerWatchdogDaemon.INSTANCE.start();
    HeapTaskDaemon.INSTANCE.start();
}

VM_HOOKS.postForkCommon的主要功能是在fork新進程後，啓動Zygote的4個Daemon線程，java堆整理，引用隊列，以及析構線程。

forkAndSpecialize小結

調用關係鏈：

Zygote.forkAndSpecialize
	ZygoteHooks.preFork
		Daemons.stop
		ZygoteHooks.nativePreFork
			dalvik_system_ZygoteHooks.ZygoteHooks_nativePreFork
				Runtime::PreZygoteFork
					heap_->PreZygoteFork()
	Zygote.nativeForkAndSpecialize
		com_android_internal_os_Zygote.ForkAndSpecializeCommon
			fork()
			Zygote.callPostForkChildHooks
				ZygoteHooks.postForkChild
					dalvik_system_ZygoteHooks.nativePostForkChild
						Runtime::DidForkFromZygote
	ZygoteHooks.postForkCommon
		Daemons.start

時序圖：

點擊查看大圖

到此App進程已完成了創建的所有工作，接下來開始新創建的App進程的工作。在前面ZygoteConnection.runOnce方法中，zygote進程執行完forkAndSpecialize()後，新創建的App進程便進入handleChildProc()方法，下面的操作運行在App進程。

7. handleChildProc

[-> ZygoteConnection.java]

private void handleChildProc(Arguments parsedArgs,
        FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
        throws ZygoteInit.MethodAndArgsCaller {

    //關閉Zygote的socket兩端的連接
    closeSocket();
    ZygoteInit.closeServerSocket();

    if (descriptors != null) {
        try {
            Os.dup2(descriptors[0], STDIN_FILENO);
            Os.dup2(descriptors[1], STDOUT_FILENO);
            Os.dup2(descriptors[2], STDERR_FILENO);
            for (FileDescriptor fd: descriptors) {
                IoUtils.closeQuietly(fd);
            }
            newStderr = System.err;
        } catch (ErrnoException ex) {
            Log.e(TAG, "Error reopening stdio", ex);
        }
    }

    if (parsedArgs.niceName != null) {
        //設置進程名
        Process.setArgV0(parsedArgs.niceName);
    }

    if (parsedArgs.invokeWith != null) {
        //據說這是用於檢測進程內存泄露或溢出時場景而設計，後續還需要進一步分析。
        WrapperInit.execApplication(parsedArgs.invokeWith,
                parsedArgs.niceName, parsedArgs.targetSdkVersion,
                VMRuntime.getCurrentInstructionSet(),
                pipeFd, parsedArgs.remainingArgs);
    } else {
        //執行目標類的main()方法 【見流程8】
        RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
                parsedArgs.remainingArgs, null);
    }
}

8. zygoteInit

[–>RuntimeInit.java]

public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
        throws ZygoteInit.MethodAndArgsCaller {

    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "RuntimeInit");
    redirectLogStreams(); //重定向log輸出

    commonInit(); // 通用的一些初始化【見流程9】
    nativeZygoteInit(); // zygote初始化 【見流程10】
    applicationInit(targetSdkVersion, argv, classLoader); // 應用初始化【見流程11】
}

9. commonInit

[–>RuntimeInit.java]

private static final void commonInit() {
    // 設置默認的未捕捉異常處理方法
    Thread.setDefaultUncaughtExceptionHandler(new UncaughtHandler());

    // 設置市區，中國時區爲"Asia/Shanghai"
    TimezoneGetter.setInstance(new TimezoneGetter() {
        @Override
        public String getId() {
            return SystemProperties.get("persist.sys.timezone");
        }
    });
    TimeZone.setDefault(null);

    //重置log配置
    LogManager.getLogManager().reset(); 
    new AndroidConfig(); 

    // 設置默認的HTTP User-agent格式,用於 HttpURLConnection。
    String userAgent = getDefaultUserAgent();
    System.setProperty("http.agent", userAgent);

    // 設置socket的tag，用於網絡流量統計
    NetworkManagementSocketTagger.install();
}

默認的HTTP User-agent格式，例如：

 "Dalvik/1.1.0 (Linux; U; Android 6.0.1；LenovoX3c70 Build/LMY47V)".

10. nativeZygoteInit

nativeZygoteInit()方法在AndroidRuntime.cpp中，進行了jni映射，對應下面的方法。

[–>AndroidRuntime.cpp]

static void com_android_internal_os_RuntimeInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
    gCurRuntime->onZygoteInit(); //此處的gCurRuntime爲AppRuntime，是在AndroidRuntime.cpp中定義的
}

[–>app_main.cpp]

virtual void onZygoteInit()
{
    sp<ProcessState> proc = ProcessState::self();
    proc->startThreadPool(); //啓動新binder線程
}

ProcessState::self()是單例模式，主要工作是調用open()打開/dev/binder驅動設備，再利用mmap()映射內核的地址空間，將Binder驅動的fd賦值ProcessState對象中的變量mDriverFD，用於交互操作。startThreadPool()是創建一個新的binder線程，不斷進行talkWithDriver()，在binder系列文章中的註冊服務(addService)詳細這兩個方法的執行原理。

11. applicationInit

[–>RuntimeInit.java]

private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
        throws ZygoteInit.MethodAndArgsCaller {
    //true代表應用程序退出時不調用AppRuntime.onExit()，否則會在退出前調用
    nativeSetExitWithoutCleanup(true);

    //設置虛擬機的內存利用率參數值爲0.75
    VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
    VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);

    final Arguments args;
    try {
        args = new Arguments(argv); //解析參數
    } catch (IllegalArgumentException ex) {
        Slog.e(TAG, ex.getMessage());
        return;
    }

    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

    //調用startClass的static方法 main() 【見流程12】
    invokeStaticMain(args.startClass, args.startArgs, classLoader);
}

此處args.startClass爲”android.app.ActivityThread”。

12. invokeStaticMain

[–>RuntimeInit.java]

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

    try {
        cl = Class.forName(className, true, classLoader);
    } 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 });
    } 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);
    }

    //通過拋出異常，回到ZygoteInit.main()。這樣做好處是能清空棧幀，提高棧幀利用率。【見流程13】
    throw new ZygoteInit.MethodAndArgsCaller(m, argv);
}

invokeStaticMain()方法中拋出的異常MethodAndArgsCaller，根據前面的【流程4】中可知，下一步進入caller.run()方法。

13. MethodAndArgsCaller

[–>ZygoteInit.java]

public static class MethodAndArgsCaller extends Exception
        implements Runnable {

    public void run() {
        try {
            //根據傳遞過來的參數，可知此處通過反射機制調用的是ActivityThread.main()方法
            mMethod.invoke(null, new Object[] { mArgs }); 
        } 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);
        }
    }
}

到此，總算是進入到了ActivityThread類的main()方法。

總結

當App第一次啓動時或者啓動遠程Service，即AndroidManifest.xml文件中定義了process:remote屬性時，都需要創建進程。比如當用戶點擊桌面的某個App圖標，桌面本身是一個app（即Launcher App），那麼Launcher所在進程便是這次創建新進程的發起進程，該通過binder發送消息給system_server進程，該進程承載着整個java framework的核心服務。system_server進程從Process.start開始，執行創建進程，流程圖（以進程的視角）如下：

點擊查看大圖

上圖中，system_server進程通過socket IPC通道向zygote進程通信，zygote在fork出新進程後由於fork調用一次，返回兩次，即在zygote進程中調用一次，在zygote進程和子進程中各返回一次，從而能進入子進程來執行代碼。該調用流程圖的過程：

system_server進程（即流程1~3）：通過Process.start()方法發起創建新進程請求，會先收集各種新進程uid、gid、nice-name等相關的參數，然後通過socket通道發送給zygote進程；
zygote進程（即流程4~6）：接收到system_server進程發送過來的參數後封裝成Arguments對象，圖中綠色框forkAndSpecialize()方法是進程創建過程中最爲核心的一個環節（詳見流程6），其具體工作是依次執行下面的3個方法：
- preFork()：先停止Zygote的4個Daemon子線程（java堆內存整理線程、對線下引用隊列線程、析構線程以及監控線程）的運行以及初始化gc堆；
- nativeForkAndSpecialize()：調用linux的fork()出新進程，創建Java堆處理的線程池，重置gc性能數據，設置進程的信號處理函數，啓動JDWP線程；
- postForkCommon()：在啓動之前被暫停的4個Daemon子線程。
新進程（即流程7~13）：進入handleChildProc()方法，設置進程名，打開binder驅動，啓動新的binder線程；然後設置art虛擬機參數，再反射調用目標類的main()方法，即Activity.main()方法。

再之後的流程，如果是startActivity則將要進入Activity的onCreate/onStart/onResume等生命週期；如果是startService則將要進入Service的onCreate等生命週期。

理解Android進程創建流程

概述

1. Process.start

2. startViaZygote

3. zygoteSendArgsAndGetResult

4. runSelectLoop

5. runOnce

6. forkAndSpecialize

6-1 preFork

6-2 nativeForkAndSpecialize

6-3 postForkCommon

forkAndSpecialize小結

7. handleChildProc

8. zygoteInit

9. commonInit

10. nativeZygoteInit

11. applicationInit

12. invokeStaticMain

13. MethodAndArgsCaller

總結

您適合從事web前端開發嗎？

Vim - 適合自己的，纔是最好的

淺談雲計算的形態

一位俄羅斯程序員移民美國的故事

以我在LinkedIn做面試官的經驗，來給程序猿面試提些建議

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結