Android系統源碼分析--Process啓動過程
因爲四大組件的啓動都涉及到進程的啓動，所以咱們這章先講一下進程啓動流程，而後再講四大組件的啓動流程。java
基礎知識
Android應用程序框架層建立的應用程序進程具備兩個特色，一是進程的入口函數是ActivityThread.main，二是進程自然支持Binder進程間通訊機制；這兩個特色都是在進程的初始化過程當中實現的。（引用自老羅安卓之旅-Android應用程序進程啓動過程的源代碼分析）android
進程按照重要性能夠分爲下面五類：微信
- 前臺進程(Foreground process)
- 可見進程(Visible process)
- 服務進程(Service process)
- 後臺進程(Background process)
- 空進程(Empty process)
進程啓動流程
AMS(ActivityMagagerService)啓動進程是從其成員函數startProcessLocked開始調用Process.start方法開始的。咱們先看一下進程啓動的時序圖：app
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 {
// 請求Zygote進程建立一個應用進程
return startViaZygote(processClass, niceName, uid, gid, gids,
debugFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, zygoteArgs);
} catch (ZygoteStartFailedEx ex) {
Log.e(LOG_TAG,
"Starting VM process through Zygote failed");
throw new RuntimeException(
"Starting VM process through Zygote failed", ex);
}
}複製代碼
注意：傳入的第一個參數是「android.app.ActivityThread」，這是進程初始化要加載的類，這個類加載到進程以後，就會把這個類的靜態成員方法main做爲進程的入口。而後調用startViaZygote方法。框架
2. 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<String> argsForZygote = new ArrayList<String>();
// 保存要建立應用程序進程的啓動參數到argsForZygote中
...
// 保存id到argsForZygote中
...
// 保存其餘信息到argsForZygote中
...
// 請求Zygote進程建立這個應用進程
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
}
}複製代碼
這個方法主要是保存信息到argsForZygote中，而後調用openZygoteSocketIfNeeded，而後根據返回的值調用zygoteSendArgsAndGetResult方法，首先先看openZygoteSocketIfNeeded方法。socket
3. openZygoteSocketIfNeeded方法：
private static ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
try {
// 經過調用ZygoteState.connect方法建立LocalSocket對象，以便將相應參數傳入Zygote進程
primaryZygoteState = ZygoteState.connect(ZYGOTE_SOCKET);
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
}
}
if (primaryZygoteState.matches(abi)) {
return primaryZygoteState;
}
// The primary zygote didn't match. Try the secondary.
if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
try {
// 經過調用ZygoteState.connect方法建立LocalSocket對象，以便將相應參數傳入Zygote進程
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);
}複製代碼
經過ZygoteState.connect放建立primaryZygoteState對象，若是第一次建立不成功，建立第二次。connect方法代碼以下：ide
4. ZygoteState.connect方法：
public static ZygoteState connect(String socketAddress) throws IOException {
DataInputStream zygoteInputStream = null;
BufferedWriter zygoteWriter = null;
// 這個Socket由ZygoteInit.java文件中的ZygoteInit類在runSelectLoopMode函數偵聽的。
final LocalSocket zygoteSocket = new LocalSocket();
try {
// 開始創建鏈接，在鏈接過程當中，LocalSocket對象zygoteSocket會在/dev/socket目錄下找到
// 一個對應的zygote文件，而後將它與本身綁定起來，這就至關於與Zygote進程中的名稱爲「zygote」
// 的Socket創建了鏈接
zygoteSocket.connect(new LocalSocketAddress(socketAddress,
LocalSocketAddress.Namespace.RESERVED));
// 鏈接成功之後，首先獲取LocalSocket對象zygoteSocket的一個輸入流，而且保存在
// zygoteInputStream中，以便得到Zygote進程發送過來的通訊數據
zygoteInputStream = new DataInputStream(zygoteSocket.getInputStream());
// 又獲得LocalSocket對象zygoteSocket的一個輸入流，而且保存在zygoteWriter中，以便
// 能夠向Zygote進程發送通訊數據
zygoteWriter = new BufferedWriter(new OutputStreamWriter(
zygoteSocket.getOutputStream()), 256);
} catch (IOException ex) {
...
}
String abiListString = getAbiList(zygoteWriter, zygoteInputStream);
Log.i("Zygote", "Process: zygote socket opened, supported ABIS: " + abiListString);
// 建立的LocalSocket對象zygoteSocket會保存在ZygoteState中
return new ZygoteState(zygoteSocket, zygoteInputStream, zygoteWriter,
Arrays.asList(abiListString.split(",")));
}複製代碼
首先建立一個LocalSocket對象，這個LocalSocket對象是在ZygoteInit中的runSelectLoop函數進行監聽的。而後經過connect方法而且傳入鏈接地址鏈接該Socket，鏈接之後會獲取輸入流DataInputStream，以便得到Zygote進程發送過來的通訊數據，而後又獲取BufferedWriter輸入流，以便向Zygote進程發送通訊數據。最後會返回一個ZygoteState對象。下面咱們看一下LocalSocket.connect方法。函數
5. LocalSocket.connect方法：
public void connect(LocalSocketAddress endpoint) throws IOException {
synchronized (this) {
if (isConnected) {
throw new IOException("already connected");
}
implCreateIfNeeded();
impl.connect(endpoint, 0);
isConnected = true;
isBound = true;
}
}複製代碼
若是已經鏈接，拋出異常，由於鏈接完成後，會關閉鏈接，使用時在打開鏈接。最後調用native方法鏈接socket，而且改變鏈接標籤。oop
6. 回到第二步，調用完openZygoteSocketIfNeeded返回參數ZygoteState傳入到zygoteSendArgsAndGetResult方法中：
private static ProcessStartResult zygoteSendArgsAndGetResult( ZygoteState zygoteState, ArrayList<String> args) throws ZygoteStartFailedEx {
try {
// Throw early if any of the arguments are malformed. This means we can
// avoid writing a partial response to the zygote.
int sz = args.size();
for (int i = 0; i < sz; i++) {
if (args.get(i).indexOf('\n') >= 0) {
throw new ZygoteStartFailedEx("embedded newlines not allowed");
}
}
final BufferedWriter writer = zygoteState.writer;
final DataInputStream inputStream = zygoteState.inputStream;
writer.write(Integer.toString(args.size()));
writer.newLine();
for (int i = 0; i < sz; i++) {
String arg = args.get(i);
writer.write(arg);
writer.newLine();
}
writer.flush();
// Zygote進程接收到這些數據以後，就會建立一個新的應用程序進程，而且將這個新建立的應用程序進程
// 的PID返回給Activity管理服務AMS
// Should there be a timeout on this?
ProcessStartResult result = new ProcessStartResult();
// Always read the entire result from the input stream to avoid leaving
// bytes in the stream for future process starts to accidentally stumble
// upon.
result.pid = inputStream.readInt();
result.usingWrapper = inputStream.readBoolean();
if (result.pid < 0) {
throw new ZygoteStartFailedEx("fork() failed");
}
return result;
} catch (IOException ex) {
zygoteState.close();
throw new ZygoteStartFailedEx(ex);
}
}複製代碼
這方法經過Socket流的方式將啓動進程的信息發送出去，從步驟4可知，這個Socket的監聽是ZygoteInit類中的runSelectLoop方法，咱們接着看這個方法。佈局
7. ZygoteInit.runSelectLoop方法：
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
while (true) {
StructPollfd[] pollFds = new StructPollfd[fds.size()];
for (int i = 0; i < pollFds.length; ++i) {
pollFds[i] = new StructPollfd();
pollFds[i].fd = fds.get(i);
pollFds[i].events = (short) POLLIN;
}
try {
Os.poll(pollFds, -1);
} catch (ErrnoException ex) {
throw new RuntimeException("poll failed", ex);
}
for (int i = pollFds.length - 1; i >= 0; --i) {
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
if (i == 0) {
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
boolean done = peers.get(i).runOnce();
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}複製代碼
數據經過Socket發送之後，Zygote進程接收到後會調用peers.get(i).runOnce()方法。這個peers.get(i)是獲取ZygoteConnection對象，表示一個Socket鏈接，而後調用它的runOnce方法。
8. ZygoteConnection.runOnce方法：
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
// 得到建立應用程序進程須要的啓動參數，而且保存在一個Arguments對象parsedArgs中
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
Log.w(TAG, "IOException on command socket " + ex.getMessage());
closeSocket();
return true;
}
...
/** the stderr of the most recent request, if avail */
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 {
parsedArgs = new Arguments(args);
if (parsedArgs.abiListQuery) {
return handleAbiListQuery();
}
...
// 調用forkAndSpecialize方法來建立這個應用程序進程，最終經過函數fork在當前進程中建立一個子進程，
// 所以，當它的返回值等於0時，就表示是在新建立的子進程中執行的，這時候ZygoteConnection類就會調用
// 成員函數handleChildProc來啓動這個子進程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
parsedArgs.appDataDir);
} catch (ErrnoException ex) {
...
} catch (IllegalArgumentException ex) {
...
} catch (ZygoteSecurityException ex) {
...
}
try {
if (pid == 0) {
...
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
return true;
} else {
...
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
...
}
}複製代碼
首先經過Zygote.forkAndSpecialize方法來建立一個新的進程，而且返回其pid。由於咱們在分心新建進程，所以咱們只分析pid爲0的狀況，pid爲0時會調用handleChildProc方法，
9. handleChildProc方法：
private void handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr) throws ZygoteInit.MethodAndArgsCaller {
...
// End of the postFork event.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
if (parsedArgs.invokeWith != null) {
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
VMRuntime.getCurrentInstructionSet(),
pipeFd, parsedArgs.remainingArgs);
} else {
// 初始化運行庫以及啓動一個Binder線程池
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs, null /* classLoader */);
}
}複製代碼
因爲咱們以前加入參數是沒有parsedArgs.invokeWith這個參數，所以這裏是null，所以會走else裏面的代碼，執行RuntimeInit.zygoteInit方法。
10. 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();
// 而後調用下面Native函數在新建立的應用程序進程中啓動一個Binder線程池
nativeZygoteInit();
applicationInit(targetSdkVersion, argv, classLoader);
}複製代碼
首先調用nativeZygoteInit函數，這是一個native函數，函數的目的是在新建立的應用程序進程中啓動一個Binder線程池而後進行進程間通訊。而後調用applicationInit函數
11. applicationInit函數：
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) throws ZygoteInit.MethodAndArgsCaller {
...
// Remaining arguments are passed to the start class's static main
// 咱們知道AMS指定了新建立的應用程序進程的入口函數爲ActivityThread類的靜態成員函數main。實際是
// 經過下面方法進入到ActivityThread類的靜態成員函數main中的
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}複製代碼
咱們在前面講過args.startClass傳入進來的是"android.app.ActivityThread"，表示要執行"android.app.ActivityThread"的main函數。
12. invokeStaticMain函數：
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) {
...
}
Method m;
try {
// 獲取它的靜態成員函數main，而且保存在Method對象m中
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
...
} catch (SecurityException ex) {
...
}
...
/* * This throw gets caught in ZygoteInit.main(), which responds * by invoking the exception's run() method. This arrangement * clears up all the stack frames that were required in setting * up the process. * 將這個Method對象封裝在一個MethodAndArgsCaller對象中，而且將這個MethodAndArgsCaller對象做爲 * 一個異常對象拋出來給當前應用程序處理 */
throw new ZygoteInit.MethodAndArgsCaller(m, argv);
/** * 引用自Android系統源代碼情景分析中的Android進程啓動分析一文 * 新建立的應用程序進程複製了Zygote進程的地址空間，所以，當前新建立的應用程序進程的調用棧與Zygote * 進程的調用堆棧是一致的。Zygote進程最開始執行的是應用程序app_process的入口函數main，接着再調用 * ZygoteInit類的靜態成員函數main，最後進入到ZygoteInit類的靜態成員函數runSelectLoopMode來循環 * 等待Activity管理服務AMS發送過來的建立新的應用進程的請求。當Zygote進程收到AMS發送過來的建立新的 * 應用程序進程的請求以後，它就會建立一個新的應用程序進程，而且讓這個新建立的應用程序進程沿着 * ZygoteInit類的靜態函數runSelectLoopModel一直執行到RuntimeInit類的靜態成員函數 * invokeStaticMain。所以，當RuntimeInit類的靜態成員函數invokeStaticMain拋出一個類型爲 * MethodAndArgsCaller的常時，系統就會沿着這個調用過程日後找到一個適合的代碼塊來捕獲它。 * 因爲ZygoteInit函數main捕獲了類型爲MethodAndArgsCaller的異常，所以，接下來它就會被調用，以便 * 能夠處理這裏拋出的一個MethodAndArgsCaller異常。所以，拋出這個異常後，會執行ZygoteInit中main * 函數中的catch來捕獲異常。 * */
}複製代碼
這個就是經過類加載器加載ActivityThread，而後調用起main方法。而後拋出異常，經過ZygoteInit中main函數中的catch來捕獲異常。
13. ZygoteInit.main函數：
public static void main(String argv[]) {
...
} catch (MethodAndArgsCaller caller) {
// 捕獲MethodAndArgsCaller異常之後會調用MethodAndArgsCaller的run函數
// ActivityThread.main
caller.run();
} catch (Throwable ex) {
...
}
}複製代碼
經過步驟12可知拋出的異常是MethodAndArgsCaller異常，所以會執行caller.run方法。
14. MethodAndArgsCaller.run:
/** * 註釋來自Android系統源代碼情景分析 * 這裏開始調用ActivityThread.main方法，爲何要繞這麼遠呢，前面提到，AMS請求Zygote進程建立的應用 * 程序進程的入口函數爲ActivityThread的main函數，可是因爲新建立的應用程序進程一開始就須要再內部初始 * 化運行時庫，以及啓動Binder線程池，所以，ActivityThread的main函數被調用時，新建立的應用程序進程 * 實際上已經執行了至關多的代碼，爲了使得西建立的應用程序的進程以爲它的入口函數就是ActivityThread類 * 的main函數，系統就不能直接調用，而是拋出異常回到ZygoteInit的main函數中，而後間接調用它，這樣就 * 能夠巧妙的利用Java語言的異常處理來清理它前面調用的堆棧了 */
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);
}
}複製代碼
經過mMethod.invoke方法調用ActivityThread的main方法。
15. ActivityThread.mian方法：
/** * 啓動新的進程時調用Process的start方法會最終調用改函數 * 啓動新的進程主要作了兩件事： * 1.在進程中建立了一個ActivityThread對象，並調用了它的成員函數attach向AMS發送一個啓動完成的通知 * 2.調用Looper類的靜態成員函數prepareMainLooper建立一個消息循環，而且在向AMS發送啓動完成通知後， * 使得當前進程進入到這個消息循環中 * * @param args */
public static void main(String[] args) {
...
// 建立looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
// 傳入false表示非系統進程啓動
thread.attach(false);
if (sMainThreadHandler == null) {
// 獲取主線程的Handler
sMainThreadHandler = thread.getHandler();
}
...
// 開始無限循環
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}複製代碼
這裏主要是建立該線程的looper，而後建立ActivityThread對象，而後進入消息循環。而後咱們就能夠啓動Activity或者Service了。
注
Android開發羣：192508518
微信公衆帳號：Code-MX
注：本文原創，轉載請註明出處，多謝。
相關文章
- 1. 系統源碼-1：Android 系統啓動流程源碼分析
- 2. Android源碼分析--Android系統啓動
- 3. Android系統進程Zygote啓動過程的源代碼分析
- 4. Android 8.0系統源碼分析--openCamera啓動過程源碼分析
- 5. Android 8.0系統源碼分析--openCamera（HAL）啓動過程源碼分析
- 6. Android 8.0系統源碼分析--startService啓動過程源碼分析
- 7. Android系統啓動源碼分析
- 8. Android系統源碼分析--Activity啓動過程
- 9. Android系統源碼分析--Zygote和SystemServer啓動過程
- 10. Android系統啓動過程分析
- 更多相關文章...
- • Swift 析構過程 - Swift 教程
- • 互聯網系統應用架構基礎分析 - 紅包項目實戰
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • Git五分鐘教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 字節跳動21屆秋招運營兩輪面試經驗分享
- 2. Java 3 年，25K 多嗎？
- 3. mysql安裝部署
- 4. web前端開發中父鏈和子鏈方式實現通信
- 5. 3.1.6 spark體系之分佈式計算-scala編程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在線
- 8. 在線畫圖
- 9. devtools熱部署
- 10. 編譯和鏈接
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 系統源碼-1：Android 系統啓動流程源碼分析
- 2. Android源碼分析--Android系統啓動
- 3. Android系統進程Zygote啓動過程的源代碼分析
- 4. Android 8.0系統源碼分析--openCamera啓動過程源碼分析
- 5. Android 8.0系統源碼分析--openCamera（HAL）啓動過程源碼分析
- 6. Android 8.0系統源碼分析--startService啓動過程源碼分析
- 7. Android系統啓動源碼分析
- 8. Android系統源碼分析--Activity啓動過程
- 9. Android系統源碼分析--Zygote和SystemServer啓動過程
- 10. Android系統啓動過程分析