Handler源码分析

分析handler的源码，我们需要提前准备好这几个java类：

• Handler.java ;
• MessageQueue.java
• Looper.java
• ActivityThread.java
• ThreadLocal.java

如果没有关联源码，我们可以在adk目录下的sources中选择我们需要查看的API版本，然后在搜索框中搜索上面的类名，就可以找到这几个类的源码，然后将源码拖拽到eclipse中，AndroidStudio中是自动关联源码的，就不用再查找了，

---

Handler : 1）按计划发送消息或执行某个Runnanble(使用POST方法)，类似定时器；
2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）；
例如：handler在ui线程中创建，用来将子线程中的消息发送到ui线程的消息队列中，并且在ui线程中处理消息

Looper :我们都知道Android中的handler机制是消息驱动；这个机制是通过looper.prepare();方法创建消息驱动；并通过looper.loop（）开启驱动事件；

MessageQueue ：这是一个消息队列，用来存贮handler发送过来的消息，遵循先进先出的原则；但是有一个例外，如果我们调用handler中的sendMessageAtFrontOfQueue（）方法，那么这条消息就会被插入到消息队列的最前面，优先处理该消息；

---

下面我们来研究一下创建一个handler的完整过程：
我们在子线程中创建一个handler：

        new Thread(new Runnable() {            public Handler handler;            @Override            public void run() {                //1、准备Looper对象                Looper.prepare();                //2、在子线程中创建Handler                handler = new Handler() {                    @Override                    public void handleMessage(Message msg) {                        super.handleMessage(msg);                    }                };                //3、调用Looper的loop()方法，开始轮询消息队列；                Looper.loop();            }        }).start();

上面的代码是在主线程中开启了一个子线程；并在子线程中创建handler；主要分为三步

1.Looper.Prepare();
2.new Handler
3.Looper.loop();

下面我们从源码方面进行分析：

---

.Looper.Prepare()

//looper.java中：   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));    }

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

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

looper.prepare()最终会执行上面这两段代码：
这个方法有下面几个个作用：
1.是生成Looper对象，
2.是把Looper对象和当前线程对象形成键值对（线程为键），存放在 ThreadLocal当中，所以一个线程只能有一个looper；
3.是在looper的构造方法中初始化了一个MessageQueue的实例，因为一个线程中只有一个looper所以也只能有一个消息队列；

---

---

new Handler
Android中handler的作用有下两个方面；
1）按计划发送消息或执行某个Runnanble(使用POST方法)，类似定时器；
2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）；

  public Handler(Callback callback, boolean async) {        if (FIND_POTENTIAL_LEAKS) {            final Class<? extends Handler> klass = getClass();            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&                    (klass.getModifiers() & Modifier.STATIC) == 0) {                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +                    klass.getCanonicalName());            }        }        mLooper = Looper.myLooper();        if (mLooper == null) {            throw new RuntimeException(                "Can't create handler inside thread that has not called Looper.prepare()");        }        mQueue = mLooper.mQueue;        mCallback = callback;        mAsynchronous = async;    }

在默认构造方法里面，handler会取出当前线程中的looper和
messageQueue；从上面的代码中我们可以看到如果looper为空则会抛出异常”Can’t create handler inside thread that has not called Looper.prepare()”；这里也许会有人问，当我们在主线程中初始化handler时并没有调用looper.prepare（）方法为什么没有报错，我们需要了解主线程启动的过程：Zygote进程先启动activityThread,在activitythread类的main方法中会调用 Looper.prepareMainLooper();来初始化looper；这个方法跟looper.prepare（），然后才会执行到我们的oncreate方法；就是我们程序中开始写代码的地方；

  */    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {        MessageQueue queue = mQueue;        if (queue == null) {            RuntimeException e = new RuntimeException(                    this + " sendMessageAtTime() called with no mQueue");            Log.w("Looper", e.getMessage(), e);            return false;        }        return enqueueMessage(queue, msg, uptimeMillis);    }

使用handler方法发送消息，我们发现最终都会调用上面这个方法；返回的是enqueueMessage，查看messageQueue我们可以看出来，enqueueMessage方法是将消息压入消息队列中去；也就是说handler发消息其实是将消息放到与handler关联的消息队列中去；

 public final Message obtainMessage(int what, Object obj)    {        return Message.obtain(this, what, obj);    }

handler机制中引入了消息池的该您，调用上面的方法会从一个全局消息池里面获取一个新的Message。在Message池中检索是否存在与handler实例对应的message比创建一个新的Message更高效。如果你不想创建新Message，就是用Message.obtain方法代替。

上面的是handler发送消息，下面我们来看看handler处理消息；

 public interface Callback {        public boolean handleMessage(Message msg);    }    /**     * Subclasses must implement this to receive messages.     */    public void handleMessage(Message msg) {    }

如上面源码所示，当你实例化一个Handler的时候可以使用Callback接口来避免写自定义的Handler子类。这里的机制类似与Thread与runable接口的关系。
在Handler里面，子类要处理消息的话必须重写handleMessage()这个方法，因为在handler里面它是个空方法，

---

---

Looper.loop()
接下来我们看看这个方法的源码

    /**     * Run the message queue in this thread. Be sure to call     * {@link #quit()} to end the loop.     */    public static void loop() {        final Looper me = myLooper();        if (me == null) {        //looper为空则抛出异常；            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");        }        // 把当前looper的queue赋值给局部变量queue        final MessageQueue queue = me.mQueue;        // Make sure the identity of this thread is that of the local process,        // and keep track of what that identity token actually is.       //确保当前线程属于当前进程，并且记录真实的token        Binder.clearCallingIdentity();        final long ident = Binder.clearCallingIdentity();//从这里开始进入重点：无限for循环        for (;;) {        //与MessageQueue中的enqueueMessage（入队）相对应queue.next()是从消息队列中取出消息，即（出队）；            Message msg = queue.next(); // might block 有可能阻塞 ；            if (msg == null) {                // No message indicates that the message queue is quitting. 如果msg为空则表明消息队列停止工作；                return;            }            // This must be in a local variable, in case a UI event sets the logger            final Printer logging = me.mLogging;            if (logging != null) {                logging.println(">>>>> Dispatching to " + msg.target + " " +                        msg.callback + ": " + msg.what);            }            final long traceTag = me.mTraceTag;            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));            }            try {   //msg.target实际上就是这个消息队列所绑定的handler，这里就是调用handler中的 dispatchMessage(msg)看这个方法的源码，实际上就是调用了 handleMessage(msg)方法来处理消息        msg.target.dispatchMessage(msg);            } finally {                if (traceTag != 0) {                    Trace.traceEnd(traceTag);                }            }            if (logging != null) {                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);            }            // Make sure that during the course of dispatching the            // identity of the thread wasn't corrupted.            final long newIdent = Binder.clearCallingIdentity();            if (ident != newIdent) {                Log.wtf(TAG, "Thread identity changed from 0x"                        + Long.toHexString(ident) + " to 0x"                        + Long.toHexString(newIdent) + " while dispatching to "                        + msg.target.getClass().getName() + " "                        + msg.callback + " what=" + msg.what);            }            //将处理完的消息放到消息池中            msg.recycleUnchecked();        }    }

注释已经表达很清楚了，这里就不多做介绍了

handler原理就简单分析到这里；接下来说一下面试中经常问道的几个问题：
1.Android是如何检查非ui线程更新ui的：
在activityThread中 会调用ViewRootImpl impl = decor.getViewRootImpl();来实例化ViewRootImpl；ViewRootImpl中有一个方法invalidateChildInParent就是来判断当前线程是否是主线程；但是，ViewRootImpl这个类是在activity的onResume()方法中创建的。就算在子线程中更新UI，只要在ViewRootImpl创建之前更新UI（比如，程序在执行onCreate方法时，我就去执行setText方法区更新UI），就可以逃避掉checkThread()的检查

ViewParent是一个接口类，其实现类是ViewRootImpl，通过查看invalidateChild()方法里面的代码就可以看到会他调用checkThread()方法。checkThread()

2.当messageQueue中没有消息是，会阻塞，为什么ui线程不会崩溃，而我们在ui线程中做耗时操作操作就会倒置ANR：

由于应用的UI线程需要保持一直运行，要有一个循环保持这个线程不会死掉。但UI线程又必须保持阻塞，以减少CPU的消耗。这个循环就是通过Looper实现的。而Looper就是处理MessageQueue中的消息，即使消息为空，也不会造成ANR，因为这个就是UI线程。