知识点1.Handler中重要的几个概念
主线程：应用程序第一次启动，会自动开启的一条线程。主要用来处理更新UI的操作。
子线程:程序手动开启的一条线程。主要用来执行一些耗时任务。
Message:线程间通信的数据单元。主要用于存储子线程要向主线程传递的数据内容
MessageQueue:消息队列，Handler存在的必要条件。主要用于存储Messge对象，是一种单链表形式，采用先进先出
Looper:循环器，MessageQueue与Handler的通信媒介,Handler存在的必要条件。主要用来循环从MessageQueue取出Message，并将Message分配给对应的Handler
知识点2.Handler 的流程图
流程分析：Handler有两个作用，分别是发送消息和接收并处理消息。先从发送消息说·起，发送消息时，会将Message发送到MessageQueue队列中，Looper会不断循环从MessageQueue取出Message发送给对应的Handler，Handler接收传递过来的消息，并进项相应的逻辑处理。由于Handler要发送Message，而Message需要存储到一个队列中才能得以保存，证明必须需要MessageQueue,而
MessageQueue并不是我们自己手动创建的，是Looper创建时候便会自动创建MessageQueue队列，且Handler处理消息是由Looper进行分发，故我们知道了MessageQueue和Looper是Handler存在必要条件。
知识点3.创建Looper的两种方式：
(1)Looper.prepareMainLooper():在主线程当应用启动时，在main()执行。不需要我们手动调用。这就是为什么Handler我们可以直接写在主线程中，并进行处理UI相关逻辑。而在子线程我们就需要自己调用Looper
(1)Looper.prepare():在子线程当需要启动一个Handler，需在new Handler()之前先写Looper.prepare()，否则会报:
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
Handler必须绑定线程才能使用，而它绑定了Looper便会绑定Looper所在的线程。故必须有Looper,且Looper不能为空。
知识点4.MessageQueue和Looper之间的关系：
MessageQueue主要任务是用来存储Message,采用单链表的形式，先进先出的方式。
MessageQueue是什么时候创建的呢？
（１）进入Looper.prepare()
public static void prepare() {
prepare(true);
}
（2）进入prepare()
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));
}
（3）进入new Looper()，Looper的构造方法
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
至此会发现，Looper初始化便会创建一个对应的MessageQueue。
生成Looper和MessageQueue后，便会自动进入消息循环（Looper.loop()），当有消息便会进行操作，没有便会挂起。
知识点5.消息循环（Looper.loop()）：
public static void loop() {
final Looper me = myLooper();//分析点1
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;;//分析点2
...
for (;;) {//分析点3
Message msg = queue.next(); // might block //分析点4
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
...
try {
msg.target.dispatchMessage(msg);//分析点5
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
...
msg.recycleUnchecked();
}
}
分析Looper.loop()中的源码，是如何开启的消息循环并把消息发给Handler?
分析点1:Looper me = myLooper(),进入 myLooper()->sThreadLocal.get(),此处Looper就是从ThreadLocal中获取(ThreadLocal:线程中的数据存储类，这里用于存储每个线程对应的Looper)
分析点2:MessageQueue是从Looper中获取的，每个Looper有一个对应MessageQueue
分析点3:这里是个死循环，不断从MessageQueue中获取待处理Message
分析点4:这里是个消息出队的操作，若MessageQueue不为空，就将此消息进行出队。若为空就会挂起Looper
分析点5：msg.target.dispatchMessage(msg);这里msg.target通过其它源码可知，指代的是Handler,将Message和Handler连在了一起,将消息分发给对应的handler，完成了消息的发送,dispatchMessage下一个知识点继续分析。
消息循环的操作 = 消息出队 + 分发给对应的Handler实例
知识点6.handler.dispatchMessage()：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
第一步：判断callback 是否为空，不为空则是handler,post()方式（下面会说handler的两种方式），回调Runnable种重写的 run()
第二步：为空则是handler.sendMessage(message)方式，回调handleMessage（）
知识点7.handler的两种使用方法：
方法1
在子线程中调用，主线程中处理
new Thread(new Runnable() {
@Override
public void run() {
Message message=Message.obtain();
message.what=1;
message.obj="hello";
handler1.sendMessage(message);
}
});
Handler handler1 = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case 1:
//更新UI
break;
}
return false;
}
});
这里涉及到一个知识点，Message的创建,有两种方式
（1） Message message=new Message();
（2） Message message=Message.obtain();
更推荐第二种方式通过源码查看,Message.obtain()方法中有一个线程池，如果线程池不为空，先是取出线程池中的线程，对其所有值赋值为空。属于线程的复用。避免了每次都new重新分配内存空间。
方法2
在主线程中创建Handler,然后直接调用即可
Handler handler2 = new Handler();
handler2.post(new Runnable() {
@Override
public void run() {
//更新UI
}
});
发现handler.post（）方式并没有创建Message，它也并不是内部启动了一个线程。而是将Runnable封装成一个Message，也是传递到了MessageQueue，其余操作和流程便是一致了。
总结
(1)handler.post()不用创建外部Message；handler.sendMessage()需要传入Message
(2)两种方法的消息处理方式不同
知识点8.一道面试题：主线程中Looper的轮询死循环为何没有阻塞主线程？
参考答案：Android是依靠事件驱动的，通过Loop.loop()不断进行消息循环，可以说Activity的生命周期都是运行在 Looper.loop()的控制之下，一旦退出消息循环，应用也就退出了。而所谓的导致ANR多是因为某个事件在主线程中处理时间太耗时，因此只能说是对某个消息的处理阻塞了Looper.loop()，反之则不然。
知识点9.新增：HandlerThread
HandlerThread：继承Thread,封装一个Handler
按顺序依次执行发送的Message
实现步骤：
1.声明初始化HandlerThread
2.线程开始 start()
3.初始化工作线程，new Handler(这里传参为HandlerThread中初始化的Looper)，所以此工作线程是子线程，不是主线程，不可以用来进行更新UI。重写handleMessage（）处理传递进来的消息
4.发送消息
5.线程关闭handlerThread.quit()
完整代码：
public class MainActivity extends AppCompatActivity {
HandlerThread handlerThread;
Handler mainHandler;
Handler workHandler;
private Button btFirst, btSecond,btQuit;
private TextView tvMsg;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btFirst = (Button) findViewById(R.id.btFirst);
btSecond = (Button) findViewById(R.id.btSecond);
btQuit= (Button) findViewById(R.id.btQuit);
tvMsg = (TextView) findViewById(R.id.tvMsg);
mainHandler = new Handler();
//1.初始化 名字自定义，用来标识线程
handlerThread = new HandlerThread("myThread");
//2.线程开始
handlerThread.start();
//3.绑定HandlerThread的线程,是thread子线程，所以不能进行更新ui操作
workHandler = new Handler(handlerThread.getLooper()) {
@Override
public void handleMessage(final Message msg) {
final String message = msg.obj.toString();
switch (msg.what) {
case 1:
mainHandler.post(new Runnable() {
@Override
public void run() {
tvMsg.setText(message);
}
});
break;
case 2:
mainHandler.post(new Runnable() {
@Override
public void run() {
tvMsg.setText(message);
}
});
break;
}
}
};
//4.发message
btFirst.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message = Message.obtain();
message.what = 1;
message.obj = "我是第一个按钮";
workHandler.sendMessage(message);
}
});
btSecond.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message = Message.obtain();
message.what = 2;
message.obj = "我是第二个按钮";
workHandler.sendMessage(message);
}
});
//5.停止
btQuit.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
handlerThread.quit();
//当handler被停止后，再调用sendMessage()会报：正在操作一个销毁了的handler，故之后不应在操作或操作之前加判断
}
});
}
}
分享一篇Handler好文章：https://www.jianshu.com/p/b4d745c7ff7a
