本文包含与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类以及当前线程实现了一个消息循环机制，用于实现任务的异步加载和处理。整个异步消息处理流程的示意图如下图所示：
根据上面的图片，我们现在来解析一下异步消息处理机制：
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.
