Android系統啟動流程
當系統引導程序啟動Linux內核，內核會記載各種數據結構，和驅動程序，加載完畢之后，Android系統開始啟動并加載第一個用戶級別的進程：init（system/core/init/Init.c）
-
查看Init.c代碼，看main函數
int main(int argc, char **argv) { ... //執行Linux指令 mkdir("/dev", 0755); mkdir("/proc", 0755); mkdir("/sys", 0755); ... //解析執行init.rc配置文件 init_parse_config_file("/init.rc"); ... } -
在init.rc中定義好的指令都會開始執行，其中執行了很多bin指令，啟動系統服務
//啟動孵化器進程，此進程是Android系統啟動關鍵服務的一個母進程 service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server socket zygote stream 666 onrestart write /sys/android_power/request_state wake onrestart write /sys/power/state on onrestart restart media onrestart restart netd -
在app_process文件夾下找到app_main.cpp，查看main函數，發現以下代碼
int main(int argc, const char* const argv[]) { ... //啟動一個系統服務：ZygoteInit runtime.start("com.android.internal.os.ZygoteInit",startSystemServer); ... } -
在ZygoteInit.java中，查看main方法
public static void main(String argv[]) { ... //加載Android系統需要的類 preloadClasses(); ... if (argv[1].equals("true")) { //調用方法啟動一個系統服務 startSystemServer(); } ... } -
startSystemServer()方法的方法體
String args[] = { "--setuid=1000", "--setgid=1000", "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003", "--capabilities=130104352,130104352", "--runtime-init", "--nice-name=system_server", "com.android.server.SystemServer", }; ... //分叉啟動上面字符串數組定義的服務 pid = Zygote.forkSystemServer( parsedArgs.uid, parsedArgs.gid, parsedArgs.gids, debugFlags, null, parsedArgs.permittedCapabilities, parsedArgs.effectiveCapabilities); -
SystemServer服務被啟動
public static void main(String[] args) { ... //加載動態鏈接庫 System.loadLibrary("android_servers"); //執行鏈接庫里的init1方法 init1(args); ... } 動態鏈接庫文件和java類包名相同，找到com_android_server_SystemServer.cpp文件
-
在com_android_server_SystemServer.cpp文件中，找到了
static JNINativeMethod gMethods[] = { /* name, signature, funcPtr */ //給init1方法映射一個指針，調用system_init方法 { "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 }, }; android_server_SystemServer_init1方法體中調用了system_init，system_init沒有方法體
在system_init.cpp文件中找到system_init方法，方法體中
//執行了SystemServer.java的init2方法
runtime->callStatic("com/android/server/SystemServer", "init2");-
回到SystemServer.java，在init2的方法體中
//啟動一個服務線程 Thread thr = new ServerThread(); thr.start(); -
在ServerThread的run方法中
//準備消息輪詢器 Looper.prepare(); ... //啟動大量的系統服務并把其逐一添加至ServiceManager ServiceManager.addService(Context.WINDOW_SERVICE, wm); ... //調用systemReady，準備創建第一個activity ((ActivityManagerService)ActivityManagerNative.getDefault()) .systemReady(new Runnable(){ ... }）； -
在ActivityManagerService.java中，有systemReady方法，方法體里找到
//檢測任務棧中有沒有activity，如果沒有，創建Launcher mMainStack.resumeTopActivityLocked(null); -
在ActivityStack.java中，方法resumeTopActivityLocked
// Find the first activity that is not finishing. ActivityRecord next = topRunningActivityLocked(null); ... if (next == null) { // There are no more activities! Let's just start up the // Launcher... if (mMainStack) { return mService.startHomeActivityLocked(); } } ...
Handler消息機制
-
Message類的obtain方法
消息隊列順序的維護是使用單鏈表的形式來維護的
-
把消息池里的第一條數據取出來，然后把第二條變成第一條
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
sPoolSize--;
return m;
}
-
創建Handler對象時，在構造方法中會獲取Looper和MessageQueue的對象
public Handler() { ... //拿到looper mLooper = Looper.myLooper(); ... //拿到消息隊列 mQueue = mLooper.mQueue; mCallback = null; } -
查看myLooper方法體，發現Looper對象是通過ThreadLocal得到的，在查找ThreadLocal的set方法時發現
-
Looper是直接new出來的，并且在Looper的構造方法中，new出了消息隊列對象
sThreadLocal.set(new Looper()); private Looper() { mQueue = new MessageQueue(); mRun = true; mThread = Thread.currentThread(); } sThreadLocal.set(new Looper())是在Looper.prepare方法中調用的
-
-
prepare方法是在prepareMainLooper()方法中調用的
public static final void prepareMainLooper() { prepare(); ... } -
在應用啟動時，主線程要被啟動，ActivityThread會被創建，在此類的main方法中
public static final void main(String[] args) { ... //創建Looper和MessageQueue Looper.prepareMainLooper(); ... //輪詢器開始輪詢 Looper.loop(); ... } -
Looper.loop()方法中有一個死循環
while (true) { //取出消息隊列的消息，可能會阻塞 Message msg = queue.next(); // might block ... //解析消息，分發消息 msg.target.dispatchMessage(msg); ... } Linux的一個進程間通信機制：管道（pipe）。原理：在內存中有一個特殊的文件，這個文件有兩個句柄（引用），一個是讀取句柄，一個是寫入句柄
主線程Looper從消息隊列讀取消息，當讀完所有消息時，進入睡眠，主線程阻塞。子線程往消息隊列發送消息，并且往管道文件寫數據，主線程即被喚醒，從管道文件讀取數據，主線程被喚醒只是為了讀取消息，當消息讀取完畢，再次睡眠
-
Handler發送消息，sendMessage的所有重載，實際最終都調用了sendMessageAtTime
public boolean sendMessageAtTime(Message msg, long uptimeMillis) { ... //把消息放到消息隊列中 sent = queue.enqueueMessage(msg, uptimeMillis); ... } -
enqueueMessage把消息通過重新排序放入消息隊列
final boolean enqueueMessage(Message msg, long when) { ... final boolean needWake; synchronized (this) { ... //對消息的重新排序，通過判斷消息隊列里是否有消息以及消息的時間對比 msg.when = when; Message p = mMessages; //把放入消息隊列的消息置為消息隊列第一條消息 if (p == null || when == 0 || when < p.when) { msg.next = p; mMessages = msg; needWake = mBlocked; // new head, might need to wake up } else { //判斷時間順序，為剛放進來的消息尋找合適的位置 Message prev = null; while (p != null && p.when <= when) { prev = p; p = p.next; } msg.next = prev.next; prev.next = msg; needWake = false; // still waiting on head, no need to wake up } } //喚醒主線程 if (needWake) { nativeWake(mPtr); } return true; } -
Looper.loop方法中，獲取消息，然后分發消息
//獲取消息隊列的消息 Message msg = queue.next(); // might block ... //分發消息，消息由哪個handler對象創建，則由它分發，并由它的handlerMessage處理 msg.target.dispatchMessage(msg); message對象的target屬性，用于記錄該消息由哪個Handler創建，在obtain方法中賦值
AsyncTask機制
-
AsyncTask必需會用到的三個方法
- onPreExeCute
- doInBackground
- onPostExecute
-
AsyncTask的execute方法，開始執行異步任務，在此方法體中
public final AsyncTask<Params, Progress, Result> execute(Params... params) { ... mStatus = Status.RUNNING; //調用onPreExecute方法 onPreExecute(); //把參數賦值給mWorker對象 mWorker.mParams = params; //線程池對象執行mFuture sExecutor.execute(mFuture); return this; } -
mWorker是什么類型？，在AsyncTask的構造方法中
mWorker = new WorkerRunnable<Params, Result>() { public Result call() throws Exception { Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); return doInBackground(mParams); } }; -
然后把mWorker對象封裝至FutureTask對象
mFuture = new FutureTask<Result>(mWorker) -
在FutureTask的構造中，又把mWorker封裝給Sync對象
public FutureTask(Callable<V> callable) { if (callable == null) throw new NullPointerException(); sync = new Sync(callable); } -
在Sync的構造方法中
Sync(Callable<V> callable) { //這里的callable就是mWorker this.callable = callable; } -
線程池執行mFuture對象，此對象是FutureTask的對象，而FutureTask實現了Runnable接口
public final AsyncTask<Params, Progress, Result> execute(Params... params) { ... //線程池對象執行mFuture sExecutor.execute(mFuture); ...}
-
mFuture的run方法被調用了
public void run() { sync.innerRun(); } -
在innerRun方法中，調用了callable的call方法，但是在sync被new出來的時候，在構造方法中就已經把mWorker賦值給了callable，所以實際上是調用mWorker的call方法
void innerRun() { ... //調用mWorker的call() result = callable.call(); set(result); ... } -
mWorker的call在mWorker被new出來時就已經重寫了
mWorker = new WorkerRunnable<Params, Result>() { public Result call() throws Exception { ... //在子線程中調用了doInBackground方法 return doInBackground(mParams); } }; -
call方法調用完畢后，得到doInBackground所返回的result
void innerRun() { ... result = callable.call(); //返回的result傳入了set方法 set(result); ... } -
set方法體
protected void set(V v) { sync.innerSet(v); } -
innerSet方法體
if (compareAndSetState(s, RAN)) { result = v; releaseShared(0); //關鍵的done方法 done(); return; } -
innerSet方法是屬于FutureTask類的，那么done方法也是調用FutureTask類的，這個done方法定義的地方，在AsyncTask.java的構造方法里
mFuture = new FutureTask<Result>(mWorker) { //此處重寫done方法 @Override protected void done() { //獲取doInbackground方法返回的結果 result = get(); //創建一個消息 message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(AsyncTask.this, result)); //把這條消息發送給創建這個消息的Handler：target.sendMessage(this) message.sendToTarget(); } }; -
然后sHandler的handlerMessage被觸發
public void handleMessage(Message msg) { AsyncTaskResult result = (AsyncTaskResult) msg.obj; switch (msg.what) { case MESSAGE_POST_RESULT: //調用finish方法 result.mTask.finish(result.mData[0]); break; } } -
finish的方法體
private void finish(Result result) { if (isCancelled()) result = null; //調用onPostExecute方法，并傳入結果 onPostExecute(result); mStatus = Status.FINISHED; }
