Android Handler机制浅析

一、什么是Handler

handler机制是Android系统中提供的一种消息处理机制，它主要的作用是用来帮助非ui线程更新ui界面。我们知道在非ui线程中，我们无法直接更新ui界面，此时我们便可以利用Handler这一机制来对UI进行更新。换一句话说我们可以通过Handler来实现跨线程的通信。
基本原理:在一个线程中，开启一个循环去不断的从消息队列里取出消息，如果存在消息，就对消息进行处理。而在另一个线程中，我们往需要通信线程的消息队列里发消息，这样就实现的跨线程的通信。

二、实现的原理

1.Looper
由上面的图可知，我们首先需要一个循环来不断的从消息队列了取消息，而这个功能就是Looper实现的。
我们知道，每一个程序都有一个入口，而Android程序的入口便是ActivityThread中的main方法。其实ActivityThread就是UI线程。我们查看ActivityThread原代码的时候会发现main方法中有一个 Looper.prepare()的方法和一个Looper.loop()的方法，我们跟进Looper去看一下。

 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));
 }

我们发现这个函数中进行了一个判断，判断是否存在Looper这个对象，如果为null则为当前线程set一个Looper对象进去。ThreadLocal在这里我们不细讲，你只要知道，此时设置进去的这个Looper是线程独立的。

public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        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.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

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

             //不为空的时候处理消息
             ..............
            msg.recycleUnchecked();
        }
    }
public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

在loop()函数中，首先得到当前线程中的Looper。然后从这个Looper中会得到一个Messagequeue，看到这你应该明白了，这就是上面提到的存放消息的消息队列。然后进行for循环。不断的从queue 中取出消息。看到这我们就明白了，在主线程一直存在一个循环，而这个就是有looper完成的。

2.Messagequeue
在上面我们从Looper中得到了MessageQueue，在这里我可以告诉你，每一个Looper中都存在唯一一个MessageQueue，而每一个线程中又只存在一个Looper，所以对于线程来说，只要有Looper存在便就有MessageQueue存在，这个MessageQueue就是该线程的唯一一个消息队列，用来存放发过来的消息。

3.Handler
在使用Handler的时候，我们都需要初始化一个实例，一般的使用方法如下。

Handler mHandler=new Handler(){
        @Override
        //此函数需要你重写，来完成你收到消息后所需要执行的动作。
        public void handleMessage(Message msg)
        {
            super.handleMessage(msg);
        }
};

我们跟进Handler看看它的源码。

//无参构造函数
 public Handler() {
        this(null, false);
 }
 //所有构造函数最终都将执行下面这个构造函数
 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 = asyn
}

这上述代码中我们发现，我们首先使用mLooper = Looper.myLooper()这个方法为Handler里面的Looper赋值。而此时Looper.myLooper()得到的便是当前线程中唯一的一个Looper。而后又通过mQueue = mLooper.mQueue获取当前线程唯一的一个MessageQueue来赋值给Handler中的Messagequeue。因此此时Handler中的Looper与Messagequeue都是线程中唯一的。
现在我们来完成一个简单的线程通信。
首先在线程A中开启一个线程B，将Handler传入进去

testThread thread=new testThread(mHandler);
thread.start();

在线程B中，将得到线程A传来的Handler，包括Handler中的Looper，以及Messagequeue。然后通过mHandler.sendMessage(message);来发消息，此时就将把消息发送到线程A中的Messagequeue中。

 public class testThread extends Thread{
        Handler mHandler;
        public testThread(Handler handler){
            mHandler=handler;
        }

        @Override
        public void run()
        {
            super.run();
            Message message=new Message();
            message.arg1=17;
            mHandler.sendMessage(message);
        }
    }

线程A在不断循环的从Messagequeue取消息，当线程B通过sendMessage发送消息后，线程A中Messagequeue便将有了新的消息，线程A取出消息，交给Handler去执行，最终就将执行handleMessage()函数中的代码，这样就实现了线程间的通信。

三、总结

回顾一下上面的流程
1.首先需要一个Looper实例，这个Looper实例是线程唯一的。在主线程中已经帮我们执行了Looper.prepare()这个方法，所以Looper已经存在。但是在其他线程中，并没有主动执行Looper.prepare()这个方法，所以我们需要自己去执行。并且开启Looper.loop()这个循环。
2.因为有了Looper，所以就有了messagequeue，looper.loop()会不断的从消息队列中去消息，如果消息存在，则执行。
3.声明一个Handler对象，并重写它的handleMessage()方法。在Handler的构造函数中，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。
4.将Handler对象作为参数传递给其他线程，并在其他线程中发送消息，当前线程就会收到，从而执行handleMessage()，完成两个线程间的通信。

四、其他线程中使用Handler的注意事项

因为主线程中自己已经帮我们执行了Looper.prepare()和Looper.loop()这两个方法，所以我们不需要自己执行。但是其他线程中没有，所以我们需要自己执行。

public class testThread extends Thread{
        Handler mHandler;
        public testThread(){
            Looper.prepare();
            //注意Handler对象的声明一定要在Looper.prepare()后。
        }

        @Override
        public void run()
        {
            super.run();
            .........
            .........
            .........
            Looper.loop();
        }
    }

五、Handler.post(new Runnable())

Handler.post(new Runnable())是另一种是用Handler的方式，在Runnable中的run方法，其实是执行在UI线程中(就是需要接受消息的线程)的。可以直接修改ui界面。

    mHandler.post(new Runnable()  
            {  
                @Override  
                public void run()  
                {  
                    mTxt.setText("run");  
                }  
  });  

我们来看看.post代码,我们发现最终也将和sendmessage一样执行到sendMessageAtTime这个函数

private static Message getPostMessage(Runnable r) {
        //将runnable对象传入message中，封装成一个带有runnable对象的message。
        Message m = Message.obtain();
        m.callback = r;
        return m;
 }
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);
}

然后调用enqueueMessage

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        //将当前的Handler对象设置为msg的target，这样可以知道这个message最终将由哪个handler来执行。
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //将Message加入到消息队列
        return queue.enqueueMessage(msg, uptimeMillis);
}

在取出消息，对消息进行处理的时候，会做一个判断。

    public void dispatchMessage(Message msg) {  
            //这里将判断msg.callback是否为空，上面我们将runnable对象赋值进去，所以这里将不为空。
            //执行callback回调，也就是我们的Runnable对象，所以是直接执行在UI线程中的。
           if (msg.callback != null) {  
               handleCallback(msg);  
           } else {  
               if (mCallback != null) {  
                   if (mCallback.handleMessage(msg)) {  
                       return;  
                   }  
               }  
               handleMessage(msg);  
           }  
  }