Android中线程之间的通信——Handler

（一）如何使用Handler

大家好， 这是我第一次写博客，这次简单的介绍一下如何使用Handler完成线程之间的通信。
先说明一下为什么会用到线程之间的通信，这是因为Android中像关于网络这些比较费时的操作必须要在子线程中进行，而UI这种操作则是在主线程中进行（毕竟重活不能给老大干嘛，而子线程就是小弟）。但是问题来了，我在子线程拿到了资源了怎么跳到主线程中更新UI呢？所以今天介绍多线程中通信的其中一种方法——使用Handler进行通信。

	//这是在主线程中更新UI
	Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                Bitmap bitmap = (Bitmap) msg.obj;
                urlImg.setImageBitmap(bitmap);
            }
        };
    //子线程中的网络操作,这里面用的是okhttp开源框架获取图片的    
	 new Thread(new Runnable() {
                @Override
                public void run() {
                    try {

                        Request request = new Request.Builder()
                                .url("https://www.baidu.com/img/bdlogo.png")
                                .build();

                        Response response = client.newCall(request).execute();
                        InputStream inputStream = response.body().byteStream();
                        Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                        Message message = Message.obtain();
                        message.obj=bitmap;
                        handler.sendMessage(message);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }
            }).start();

来看一下上面的代码，想要建立Handler通信就需要new 一个Handler了，在子线程中我们已经获取到了bitmap这个资源了，我们需要一个Message对象用以发送，这个对象你可以直接new当然最好是像我上面那样使用Message.obtain()，用这种方法它会判断有没有Messeage对象，如果有就不会创建了，对于内存是会优化的。然后通过message.obj=bitmap将资源放到了Message里去了(这个obj你想放啥都可以)，在子线程中handler.sendMessage(message)，这是通过Handler发送了消息。

而在主线程中通过了Handler中的handleMessage(Message msg)我们拿到了消息，并获取了消息中的对象，并更新了UI。

（二）简谈Handler机制

知道了怎么用了以后，我们再来简单的了解一下Handler的机制，至少知道它流程是啥样的。

这是在下手画的，觉得丑的同学就多担待点吧。
接下来分析这个流程图，在子线程中的Handler将消息发送出去了，而在主线程中消息队列则是收到了message并放到它这个队列里，而在主线中有一个叫Looper的东东是消息循环器，它可以不断循环的读取消息队列中的消息并获取，在下面的Looper类中的loop方法里可以看到有一个死循环在不断地读取，而读取的对象就是MessageQueue.

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

        // Allow overriding a threshold with a system prop. e.g.
        // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
        final int thresholdOverride =
                SystemProperties.getInt("log.looper."
                        + Process.myUid() + "."
                        + Thread.currentThread().getName()
                        + ".slow", 0);

        boolean slowDeliveryDetected = false;

        for (;;) {
            Message msg = queue.next(); // might block
            if (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 logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long traceTag = me.mTraceTag;
            long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
            long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
            if (thresholdOverride > 0) {
                slowDispatchThresholdMs = thresholdOverride;
                slowDeliveryThresholdMs = thresholdOverride;
            }
            final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
            final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);

            final boolean needStartTime = logSlowDelivery || logSlowDispatch;
            final boolean needEndTime = logSlowDispatch;

            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }

            final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
            final long dispatchEnd;
            try {
                msg.target.dispatchMessage(msg);
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            if (logSlowDelivery) {
                if (slowDeliveryDetected) {
                    if ((dispatchStart - msg.when) <= 10) {
                        Slog.w(TAG, "Drained");
                        slowDeliveryDetected = false;
                    }
                } else {
                    if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                            msg)) {
                        // Once we write a slow delivery log, suppress until the queue drains.
                        slowDeliveryDetected = true;
                    }
                }
            }
            if (logSlowDispatch) {
                showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", 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();
        }
    }

在读取过后拿到了message，而在Looper类里面有这么一段代码msg.target.dispatchMessage(msg);那么这个msg.target是什么呢？
我们在Message这个类里面可以找到

/*package*/ Handler target;

定义了一个Handler类的target，这说明了Looper拿到了消息以后是要给主线程中的Handler来处理的，然后我们继续找后面的dispatchMessage(msg)，在Handler类中有这么一段代码

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

这说明了消息被Handler接受后需要实现handleMessage(msg)，在这个方法中我们可以拿到了message同时拿到了它所承载的对象并更新我们的UI。
大致的流程跟我上面手画的流程图是差不多的。