Handler的前世今生之framework层源码分析

Handler在线程间通讯随处可见，尤其framework层，Activity的生命周期就是AMS(ActivityManagerService)通过ApplicationThread（ActivityThread的内部类，也是一个Binder）发送Handler消息通知执行ActivityThread的相应的Activity生命周期函数。那就先来分析一下App点击运行后Handler如何执行Activity的生命周期的，当手指点击手机屏幕上的app图标时，Launcher（其实就是一个Activity,在SystemServer进程初始化后，由Zygote孵化的第一个系统进程）根据点击的图标通过AMS、PMS(Package Manager Services)来完成新App进程的创建，在创建过程中就会启动ActivityThread的main()方法，来看一下main（）中做了什么：

    public static void main(String[] args) {

       // 省略部分代码

        Looper.prepareMainLooper();  //【1.0】

        ActivityThread thread = new ActivityThread();
        thread.attach(false);// 【1.1】

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();// 【1.2】
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }
        Looper.loop(); //【1.3】

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

【1.0】就是主线程开始创建Lopper，这就是为什么我们在UI线程不需要写Loop.prepare()和Lopper.loop()代码,因为ActivityThread已经在App进程创建的时候帮我们完成了，ActivtyThread不是Thread类，只是默认的线程，所以以后她也就代表的main线程（UI 线程），看一下这句代码如何创建主线程的Looper：

   public static void prepareMainLooper() {
        prepare(false); // 【2.1】
        synchronized (Looper.class) {// 加同步对象锁 避免多线程执行
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();//【2.2】
        }
    }

【2.1】真正创主线程的sMainLooper：

 private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed)); // 【3.1】创建一个Looper，存到TLS(Thread Local Storge)，也就是存在了Main线程的线程本地存储区
    }

【3.1】创建一个Lopper对象存储到ActivityThread所代表的的UI线程的存储区，以后就直接通过一下代码获取：

public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper; // 该变量为私有的静态变量
        }
    }

方便查看，再写一遍ActivityThread 的Main（）吧：

   public static void main(String[] args) {

       // 省略部分代码

        Looper.prepareMainLooper();  //【1.0】

        ActivityThread thread = new ActivityThread();
        thread.attach(false);// 【1.1】

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();// 【1.2】
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }
        Looper.loop(); //【1.3】

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

【1.1】 用来关联AMS，通过Binder机制来与接受AMS的消息
【1.2】获取ActivityThread中的成员变量mH,(Handler)

   final H mH = new H(); // 作为Activity的成员变量，处理ActivityThread接受的消息
       private class H extends Handler {
        public static final int LAUNCH_ACTIVITY         = 100;
        public static final int PAUSE_ACTIVITY          = 101;
        public static final int PAUSE_ACTIVITY_FINISHING= 102;
        public static final int STOP_ACTIVITY_SHOW      = 103;
        public static final int STOP_ACTIVITY_HIDE      = 104;
        public static final int SHOW_WINDOW             = 105;
        ...

        String codeToString(int code) {
            if (DEBUG_MESSAGES) {
                switch (code) {
                    case LAUNCH_ACTIVITY: return "LAUNCH_ACTIVITY";
                    case PAUSE_ACTIVITY: return "PAUSE_ACTIVITY";
                    case PAUSE_ACTIVITY_FINISHING: return "PAUSE_ACTIVITY_FINISHING";
                    case STOP_ACTIVITY_SHOW: return "STOP_ACTIVITY_SHOW";
                    case STOP_ACTIVITY_HIDE: return "STOP_ACTIVITY_HIDE";
                     ...

                }
            }
            return Integer.toString(code);
        }
        public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                case LAUNCH_ACTIVITY: {

                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");

                } break;

                case PAUSE_ACTIVITY: {
                    SomeArgs args = (SomeArgs) msg.obj;
                    handlePauseActivity((IBinder) args.arg1, false,
                            (args.argi1 & USER_LEAVING) != 0, args.argi2,
                            (args.argi1 & DONT_REPORT) != 0, args.argi3);
                    maybeSnapshot();

                } break;
                ...
        }

【1.3】开始循环获取MessageQueue（存储Message的一个类似栈的数据结构）
开始分析循环前，来了解一下这几个类之间的关系：

Looper：

轮询器，该对象每个Thread最多存在一个，UI线程在App创建时在ActivityThread中自动完成，其他线程需要调用Looper.prepare()来为当前线程创建一个Looper，如果该线程已经存在，则不会再创建。

MessageQueue

消息队列，作为消息（Message）的承载体，内部维持一个类似栈的Message集合

Message

消息 ，发送体对象，持有发送者（Handler）的引用，内部含有几个成员变量（arg1,arg2
,what…）内部包含一个Message缓存池，通过obtain（）来获取空闲的Message对象，避免重复创建对象

Handler

处理器，消息的发送者，内部持有Looper和MessageQueue对象，创建Handler对象的时候会判断该线程是否存在Lopper和MessageQueue,其实有Lopper就一定存在MessageQueue,因为在创建Looper时候就创建了Looper：

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

而在创建Handler对象的时候包含多个构造函数：

其实就是包含三个参数，1：Looper 可以指定一个特定线程持有的Looper,发送的消息将发送到该Looper的MessageQueue 2：CallBack 消息的回调接口

    public interface Callback {
        public boolean handleMessage(Message msg);
    }

3：Boolean 表示是否消息是否异步处理

这下看一下Loop.loop()到底做了什么：

public static void loop() {
    final Looper me = myLooper();  //获取TLS存储的Looper对象 
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;  //获取Looper对象中的消息队列

    Binder.clearCallingIdentity();
    //确保在权限检查时基于本地进程，而不是基于最初调用进程。
    final long ident = Binder.clearCallingIdentity();

    for (;;) { //进入loop的主循环方法
        Message msg = queue.next(); //可能会阻塞 
        if (msg == null) { //没有消息，则退出循环
            return;
        }

        Printer logging = me.mLogging;  //默认为null，可通过setMessageLogging()方法来指定输出，用于debug功能
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }
        msg.target.dispatchMessage(msg); //用于分发Message 
        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }

        final long newIdent = Binder.clearCallingIdentity(); //确保分发过程中identity不会损坏
        if (ident != newIdent) {
             //打印identity改变的log，在分发消息过程中是不希望身份被改变的。
        }
        msg.recycleUnchecked();  //将Message放入消息池 
}

最后，来看一下这个图加深理解：