android开发之源码级分析（系统启动流程 & Handler消息机制 & AsyncTask机制）

Android系统启动流程

Android启动过程：系统引导Linux内核启动，内核启动时会加载Linux的各种设备驱动和数据结构，驱动加载完毕，Android系统才开始启动，启动过程中，系统加载第一个用户级别的进程：init，而launcher(桌面进程)是Android系统启动完毕之后，加载的第一个上层应用的进程。

Bootloader：引导程序 – DOS的启动盘
Linux Kernel：内核启动
Android：系统启动

init.c – 源码在system\core\init目录下

查看init.c代码，看main函数

init 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 – 源码在system\core\rootdir – 包含非常多的可执行指令

播放开机动画：

service bootanim /system/bin/bootanimation    user graphics    group graphics    disabled    oneshot

启动孵化器进程：

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文件夹下的：源码在frameworks\base\cmds\app_process

app_main.cpp：启动了ZygoteInit服务！

int main(int argc, const char* const argv[]) {    ...    if (i < argc) {        arg = argv[i++];        if (0 == strcmp("--zygote", arg)) {            bool startSystemServer = (i < argc) ? strcmp(argv[i], "--start-system-server") == 0 : false;            setArgv0(argv0, "zygote");            set_process_name("zygote");            runtime.start("com.android.internal.os.ZygoteInit", startSystemServer);    ...}

在ZygoteInit.java中

main()中：

public static void main(String argv[]) {    try {        ...        **preloadClasses();**        ...    } catch (RuntimeException ex) {    }}

preloadClasses()：进行预加载类

private static void preloadClasses() {        ...        //解析PRELOADED_CLASSES文件，把该文件中定义好的1835个类全部预加载进来！        InputStream is = ZygoteInit.class.getClassLoader().getResourceAsStream(PRELOADED_CLASSES);        //PRELOADED_CLASSES包含很多的java类！包括ActivityThread.java...        ...}

回到ZygoteInit.java中的main()中：

public static void main(String argv[]) {    try {        ...        if (argv[1].equals("true")) {             **startSystemServer();** //启动系统服务！        } else if (!argv[1].equals("false")) {             throw new RuntimeException(argv[0] + USAGE_STRING);        }        ...    } catch (RuntimeException ex) {    }}

startSystemServer() – 启动系统服务

 /** * Prepare the arguments and fork for the system server process. */  private static boolean startSystemServer()          throws MethodAndArgsCaller, RuntimeException {      /* Hardcoded command line to start the system server */      String args[] = {          "--setuid=1000",          "--setgid=1000",          "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,3001,3002,3003",          "--capabilities=130104352,130104352",          "--runtime-init",          "--nice-name=system_server",          **"com.android.server.SystemServer"**,      };      ZygoteConnection.Arguments parsedArgs = null;      int pid;      try {          parsedArgs = new ZygoteConnection.Arguments(args);          /* * Enable debugging of the system process if *either* the command line flags * indicate it should be debuggable or the ro.debuggable system property * is set to "1" */          int debugFlags = parsedArgs.debugFlags;          if ("1".equals(SystemProperties.get("ro.debuggable")))              debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER;          /* Request to fork the system server process */          **pid = Zygote.forkSystemServer(                  parsedArgs.uid, parsedArgs.gid,                  parsedArgs.gids, debugFlags, null,                  parsedArgs.permittedCapabilities,                  parsedArgs.effectiveCapabilities);**      } catch (IllegalArgumentException ex) {          throw new RuntimeException(ex);      }    ...  }

SystemServer.java中的mian()方法中

public static void main(String[] args) {    ...    //加载动态链接库    **System.loadLibrary("android_servers");**    **init1(args);**    ...}

加载完成之后，在main()方法中又调用了init1(args);方法，显然发现init1()是一个本地方法，那么init1()方法有可能在动态链接库中；因此就找到了com_android_server_SystemServer.cpp：

com_android_server_SystemServer.cpp：源码存放在frameworks\base\services\jni目录下

namespace android {.../* * JNI registration. */static JNINativeMethod gMethods[] = {    /* name, signature, funcPtr */    { **"init1"**, "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 },};...};

函数也是可以用指针的！因此我们可以知道init1的函数指针就是(void*) android_server_SystemServer_init1 ；这样的话也说明了init1由函数指针代替，因此init1执行的时候就会去执行android-server_SystemServer_init1()方法！那么在com_android_server_SystemServer.cpp中就不难发现有这样一个方法了！

namespace android {...static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz){    system_init();}...};

那么在android_server_SystemServer_init1()方法中会去调用system_init()方法：

namespace android {extern "C" int system_init();...};

该方法是一个抽象的方法，因此需要子类去覆写该方法！那么再去搜那里覆写了该方法；最后发现System_init.cpp类中覆写了这个方法：

System_init.cpp：

extern "C" status_t system_init(){   ......    //运行静态方法，要运行SystemServer类中的**init2()**方法    runtime->callStatic("com/android/server/SystemServer", "init2");   ......}

来到SystemServer类中的init2()方法：

public static final void init2() {    Slog.i(TAG, "Entered the Android system server!");    Thread thr = new ServerThread();    thr.setName("android.server.ServerThread");    thr.start();}

该方法创建了服务线程，并开启了线程，那么这样的话，就去看看线程到底干了些什么！去看看线程中的run()方法，在run()方法中，给ServiceManager添加了好多SystemService。这也是我们之所以能在java程序中使用getSystemService()方法能得到自己想要的Service，因为都在这里添加完成了。你尽管拿！ServerThread类就在本类当中，而run()因此也就在本类当中！

class ServerThread extends Thread {    ...    @Override    public void run() {        ...        ((ActivityManagerService)ActivityManagerNative.getDefault()).**systemReady**(new Runnable() {            public void run() {                ...            }        });        ...    }    ...}

在run()方法中，有一个重点：ActivityManagerService类中的systemReady()方法！

public void systemReady(final Runnable goingCallback) {    ...    //mMainStack：ActivityTask任务栈    **mMainStack.resumeTopActivityLocked(null);**}

ActivityTask.java中resumeTopActivityLocked方法中：

final boolean resumeTopActivityLocked(ActivityRecord prev) {    ...    // Launcher...    if (mMainStack) {        return mService.startHomeActivityLocked();    }    ...}

Handler消息机制

主线程有一个消息队列（MessageQueue），用来存储子线程中的handler.sendMessage()发送过来的消息，之后如果MessageQueue一旦有消息，那么就会去唤醒Looper.loop()轮询器，轮询器就会不断的检查MessageQueue有没有消息，如果有消息，那么就交给用户自己定义的Handler对象，去调用handler对象中的handleMessage()方法来处理消息。

消息的创建：使用handler.obtionMessage(),但最终会调用Message类中的obtion()方法，来创建Message对象。

public final Message obtainMessage(){    return Message.obtain(this);}

public static Message obtain() {    synchronized (sPoolSync) {        if (sPool != null) {            Message m = sPool;            sPool = m.next;            m.next = null;            sPoolSize--;            return m;        }    }    return new Message();}

前提：
①、首先来看MessageQueue中的消息，按照队列的思想，先进先出去处理每一个消息
②、消息对象有一个成员属性：Message next。next本身也是一个消息。

a消息有一个成员属性next，而next也是一个消息，那么就是a指向b，b指向c–单链表的形式来维护消息的，而不是消息队列来维护的！因此消息是由消息自己来维护的，而不是靠消息队列来维护。

分析Message.obtain()方法中的代码：

if(sPool != null) {    Message m = sPool;    sPool = m.next;    m.next = null;    sPoolSize--;    return m;}

①. Message m = sPool;

②. sPool = m.next;

③. m.next = null;

④. sPoolSize–；消息池中的消息被拿走了一条，所以总数减一。

⑤. return m；把a消息拿出去，a就离开了消息池，而sPool依然指向第一条消息。

handler创建：任何一个应用程序启动的时候，ActivityThread都会被创建。

ActivityThread中的main()方法中：

public static final void main(String[] args) {        ...        Looper.prepareMainLooper(); //创建轮询器        ...        ActivityThread thread = new ActivityThread();        ...        Looper.loop(); //开启轮询器，开始轮询，不断的检查消息队列是否有消息        ...    }}

在Looper.prepareMainLooper()中：

public static final void prepareMainLooper() {    prepare();    ...}

在prepare()中：

public static final void prepare() { if (sThreadLocal.get() != null) { throw new RuntimeException("Only one Looper may be created per thread"); }    sThreadLocal.set(**new Looper()**); //创建轮询器，同时将会创建MessageQueue(消息队列)}

在Looper.loop()中：

public static final void loop() {     ...     while (true) { //主线程       Message msg = queue.next(); // might block -- 如果消息队列没有消息，就会阻塞休眠       ...    }}

为什么阻塞休眠？

因为内存中的一块空间存放了特殊文件

消息队列中有消息不会唤醒主线程的，唤醒主线程的是管道，就是当你往消息队列中发送消息的时候，会往管道中写数据，这样才会唤醒主线程。

消息发送： Message对象中有一个long类型记录自己的发送时间。

使用handler.sendMessage()；通过handler对象调用各种方法来发送消息，不管你调用哪个方法，其实最终调用的都是sendMessageAtTime()，但前提是创建了Handler对象，一旦创建了对象必将调用其构造。

Handler对象构造方法：

public Handler(Looper looper) {    mLooper = looper;    mQueue = looper.mQueue; //从looper对象中拿到已创建好的MessageQueue对象    mCallback = null;}

sendMessageAtTime()：

public boolean sendMessageAtTime(Message msg, long uptimeMillis){    boolean sent = false;    MessageQueue queue = mQueue; //从looper对象中拿到已创建好的MessageQueue对象    if (queue != null) {        msg.target = this; //绑定当前处理器(handler)        sent = **queue.enqueueMessage(msg, uptimeMillis);**//通过MessageQueue对象调用其enqueueMessage()方法    }    else {        ...    }    return sent;}

enqueueMessage()：

final boolean enqueueMessage(Message msg, long when) {    if (msg.when != 0) {        throw new AndroidRuntimeException(msg + " This message is already in use.");    }    if (msg.target == null && !mQuitAllowed) {        throw new RuntimeException("Main thread not allowed to quit");    }    **final boolean needWake; //是否需要唤醒**    synchronized (this) {        ...        msg.when = when; //时间        Message p = mMessages; //消息队列里的第一条消息        if (p == null || when == 0 || when < p.when) {            msg.next = p;            mMessages = msg;            ...        }    }    if (needWake) {        nativeWake(mPtr); //唤醒主线程    }    return true;}

第一种情况：p == null；

第二种情况：when = 0;

msg.next = p;

mMessage = msg;

第三种情况：when < p.when;//说明你传进来的消息的事件小于消息队列中的第一条消息的时间。

如果三种情况都不满足，那么：

来了一条消息：准备往消息队列中去插

p = p.next;//此时此刻p指向b

while(p.when < when);//p.when：表示b的时间，如果你传进来的消息的时间还比消息队列中的b消息的时间还大，那么就p又指向c消息，这样一次一次的进行对比：
一直这样，终于消息队列中的消息的时间，比你传进来的消息的时间大，那么就插入到c消息的前面。

如果此时，c消息的时间比你传过来的消息的时间大，那么就：
prev = p;
p = p.next;

msg.next = prev.next;

prev.next = msg;

Looper轮询器：分发处理消息
①、Message对象中有一个Handler类型的成员变量target，这个target是记录此消息对象是由谁创建的。

②、多个Handler给同一个消息队列发送消息。
Looper.loop() – > next() – > dispatchMessage() – > handleMessage();

AsyncTask机制

①、创建AsyncTask对象：

要执行execute()方法，首先就得创建AsyncTask对象，那么就会去执行其AsyncTask的构造方法，在其构造方法中：只是创建了WorkerRunnable对象，并没有去调用call()，因此不会去执行doInBackground()方法。

public AsyncTask() {    mWorker = new WorkerRunnable<Params, Result>() {//创建WorkerRunnable对象，是Callable的实现类。        public Result call() throws Exception {            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);            return doInBackground(mParams);//该方法目前还不会被执行，因为没有人调用call()方法。        }    };    //把WorkerRunnable对象传给了Future对象，作为其构造方法的参数。FutureTask是RunnableFuture的实现类，它的爷爷是Runnable。    mFuture = new FutureTask<Result>(mWorker) {       ......    };  ......}

②、在Future类的构造函数中：

③、创建了Sync对象，执行其构造方法：

private final Callable<V> callable;Sync(Callable<V> callable) {    this.callable = callable;//callable就是通过层层传递过来的WorkerRunnable对象。}

④、执行execute()：

⑤、在execute()方法中的sExecutor.execute(mFuture)：//sExecutor：是线程池。

private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(    CORE_POOL_SIZE,    MAXIMUM_POOL_SIZE,     KEEP_ALIVE,     TimeUnit.SECONDS,     sWorkQueue,     sThreadFactory);

那么用线程池的sExecutor.execute(mFuture)方法去执行一个Runnable对象，线程池会开启子线程去执行Runnable的run()方法。
FutureTask中的run()方法：

调用innerRun()：

使用Sync中的成员变量callable去调用了其自身的callable.call()方法，而callable就是一层一层传入过来的WorkerRunnable对象，这样调用call()方法就是调用WorkerRunnable中自身的实现好的call()方法，与此同时也就调用了call()方法中的doInBackground()方法，而doInBackground()方法是在子线程中被调用的。
那么，doInBackground()方法返回来的结果，赋值给了innerRun()中的result，而result有作为了set(result)参数传给了set()方法：

又调用了内部类Sync中的innerSet()方法：

而方法中有调用了done()方法，而done方法我们可曾写过：
在AsyncTask构造函数中曾创建了FutureTask对象并覆写了done()方法：

而sendToTarget()方法中又调用了sendMessage()方法：
同时target就是sHandler，那么将消息发送到消息队列当中，消息最终要被处理就会调用哪个发送消息的handler来处理，这里发送消息的就是sHandler，而sHandler又是哪里来的呢？
AsyncTask的内部类：

private static final InternalHandler sHandler = new InternalHandler();

MESSAGE_POST_RESULT：将会调用finish()方法：

这样就调用了onPostExecute(result)；//result：就是doInBackground()所返回的结果。

All in all，because just begun！

Android系统启动流程

Handler消息机制

AsyncTask机制

更多相关文章

随机推荐