1. 程式人生 > >【系統之音】Android程序的建立及啟動簡述

【系統之音】Android程序的建立及啟動簡述

       Android系統中的程序(這裡不包括init等底層的程序)都是通過Zygote fork而來的,那這些程序的啟動流程都是怎樣的呢?

       這裡將Android程序分為兩個部分:

    (1)系統框架程序SystemServer程序。它是Zygote建立的第一個程序,是在系統啟動過程中,Zygote程序啟動時直接fork而來的。

    (2)應用程式程序。比如Launcher、SystemUI,其它應用程式等的程序。這些應用程式程序的啟動大致包含兩個步驟:

            1)AMS向Zygote程序傳送建立程序的請求;

            2)Zygote接受請求,建立並啟動應用程式程序。

        本文將圍繞上述幾點,基於Android P(API28)的原始碼,來梳理Android程序的建立與啟動過程。內容的主要物件是應用開發者,所以力求簡潔和完整,內容大體如下:

 

1、Zygote程序啟動簡述

       在理解這一部分前,建議先閱讀【系統之音】Android系統啟動篇。

       系統在啟動時,會啟動一個名為“init”的系統程序,然後該程序會建立並啟動Zygote程序。建立和啟動Zygote程序的過程,先後從Nativie層跨入Java層,在Native層會建立虛擬機器例項(即ART例項),然後通過JNI的方式呼叫ZygoteInit類的main方法。Native層的程式碼咱們不深究,這裡看看main方法:

 1 //(程式碼1.1)=========ZygoteInit.java=====
 2 public static void main(String argv[]) {
 3       ZygoteServer zygoteServer = new ZygoteServer();
 4       ......
 5       String socketName = "zygote";
 6       ......
 7       //建立一個名為“zygote”的Server端Socket,在後續會一直監聽AMS發起的建立新程序的請求。
 8       zygoteServer.registerServerSocketFromEnv(socketName);
 9       ......
10       //①通過fork方式建立SystemServer程序並啟動
11       if (startSystemServer) {
12                 Runnable r = forkSystemServer(abiList, socketName, zygoteServer);//fork建立SystemServer程序
13                 ......
14                 if (r != null) {
15                     r.run();//啟動SystemServer程序
16                     return;
17                 }
18             }
19        //②該方法中使用了一個while(true)的無限迴圈來實現一直監聽AMS的請求
20        caller = zygoteServer.runSelectLoop(abiList);
21        ......
22        //③這裡是會執行子程序(應用程式程序)的ActivityThread的main方法,後文會講到
23        if (caller != null) {
24             caller.run();
25         }
26 }

我抽取了關鍵的程式碼,主要是關注Zygote啟動期間所做的主要工作,這裡先給出結論(有必要牢記於心):

    (1)建立虛擬機器例項;

    (2)建立一個名為“zygote”的Server端Socket,用於後續監聽AMS的請求;

    (3)通過fork的方式建立SystemServer程序並啟動它,該過程會啟動各種系統服務,AMS就是在這個階段啟動的;

    (4)在runSelectLoop方法中通過一個while(true)無限迴圈來實現對AMS的監聽;

    (5)啟動非SystemServer程序。

 

2、Zygote建立與啟動SystemServer

       實際上SystemServer是Zygote創建出的第一個程序,我們從程式碼1.1中的註釋②處的forkSystemServer方法來深入瞭解:

 1 //程式碼2.1==========ZygoteInit.java=======
 2 private static Runnable forkSystemServer(String abiList, String socketName,ZygoteServer zygoteServer) {
 3       ......
 4       int pid;
 5       ......
 6       //fork的過程發生在Native層
 7       pid = Zygote.forkSystemServer(...);
 8       ......
 9       //④pid為0表示子程序(即SystemServer程序)建立成功,邏輯進入到子程序中。下面的邏輯會啟動SystemServer程序
10       if (pid == 0) {
11             ......
12             return handleSystemServerProcess(parsedArgs);
13        }
14 }
15 
16 public static int forkSystemServer(...){
17       ......
18       int pid = nativeForkSystemServer(...);
19       ......
20 }
21 
22 native private static int nativeForkSystemServer(...)

可見,forkSystemServer程序是發生在Native層的,接著繼續從註釋④處看看SystemServer程序的啟動:

 1 //程式碼2.2 =========ZygoteInit.java========
 2 private static Runnable handleSystemServerProcess(...){
 3       ......
 4       return ZygoteInit.zygoteInit(...);
 5 }
 6 
 7 public static final Runnable zygoteInit(...) {
 8        ......
 9        //該處用於建立Binder執行緒池,此後SystemServer程序就可以使用Binder來實現IPC了。該過程也是在Native層實現,Binder在ServiceManager中進行註冊。
10         ZygoteInit.nativeZygoteInit();
11         return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
12     }
13 
14 private static final native void nativeZygoteInit();
15 
16 //==========RuntimeInit.java=======
17 protected static Runnable applicationInit(...){
18       ......
19       //通過上下文可以得知這裡的args.startClass值為“com.android.server.SystemServer”
20       return findStaticMain(args.startClass, args.startArgs, classLoader);
21 }
22 
23 /**
24  * Invokes a static "main(argv[]) method on class "className".
25  * ......
26  */
27 protected static Runnable findStaticMain(String className, String[] argv,
28         ClassLoader classLoader) {
29     Class<?> cl;
30     try {
31         cl = Class.forName(className, true, classLoader);
32     } catch (ClassNotFoundException ex) {
33         throw new RuntimeException(
34                 "Missing class when invoking static main " + className,
35                 ex);
36     }
37     Method m;
38     try {
39         m = cl.getMethod("main", new Class[] { String[].class });
40     } catch (NoSuchMethodException ex) {
41         throw new RuntimeException(
42                 "Missing static main on " + className, ex);
43     } catch (SecurityException ex) {
44         throw new RuntimeException(
45                 "Problem getting static main on " + className, ex);
46     }
47     int modifiers = m.getModifiers();
48     if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
49         throw new RuntimeException(
50                 "Main method is not public and static on " + className);
51     }
52     ...... //毫無疑問,這裡的m就是SystemServer類的main方法了
53     return new MethodAndArgsCaller(m, argv);
54 }
55 
56 static class MethodAndArgsCaller implements Runnable {
57     /** method to call */
58     private final Method mMethod;
59     /** argument array */
60     private final String[] mArgs;
61     public MethodAndArgsCaller(Method method, String[] args) {
62         mMethod = method;
63         mArgs = args;
64     }
65     public void run() {
66         try {
67             mMethod.invoke(null, new Object[] { mArgs });
68         }
69         ......
70     }
71 }

       一步步跟進時,我們會發現該過程中主線都是返回的Runnable型別的物件,回到程式碼1.1的註釋②處的第12行,這裡的 r 就是MethodAndArgsCaller物件,第13行r.run()執行,就是呼叫的上述程式碼第67行,跟蹤上下文可知這裡就是執行的SystemServer.main方法。緊接著第14行是return,Zygote就完成了建立和啟動SystemServer程序。此時你是否會有疑問:這裡就return了,那後面監聽AMS請求和啟動非SystemServer程序的邏輯又如何實現呢?這裡我們需要理解“fork”,後面我們會詳細介紹。

        這裡進一步看看SystemServer程序中都做了些什麼:

 1 //=========SystemServer.java===========
 2 public static void main(String[] args) {
 3     new SystemServer().run();
 4 }
 5 private void run() {
 6     ......
 7     //建立訊息Looper
 8     Looper.prepareMainLooper();
 9     // 載入動態庫libandroid_servers.so,初始化native服務
10     System.loadLibrary("android_servers");
11     ......
12     //初始化系統context
13     createSystemContext();
14     //建立SystemServiceManager
15     mSystemServiceManager = new SystemServiceManager(mSystemContext);
16     ......
17     //啟動引導服務,如AMS等
18     startBootstrapServices();
19     //啟動核心服務
20     startCoreServices();
21     //啟動其它服務,如WMS,SystemUI等
22     startOtherServices();
23     ....
24     // Loop forever.
25     Looper.loop();
26 }

到這裡Zygote就建立並啟動了SystemServe程序,總結一下這個過程中主要做了些什麼工作:

    (1)通過fork得到一個虛擬機器例項副本;

    (2)建立Binder執行緒池,SystemServer可以通過Binder來實現IPC(跨程序通訊);

    (3)啟動系統服務,比如AMS,WMS等;

    (4)建立訊息迴圈,Looper.loop()中是一個無限迴圈,SystemServer將持續執行。

 

3、fork簡介

       在前文中提到了使用fork的方式來建立程序,也提到了一個疑問:

       “此時你是否會有疑問:這裡就return了,那後面監聽AMS請求和啟動非SystemServer程序的邏輯又如何實現呢?”

       這裡先看看百度百科的介紹:

    “復刻(英語:fork,又譯作派生、分支)是UNIX或類UNIX中的分叉函式,fork函式將執行著的程式分成2個(幾乎)完全一樣的程序,
每個程序都啟動一個從程式碼的同一位置開始執行的執行緒。這兩個程序中的執行緒繼續執行,就像是兩個使用者同時啟動了該應用程式的兩個副本。 fork系統呼叫用於建立一個新程序,稱為子程序,它與程序(稱為系統呼叫fork的程序)同時執行,此程序稱為父程序。建立新的子程序後,
兩個程序將執行fork()系統呼叫之後的下一條指令。子程序使用相同的pc(程式計數器),相同的CPU暫存器,在父程序中使用的相同開啟檔案。”

       所以,在程式碼1.1中forkSystemServer時,Zygote程序會分化為兩個一模一樣的程序來,其中一個是父程序,另外一個是子程序,它是主程序的副本。當SystemServer fork成功後其流程就進入到了子程序中,即程式碼1.1中的第15、16行是在子程序中執行的。而與此同時,父程序還會繼續往下執行,不斷監聽AMS的請求以及啟動新的程序。

       要更好地理解fork後Zygote程序和子程序的工作,可以參考閱讀:https://www.cnblogs.com/jiangzhaowei/p/11023098.html。

 

4、Zygote監聽AMS的請求

        在程式碼1.1中註釋②處,會通過呼叫runSelectLoop方法來監聽AMS的請求,我們看看該方法的實現:

 1 //程式碼4.1======ZygoteServer.java======
 2 Runnable runSelectLoop(String abiList) {
 3       ......
 4       ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
 5       ......
 6       while (true) {
 7            ......
 8            //⑤當監聽到AMS請求的資料時會執行這裡
 9            ZygoteConnection connection = peers.get(i);
10            final Runnable command = connection.processOneCommand(this);
11            ......
12            return command;
13       }
14 }

這其中包含了一個while(true)的無限迴圈,以此來一直監聽AMS的請求,直到註釋⑤處監聽到了AMS的請求,fork出新的子程序(應用程式程序),隨後在子程序中return,結束監聽。和fork SystemServer一樣,父程序Zygote仍然繼續監聽著,繼續相應AMS新的請求,fork出新的子程序。

 

5、AMS向Zygote程序發起建立程序的請求

       要啟動一個程式時,系統首先會判斷該程式所在的程序是否存在,如果不存在就需要先建立並啟動目標程式對應的程序。這一點在四大元件元件啟動流程的原始碼中都有體現,當發現目標程序還不存在時,AMS都會向Zygote程序申請建立目標程序。這個過程分為兩步:(1)AMS向Zygote程序發起建立程序的請求;(2)Zygote收到請求,建立並啟動程序。這一節我們先看看第(1)步:

 1 //==============ActivityManagerService.java============
 2 private final boolean startProcessLocked(ProcessRecord app, String hostingType,
 3             String hostingNameStr, boolean disableHiddenApiChecks, String abiOverride) {
 4        ......
 5        final String entryPoint = "android.app.ActivityThread";
 6        return startProcessLocked(hostingType, hostingNameStr, entryPoint...);
 7 }
 8 private boolean startProcessLocked(...String entryPoint...) {
 9        ......
10        final ProcessStartResult startResult = startProcess(...entryPoint...);
11  }
12  private ProcessStartResult startProcess(...String entryPoint...){
13        ......
14        final ProcessStartResult startResult;
15        ......
16        startResult = Process.start(entryPoint,
17                          app.processName, uid, uid, gids, runtimeFlags, mountExternal,
18                          app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
19                          app.info.dataDir, invokeWith,
20                          new String[] {PROC_START_SEQ_IDENT + app.startSeq});
21        ......
22  }
23  //================Process.java==============
24  public static final ZygoteProcess zygoteProcess = new ZygoteProcess(ZYGOTE_SOCKET, SECONDARY_ZYGOTE_SOCKET);
25  public static final ProcessStartResult start(final String processClass,...) {
26           return zygoteProcess.start(processClass, ...);
27  }
28  //==============ZygoteProcess.java==========
29   public final Process.ProcessStartResult start(final String processClass...) {
30          try {
31              return startViaZygote(processClass...);
32          }......
33     }
34  private Process.ProcessStartResult startViaZygote(final String processClass...){       
35        argsForZygote.add(processClass);
36        ......
37        return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
38  }
39  private ZygoteState primaryZygoteState;
40  ......
41  private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
42        ......
43        //追蹤程式碼,容易得知mSocket值為"zygote",這裡的作用是連線名為“zygote”的Socket
44        primaryZygoteState = ZygoteState.connect(mSocket);
45        ......
46  }

        從上述程式碼可以看出,該過程的邏輯其實挺簡單,通過層層呼叫後走到第50行。這一行的作用就是和名為“zygote”的Socket服務端建立連線,這樣就向Zygote程序發起了請求。這裡的ZygoteState類中的

 

6、Zygote收到AMS的請求,建立並啟動程序

       在程式碼4.1中,我們講過,其中while(true)迴圈一直監聽AMS的請求,直到收到請求。

 1 //===========ZygoteConnection.java=======
 2 Runnable processOneCommand(ZygoteServer zygoteServer) {
 3       ......
 4       //⑥fork方式建立應用程式程序
 5       pid = Zygote.forkAndSpecialize(...);
 6       ......
 7       //pid為0表示當前的程式碼邏輯執行在新建立的子程序(即應用程式程序)中
 8       if (pid == 0) {
 9                 // in child
10                  ......
11                  //處理應用程式程序
12                  return handleChildProc(parsedArgs, descriptors, childPipeFd,
13                          parsedArgs.startChildZygote);
14              } else {
15                  ......
16              }
17  }
18 
19  private Runnable handleChildProc(...){
20         ......
21         return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs,null /* classLoader */);
22  }
23  //=====ZygoteInit.java========
24  public static final Runnable zygoteInit(...) {
25        ......
26        //建立Binder執行緒池,此後新的子程序就能夠使用Binder進行IPC了
27        ZygoteInit.nativeZygoteInit();
28        return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
29  }
30 
31 //============Zygote.java==========(補充註釋⑥處)
32 public static int forkAndSpecialize(...) {
33     ........
34     int pid = nativeForkAndSpecialize(...);
35     ......
36     return pid;
37 }
38 native private static int nativeForkAndSpecialize(...);

流程走到第26行就比較清晰了,和程式碼2.2中啟動SystemServer程序一致了,只不過這裡啟動的是ActivityThread的main方法。

 1 //=======ActivityThread.java=====
 2 static volatile Handler sMainThreadHandler;
 3 
 4 public static void main(String[] args) {
 5       ......
 6       Looper.prepareMainLooper();
 7       ......
 8       ActivityThread thread = new ActivityThread();
 9       ......
10       if (sMainThreadHandler == null) {
11             sMainThreadHandler = thread.getHandler();
12        }
13       ......
14        Looper.loop();
15 }
16 
17 final Handler getHandler() {
18         return mH;
19     }
20 
21 final H mH = new H();
22 
23 class H extends Handler {
24       ......
25 }

       ActivityThread類是主執行緒的管理類,其main方法中會建立訊息迴圈,其中Looper.loop()方法中通過無限迴圈的方式,保持主執行緒一直執行。同時還會建立主執行緒的H類,這是一個包含主執行緒looper的Handler,四大元件啟動過程中都需要通過這個H類物件來從Binder執行緒中切換到主執行緒中。

       這裡總結一下普通應用程式程序建立時的關鍵工作:

    (1)通過fork得到一個虛擬機器例項副本;

    (2)建立Binder執行緒池,應用程式程序就可以通過Binder來實現IPC;

    (3)建立訊息迴圈,建立主執行緒的H類。

 

7、疑問

    (1)為什麼AMS(SystemServer程序)與Zygote程序通訊採用Socket而不是Binder?

       答:因為fork不允許存在多執行緒,而Binder通訊偏偏就是多執行緒。(不知道該答案是否準確,目前還沒找到權威答案)。

       可以參考:https://blog.csdn.net/qq_39037047/article/details/88066589

 

 參考及推薦閱讀:

       https://www.cnblogs.com/andy-songwei/p/11429421.html

       https://www.cnblogs.com/jiangzhaowei/p/11023098.html

       https://www.jianshu.com/p/ab9b83a77af6

       https://blog.csdn.net/qq_39037047/article/details/88066589

       劉望舒《Android進階解