Handler详解

本文包含与Handler有关的以下问题

1.Handler的作用
2.为什么Android中要设计为只能在UI线程中去更新UI呢?
3.Handler的两个异常
4.Handler、Looper MessageQueue之间的关系（源码角度）
5.跟线程相关的Handler，即HandlerThread（源码角度分析）
6.主线程往子线程发消息
7.子线程往子线程发消息
8.在同一线程中android.Handler和android.MessaegQueue的数量对应关系是怎样的？

一、Handler的作用

1.在非UI线程中完成耗时操作，在UI线程中去更新UI。
2.可以在主线程中发送延时消息。

二、为什么Android中要设计为只能在UI线程中去更新UI

1.解决多线程并发问题（根本原因）
2.提高界面更新的性能问题
3.架构设计的简单
你可能会说，既然是担心多线程并发问题，那我在子线程中加锁进行更新UI行不行呢？你这样想的话，会容易造成UI卡顿的，而且性能也不好。
注1：大部分面试者很难去说出一个令面试官满意的答案。
注2：关于多线程，这里举一个例子，比如说银行取款的问题。正常情况下，银行卡余额不能少于取款金额，如果多线程进行取款的话，就会造成线程不安全。
注3：Android中之所以说架构简单，是因为帮我们封装了很多更新UI的操作。

三、Handler的两个异常

在使用Handler时，经常会出现以下两个异常：
1.CalledFromWrongThreadException：这种异常是因为尝试在子线程中去更新UI，进而产生异常。
2.Can't create handle inside thread that ha not called Looper.prepared：是因为我们在子线程中去创建Handler，没有调用Looper.prepared而产生的异常。

四、Handler、Looper MessageQueue之间的关系（源码角度）

原理分析：

Handler是Android类库提供的用于发送、处理消息或Runnable对象的处理类，它结合Message、MessageQueue和Looper类以及当前线程实现了一个消息循环机制，用于实现任务的异步加载和处理。整个异步消息处理流程的示意图如下图所示：

image.png

根据上面的图片，我们现在来解析一下异步消息处理机制：

Message：消息体，用于装载需要发送的对象。
Handler：它直接继承自Object。作用是：在子线程中发送Message或者Runnable对象到MessageQueue中；在UI线程中接收、处理从MessageQueue分发出来的Message或者Runnable对象。发送消息一般使用Handler的sendMessage()方法，而发出去的消息经过处理后最终会传递到Handler的handlerMessage()方法中。
MessageQueue：用于存放Message或Runnable对象的消息队列。它由对应的Looper对象创建，并由Looper对象管理。每个线程中都只会有一个MessageQueue对象。
Looper：是每个线程中的MessageQueue的管家，负责接收和分发Message或Runnable的工作。调用Looper.loop()方法，就是一个死循环，不断地从MessageQueue中取消息：如果有消息，就取出，并调用Handler的handlerMessage()方法；如果没有消息阻塞。
现在可以做出如下总结：
（1）Handler负责发送消息，Looper负责接收Handler发送的消息放到MessageQueue，Looper又将消息回传给Handler自己。
（2）一个Handler对应一个Looper对象，一个Looper对应一个MessageQueue对象（Looper内部包含一个MessageQueue），一个Handler可以生成多个Message。
（3）Handler就是公开给外部线程的接口，用于线程间的通信。Looper是由系统支持的用于创建和管理MessageQueue的依附于一个线程的循环处理对象，而Handler是用于操作线程内部的消息队列的，所以 Handler也必须依附一个线程，而且只能是一个线程。
（4）由于Handler是在主线程中创建的，所以此时handleMessage()方法中的代码也会在主线程中运行，于是我们在这里就可以安心地进行UI操作了

五、跟线程相关的Handler，即HandlerThread（源码角度分析）

HandlerThread本质上就是一个普通Thread,只不过内部建立了Looper

HandlerThread的特点

1.HandlerThread将loop转到子线程中处理，说白了就是将分担MainLooper的工作量，降低了主线程的压力，使主界面更流畅。
2.开启一个线程起到多个线程的作用。处理任务是串行执行，按消息发送顺序进行处理。
3.相比多次使用new Thread(){…}.start()这样的方式节省系统资源。
4.但是由于每一个任务都将以队列的方式逐个被执行到，一旦队列中有某个任务执行时间过长，那么就会导致后续的任务都会被延迟处理。
5.HandlerThread拥有自己的消息队列，它不会干扰或阻塞UI线程。
6.通过设置优先级就可以同步工作顺序的执行，而又不影响UI的初始化；

六、主线程往子线程发消息

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity implements OnClickListener {
    public static final int UPDATE_TEXT = 1;
    private TextView tv;
    private Button btn;
    private Handler handler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);
        btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(this);
        //疑问：为什么这段代码如果写在onClick方法里面会报空指针？
        new Thread(new Runnable() {
            @Override
            public void run() {
                //1、准备Looper对象
                Looper.prepare();
                //2、在子线程中创建Handler
                handler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        Log.i("handleMessage:", Thread.currentThread().getName());
                        Log.i("后台输出", "收到了消息对象");
                    }
                };
                //3、调用Looper的loop()方法，取出消息对象
                Looper.loop();
            }
        }).start();

    }
    @Override
    public void onClick(View v) {
        Log.i("onClick:", Thread.currentThread().getName());
        switch (v.getId()) {
            case R.id.btn:
                Message msg = handler.obtainMessage();
                handler.sendMessage(msg);
                break;

            default:
                break;
        }
    }
}

总结：

首先执行Looper的prepare()方法，这个方法有两个作用：一是生成Looper对象，而是把Looper对象和当前线程对象形成键值对（线程为键），存放在ThreadLocal当中，然后生成handler对象，调用Looper的myLooper()方法，得到与Handler所对应的Looper对象，这样的话，handler、looper 、消息队列就形成了一一对应的关系，然后执行上面的第三个步骤，即Looper在消息队列当中循环的取数据。
另外，在本文最开头的第一段中，我们在主线程中创建Handler也没有调用Looper.prepare()方法，为什么就没有崩溃呢？，这是由于在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。

七、子线程往子线程发送消息

new Thread(new Runnable() {

                      @Override
                      public void run() {
                          String msg;
                          Looper.prepare();

                          childHandler = new Handler() {
                              @Override
                    public void handleMessage(Message msg) {
                                 super.handleMessage(msg);

                                 System.out.println("这个消息是从-->>" + msg.obj+ "过来的，在" + "btn的子线程当中" + "中执行的");

                             }

                         };  
                      Looper.loop();//开始轮循

                     }
                 }).start();

创建第二个线程

new Thread(new Runnable() {

                      @Override
                      public void run() {
                         Looper loop = Looper.myLooper();
               Message msg = childHandler.obtainMessage();
                         msg.obj = "btn2当中子线程";
                         childHandler.sendMessage(msg);
                     }
                 }).start();

其实子线程向子线程之间通信，其实就是在一个子线程中创建一个Handler，它的回调自然就在此子线程中，然后在另一个子线程中调用此handler来发送消息就可以了，不过记得写上Looper哦。

八、在同一线程中android.Handler和android.MessaegQueue的数量对应关系是怎样的？

N(Handler)：1(MessageQueue)
在同一线程中肯定会调用一个 Loop.prepare() ，其中就生成一个 MessageQueue .
而代码中可以 new 出多个 Handler 发送各自的 Message 到这个 MessageQueue 中，最后调用 msg.target.dispatch 中这个>target来捕获自己发送的massge，所以明显是 N 个 Handler 对应一个 MessageQueue.