Looper源码探究—Android消息机制

Android消息机制探究

Looper Handler 之间有什么关系：

首先看一个handler的使用例子：

  Handler handler = new Handler(){            @Override            public void dispatchMessage(Message msg) {                super.dispatchMessage(msg);            }            @Override            public void handleMessage(Message msg) {                super.handleMessage(msg);                            }        };                handler.sendEmptyMessage(1);

貌似主动创建就可以使用，但是如果是在子线程此方法是行不通的，具体原因是因为在ActivityThread中（app启动的的第一步ActivityThread的main方法）在启动前已经为其做好了充足的准备：

        Looper.prepareMainLooper();        ActivityThread thread = new ActivityThread();        thread.attach(false);        if (sMainThreadHandler == null) {            sMainThreadHandler = thread.getHandler();        }        //省略 无用代码        Looper.loop();

至于为什么要在这里创建一句话，activity的生命周期大部分都是由handler来触发和控制的，handler在使用前就需要为其准备好looper

因而在子线程创建并使用handler需要进行如下准备：

 new Thread(new Runnable() {            @Override            public void run() {                Looper.prepare();                Handler handler = new Handler() {                    @Override                    public void dispatchMessage(Message msg) {                        super.dispatchMessage(msg);                    }                    @Override                    public void handleMessage(Message msg) {                        super.handleMessage(msg);                    }                };                handler.sendEmptyMessage(1);                Looper.loop();            }        }).start();

由此我们可以确定一个对应关系：一个 thread(一开始创建的线程默认为主线程) 对应多个Handler 至于对应几个Looper我们向下看

//子线程中使用的方法     /** Initialize the current thread as a looper.      * This gives you a chance to create handlers that then reference      * this looper, before actually starting the loop. Be sure to call      * {@link #loop()} after calling this method, and end it by calling      * {@link #quit()}.      */     public static void prepare() {        prepare(true);    }    ／／在activityThread中创建的方法       /**     * Initialize the current thread as a looper, marking it as an     * application's main looper. The main looper for your application     * is created by the Android environment, so you should never need     * to call this function yourself.  See also: {@link #prepare()}     */    public static void prepareMainLooper() {        prepare(false);        synchronized (Looper.class) {            if (sMainLooper != null) {                throw new IllegalStateException("The main Looper has already been prepared.");            }            sMainLooper = myLooper();        }    }

共同点都调用了prepare(boolean quitAllowed) 只是入参不同，但是根据入参名称可以看出这个入参之时决定是否允许退出。
然而 prepare(boolean quitAllowed);这个方法仿佛开启了一个异界的大门

 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));／／重点 看这里    }

从这里可以看到原来这个prepare()只是干了一件事，创建一个looper然后放在sThreadLocal里。
至于sThreadLocal是个啥东西看这里：ThreadLocal sThreadLocal = new ThreadLocal();
看到了吗？

ThreadLocal

ThreadLocal!!! 就是我们经常听说但是并没有什么实际使用场景的ThreadLocal
但是这里就出现了ThreadLocal的使用场景。

惯例先给ThreadLocal进行下说明：
1 是一个线程内部的数据存储类
2 通过它可以在制定的线程中存储数据
3 只有在指定的线程中可以获取到存储的数据

由此我明白了一些事情：

1 虽然每次都是new 一个新的但是面对主线程的looper在代码中还是进行的防范重复创建：

  synchronized (Looper.class) {            if (sMainLooper != null) {                throw new IllegalStateException("The main Looper has already been prepared.");            }            sMainLooper = myLooper();//myLooper()这个方法稍后研究        }

2 对应关系可以继续补充了： Thread ——> N*Handler Thread->Looper 一个线程里只有一个looper（在threadlocal中保存着）虽然可以有多个handler实例但是都是在一个looper中。

看到这里我又有了新的问题：Thread是怎么区分线程的，毕竟只是一个set方法难道就ok了？让我们看看set方法：

    public void set(T value) {        Thread t = Thread.currentThread();        ThreadLocalMap map = getMap(t);        if (map != null)            map.set(this, value);        else            createMap(t, value);    }

根据变量名就能发现原来是ThreadLocal内部维护着一个map --- ThreadLocalMap，这个map的key就是当前的线程，而且还是懒加载呢，看来这些小技巧也没有被这些大牛们ingore

我又有问题了这个ThreadLocalMap 是什么map？ hashMap还是？

  ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {            table = new Entry[INITIAL_CAPACITY];            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);            table[i] = new Entry(firstKey, firstValue);            size = 1;            setThreshold(INITIAL_CAPACITY);        }

于是乎我就顺手看了其创建方法，key的生成方式还是依据hash值，原来是放在一个初始长度是16的数组中，就是一个简易的hashmap

回归正题，想知道 handler和looper的关系，还得深入looper来看：new Looper(quitAllowed)
···
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
···
哈哈哈，看到这里我笑了本来我们是要找looper 和 handler的关系怎么就冒出来一个MessageQueue，呵呵看来关系图要加上一笔，简直是意外收获啊，确认关系：thread ——> looper -> MessageQueue
(handler就先不考虑的)

MessageQueue

它就是Android中大名鼎鼎的消息队列，
1 它主要工作只有两部：插入和读取 enqueueMessage,next
2 虽然叫消息队列但实际上是通过单向链表维护数据结构（单向链表在插入和删除上比较有优势）

说起它是单向链表我很好奇啊这个单向链表是怎么实现的？

 boolean enqueueMessage(Message msg, long when) {   ／／省略             if (p == null || when == 0 || when < p.when) {                msg.next = p;                mMessages = msg;                needWake = mBlocked;            } else {                needWake = mBlocked && p.target == null && msg.isAsynchronous();                Message prev;                for (;;) {                    prev = p;                    p = p.next;                    if (p == null || when < p.when) {                        break;                    }                    if (needWake && p.isAsynchronous()) {                        needWake = false;                    }                }                msg.next = p; // invariant: p == prev.next                prev.next = msg;            }    }

删掉一些辅助类代码和注释也不长就是一个判断但是根据判断就明白了原来 MessageQueue所谓的链表原来是这样的结果 Message 对象，但是Message对象有个next属性用来记录下一个对象的引用
如图所示：

图片发自App

再看看如果获取消息：虽然是精简过的但是也不少，因为它还要考虑到延时消息怎么搞的问题

  final long now = SystemClock.uptimeMillis();                Message prevMsg = null;                Message msg = mMessages;                if (msg != null && msg.target == null) {                    // Stalled by a barrier.  Find the next asynchronous message in the queue.                    do {                        prevMsg = msg;                        msg = msg.next;                    } while (msg != null && !msg.isAsynchronous());                }                if (msg != null) {                    if (now < msg.when) {                        // Next message is not ready.  Set a timeout to wake up when it is ready.                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);                    } else {                        // Got a message.                        mBlocked = false;                        if (prevMsg != null) {                            prevMsg.next = msg.next;                        } else {                            mMessages = msg.next;                        }                        msg.next = null;                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);                        msg.markInUse();                        return msg;                    }                } else {                    // No more messages.                    nextPollTimeoutMillis = -1;                }

耐心看完，其实你可以发现：message的排列顺序有多少个 messagequeue都不知道或者说不关心，也没有提供向上追溯的方法，而且看了代码才理解了“消费”这个词，当message被消费掉了，mMessage就会被替换成下一个message。简直是精妙！
上面介绍了这么多其实消息队列还没有跑起来呢，回到问题，即然是想要让消息机制运转起来，还有一段很重要的话：Looper.loop()

Looper

loop() 第一句代码就是 final Looper me = myLooper();

呵呵 myLooper() 到你了吧，这句话干嘛呢？让我看一下：

    public static @Nullable Looper myLooper() {        return sThreadLocal.get();    }

实现很简单，就是从LocalThread中获取到当前的looper

接下来就是惨无人道的一通遍历(死循环啊)

  for (;;) {            Message msg = queue.next(); // might block            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }            //省略                msg.target.dispatchMessage(msg);／／省略        }

无脑从消息队列中获取 next直到next是null，但是如果next取不到东西其实就说明消息队列没有内容，messagequeue这时候其实已经是阻塞的了（调用native方法终止循环）最终消息是怎么被处理的呢？看到没 msg.target.dispatchMessage(msg)
呵呵你知道target对象是谁吗？
没错就是 Handler

Handler

handler啊说白了就是个生产者，整天造垃圾向传送带（messagequeue）上扔，怎么扔呢：

 public final boolean sendMessageAtFrontOfQueue(Message msg) {        MessageQueue queue = mQueue; //省略        return enqueueMessage(queue, msg, 0);    }    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;        if (mAsynchronous) {            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }

原来handler中有messagequeue的引用啊，什么时候有的？

  mLooper = Looper.myLooper();        if (mLooper == null) {            throw new RuntimeException(                "Can't create handler inside thread that has not called Looper.prepare()");        }        mQueue = mLooper.mQueue;

原来是创建的时候啊，其实什么时候都无所谓因为想要looper 调用静态方法Looper.myLooper()就得到了。

哈哈这下算是形成了一个闭环，handler（扔垃圾者）——》MessageQueue（垃圾车收垃圾）——》Looper（从垃圾车上捡垃圾，问垃圾是谁扔的你）——》handler（处理自己造的垃圾）