Android_Handler机制

在安卓中，在不同的线程间通信，可是使用Handler来轻松实现，本文就详细的介绍Handler处理消息的原理。

1,Message

讲Handler机制，我们就不得不涉及到一个很重要的对象Message,Handler使用Message对象作为传输对象，所以Message对象中，可以携带一些对象，直接在另一个线程(handler对象所绑定的线程)中去处理。一个典型的案例就是我们在获取网络图片时必须单开线程，而后通过Handler发送一个Message通知UI线程去更新图片，这里就可以将得到的bitmap作为对象放在Message中，在UI线程中去得到这个bitmap，然后显示在ImageView控件上。

public class MainActivity extends Activity {String m_image_url = "https://ss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superplus/img/logo_white_ee663702.png";private Handler m_handler;private ImageView m_imageView;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);m_imageView = (ImageView) findViewById(R.id.imageview_temp);//在UI线程中new Handler()这样，处理消息时，也会在主线程中m_handler = new Handler(new Handler.Callback() {@Overridepublic boolean handleMessage(Message msg) {if (msg.what == 0x11) {//获得非UI线程传递过来的BitmapBitmap bitmap = (Bitmap) msg.obj;if (m_image_url != null) {m_imageView.setImageBitmap(bitmap);}}return true;//表示拦截消息事件，不会下发到handler的handerMessage()了}});}//按钮的触发事件public void click_fetch_image(View view) {new Thread(new Runnable() {@Overridepublic void run() {try {
//                    请求网络，注意添加网络权限URL url = new URL(m_image_url);HttpURLConnection connection = (HttpURLConnection) url.openConnection();connection.setDoInput(true);connection.connect();InputStream inputStream = connection.getInputStream();Bitmap bitmap = BitmapFactory.decodeStream(inputStream);if (bitmap != null) {
//                        得到一个Message对象的方法,官方推荐1,2方法
//                        1 new Message();2 Message.obtain();3 handler.obtainMessage();
//                        Message message = Message.obtain();Message message = m_handler.obtainMessage();
//                        设置message传递的信息
//                        2个int类型 message.arg1 .arg2 一个obj类型 message.objmessage.what = 0x11;message.obj = bitmap;
//                        发送消息给指定的handler
//                        1 通过Message自己发送message.setTarget(m_handler);message.sendToTarget();
//                        2 通过Handler发送
//                        m_handler.sendMessage(message);Log.d("", "子线程消息发送成功！");}else {Log.d("", "网络图片返回为null");}} catch (Exception e) {e.printStackTrace();}}}).start();}
}

代码中已经讲得很清楚怎么去获取一个Message对象，如果给利用message传递参数，如何将一个通过handler发送message.当然messge还有一些其他知识点，这里就先不讲。

2，Looper

第二个重要的类，当然是Looper了。
Looper其实就是一个在线程的处理MessageQueue的一个类，注意这里的线程是任意线程，不要被UI线程中存在looper就以为它只能在UI线程中存在，只是当运行应用时，系统会默认的在UI线程中去创建Looper而已。一个线程中只能有一个looper去处理消息(其实是分发消息给handler去处理)。想要在子线程中使用handler机制，就必须在子线程中创建looper对象。
一个典型的实例如下：

class LooperThread extends Thread {public Handler mHandler;public void run() {Looper.prepare();mHandler = new Handler() {public void handleMessage(Message msg) {// process incoming messages here}};Looper.loop();}}

跟进Looper源码中看到Lopper.prapare()最终调用了

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

它的私有构造方法，去创建一个MessageQueue，并绑定当前线程，此时我们线程中就有了looper对象了(或许应该反过来)。

看下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) {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 blockif (msg == null) {// No message indicates that the message queue is quitting.return;}// This must be in a local variable, in case a UI event sets the loggerPrinter logging = me.mLogging;if (logging != null) {logging.println(">>>>> Dispatching to " + msg.target + " " +msg.callback + ": " + msg.what);}msg.target.dispatchMessage(msg);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();}}

在第6行，得到当前线程的looper
第10行，得到消息队列，
从第17行开始是一个执行死循环，
18行从消息队列里获得消息，
31行调用handler(message.target就是message绑定的handler)的dispatchMessage()方法，对msg处理message消息

3,Handler

终于言归正传了,因为一般我们都是在UI线程中使用Handler所以这里只讲UI线程中的Handler的用法。

创建一个Handler

先创建一个Handler，我们一般声明的时候就创建，或者在Activity的onCreate()中创建：

Handler handler = new Handler();//这个handler就不具有处理消息的能力
Handler handler= new Handler(new Handler.Callback() {//这个handler可以处理消息,callback方式@Overridepublic boolean handleMessage(Message msg) {//use msg codereturn true;}});
Handler handler= new Handler(){//这个handler可以处理消息,匿名内部类方式@Overridepublic void handleMessage(Message msg) {super.handleMessage(msg);}};

Handler的两个最大的用处就是1，在另一个线程中发送message，或者runnable将他们入队(MessageQueue)；2，处理message或者runnable。

使用handler发送消息

1，Message方式
前面讲Message时，讲过了，就是调用m_handler.sendMessage()方法发送消息
2，Runnable方式
如果不需要传递数据给另一个线程，只需要通知handler线程执行某个方法，比如切换一个Button的状态，这时候，就应该用Runnable方式：

        new Handler().post(new Runnable() {@Overridepublic void run() {//handler所在线程执行的代码//code}});

前面去面试一家公司，面试官问我：handler发送消息的Message和Runnable方式有什么区别?苦逼的我当时没研究过handler源码，没答上来。
现在分析一下，就应该去看一下这个post()方法怎么去处理这个Runnable的，先看一下handler的post()方法

    public final boolean post(Runnable r){return  sendMessageDelayed(getPostMessage(r), 0);}

看到这个方法名，就有点懂了，其实还是去发送了个Message消息，因为这个sendMessageDelayed()的第一个参数是一个Message对象，下面跟进getPostMessage()

    private static Message getPostMessage(Runnable r) {Message m = Message.obtain();m.callback = r;return m;}

看到这里就明白了，当使用Runnable形式发送消息时，也是发送一个Message对象，只是记录在了message.callback中。

使用Handler处理消息

在处理之前，先看一下，handler把是如何把消息发送出去，然后消息又回到handler中去处理的

    Class Handlerpublic final boolean sendMessage(Message msg){return sendMessageDelayed(msg, 0);}public final boolean sendMessageDelayed(Message msg, long delayMillis){if (delayMillis < 0) {delayMillis = 0;}return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);}public boolean sendMessageAtTime(Message msg, long uptimeMillis) {/** mQueue为Looper中的MessageQueue */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);}private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {/** 设置当前消息的handler对象 */msg.target = this;if (mAsynchronous) {msg.setAsynchronous(true);}/** messageQueue将msg加入队列 */return queue.enqueueMessage(msg, uptimeMillis);}

Class MessageQueueboolean enqueueMessage(Message msg, long when) {/** 没有找到发送者(handler) */if (msg.target == null) {throw new IllegalArgumentException("Message must have a target.");}if (msg.isInUse()) {throw new IllegalStateException(msg + " This message is already in use.");}synchronized (this) {if (mQuitting) {IllegalStateException e = new IllegalStateException(msg.target + " sending message to a Handler on a dead thread");Log.w("MessageQueue", e.getMessage(), e);msg.recycle();return false;}msg.markInUse();msg.when = when;Message p = mMessages;boolean needWake;if (p == null || when == 0 || when < p.when) {// New head, wake up the event queue if blocked./** 当前没有消息处理，将msg加入队列 */msg.next = p;mMessages = msg;needWake = mBlocked;} else {// Inserted within the middle of the queue.  Usually we don't have to wake// up the event queue unless there is a barrier at the head of the queue// and the message is the earliest asynchronous message in the queue.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.nextprev.next = msg;}// We can assume mPtr != 0 because mQuitting is false.if (needWake) {nativeWake(mPtr);}}return true;}

通过分析Handler和MessageQueue的源码，可以发现，Handler发送一条消息之后，是加入到Looper的MessageQueue中的，这样Looper.loop()就能实时的从MessageQueue中去获得消息了，通过调用msg.target.dispatchMessage(msg);将当前的msg消息发送给原来的发送者target来处理。
现在message又回到了Handler中，分析一下handler.dispatchMessage()：

public void dispatchMessage(Message msg) {if (msg.callback != null) {/** 表明使用Runnable方式发送 */handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {/** 如果存在callback拦截消息 ，并返回true */return;}}/** 这就是我们常重写的handlerMessage() */handleMessage(msg);}}

到这里，就恍然大悟了，msg已经到我们的handlerMessage()碗里来了。不过还是要看一下handlerCallBack(）是怎么处理Runnable的

    private static void handleCallback(Message message) {message.callback.run();}

很简单的一行代码，就是去跑一个run()方法，而不是start()。
这里分析一下，线程中绑定的是Looper对象，也就是说当前线程一直有一个looper在轮询消息，当looper轮询到一条消息时，就通知handler去处理，注意这是在同一个线程中，也就是looper所在的线程中。handler如果去调用一个实现runnable接口的start(）方法岂不是又新开启了一个线程了，所以这里直接调用了run()方法，在当前线程就执行就行了。

4,使用Handler完成定时任务

Handler除了上面提到的基本用法外，还有一个常用功能就是在UI线程执行一个定时的任务，比如让一个TextView自增长。

    private Handler m_handler;public void click_start(View view) {m_handler = new Handler();//发送一个runnable，延迟一秒执行m_handler.postDelayed(m_runnable, 1000);}public void click_cancel(View view){//从消息队列中移除runnablem_handler.removeCallbacks(m_runnable);}Runnable m_runnable = new Runnable() {int i = 1;@Overridepublic void run() {m_increment_textview.setText("" + i++);//在run()中又去发送一个runnable,就是一个循环调用的过程m_handler.postDelayed(this, 1000);}};