大话Android多线程(三) 线程间的通信机制之Handler

版权声明：本文为博主原创文章，未经博主允许不得转载

源码：github.com/AnliaLee

大家要是看到有错误的地方或者有啥好的建议，欢迎留言评论

前言

在Android中规定了修改UI控件，更新视图这些操作必须在UI线程（主线程）中进行。而一些耗时的操作例如加载网络数据，查询本地文件、数据等，则必须放到子线程中。因此我们需要一种通信机制使得子线程完成任务后可以通知UI线程更新界面。本章将挑选线程通信机制中的Handler进行讲解，聊一聊它和ThreadLocal、Message、MessageQueue以及Looper之间的故事

ps：本篇博客主要是起到一个引导的作用，帮助大家梳理清楚Handler、Looper、MessageQueue等角色的关系，以及它们在Handler消息机制下所起到的作用，并不会过多地深入到源码中。至于源码的讲解，网上优秀的文章实在是太多了，这里推荐几位前辈撰写的博客，大家可以相互对照着看看

Android进阶——Android消息机制之Looper、Handler、MessageQueue

Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系

Android开发——Android的消息机制详解

ps2：看完这篇博客再去了解源码有助于消化知识哦~

往期回顾

大话Android多线程(一) Thread和Runnable的联系和区别

大话Android多线程(二) synchronized使用解析

子线程向主线程发送消息

在遥远的Android大陆中，U国（UI线程，即主线程）和T国（Thread，子线程）之间发生了战争。某日，U国部队准备攻打T国的首都R城，只要收到地下组织（Handler）的特工小h（Handler的实例）的信号后，即可采取相应的行动（更新UI）。由于R城戒备森严，小h传达信号需要做到格外隐秘，因此制定了如下计划，计划由小h和他专属的情报员小L（Looper，Handler在创建时就会关联一个Looper对象，而Looper存放在ThreadLocal中，每一个线程都会维护自己的Looper，这里的Looper自然是属于主线程的）执行：

* 小h在执行潜入任务前留有各种特定信号的说明，组织可根据说明采取相应的行动

创建Handler实例时，重写handleMessage方法（在其中编写更新UI的操作），以便在消息分配后执行

public class HandlerTestActivity extends AppCompatActivity {
TextView textShow;

private static final int CODE_TEST_ONE = 101;
private static final int CODE_TEST_TWO = 102;
private static final int CODE_TEST_THREE = 103;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);
textShow = (TextView) findViewById(R.id.text_show);
}

private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case CODE_TEST_ONE:
textShow.setText("开始刺探军情...");
break;
case CODE_TEST_TWO:
textShow.setText("情报收集完毕...");
break;
case CODE_TEST_THREE:
textShow.setText("发起总攻！");
break;
}
}
};
}

小h潜入城中后，只要时机成熟，就会将信号写在纸条（Message，即消息）上塞到小L在城墙上挖好的小洞（MessageQueue）中，见下图（灵魂画手）



MessageQueue：通过单链表的数据结构来存储消息列表，消息按照先进先出的原则进行存取，在线程中创建一个Looper实例时，会自动创建一个与之配对的MessageQueue

我们在子线程中使用Handler实例发送消息时，Handler会调用内部方法enqueueMessage将Message插入到MessageQueue中（Handler.enqueueMessage方法最后调用了MessageQueue.enqueueMessage方法存放Message，有关Handler发送消息的方法请见下文附录一）

public class HandlerTestActivity extends AppCompatActivity {
//省略部分代码...
public void clickEvent(View view) {
switch (view.getId()) {
case R.id.btn_start:
new Thread(new TestRunnable()).start();
break;
}
}

private class TestRunnable implements Runnable{
@Override
public void run() {
try {
handler.sendEmptyMessage(CODE_TEST_ONE);

//                你也可以这样发送消息
//                Message message = Message.obtain();
//                message.what = CODE_TEST_ONE;
//                handler.sendMessage(message);

//                或者
//                message.sendToTarget();

Thread.sleep(2000);
handler.sendEmptyMessage(CODE_TEST_TWO);

Thread.sleep(2000);
handler.sendEmptyMessage(CODE_TEST_THREE);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}

城外负责接应的小L会一直蹲守在小洞旁（Looper.loop），一旦发现洞中出现纸条（MessageQueue.next），就将其取出送回组织（Handler.dispatchMessage），然后返回继续蹲守小洞

Looper.loop方法不断地调用MessageQueue.next方法读取消息，若消息不为空则调用Handler.dispatchMessage方法将消息分发出去

组织拿到纸条后，首先确定纸条是不是由小h发出的，确认无误后，根据纸条上的信号采取相应行动

之前在Looper中调用了Handler的dispatchMessage方法，而在dispatchMessage方法中又调用了Handler.handleMessage方法，这样就回到了我们第一点重写的代码，实现了从子线程中发送消息到主线程更新UI的操作

最后运行效果如图所示



总结Handler创建，发送消息到处理消息的整个流程，大致如下图所示

主线程向子线程发送消息

主线程的Looper在应用开启前系统就已经帮我们创建好了，如果我们要在主线程中向子线程发送消息，则需要在子线程创建时手动创建Looper并开启循环，具体实现代码如下：

public class HandlerTestActivity extends AppCompatActivity {
private Handler handler2;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);
TestThread testThread = new TestThread();
testThread.start();

while (true){//保证testThread.looper已经初始化
if(testThread.looper!=null){
handler2 = new Handler(testThread.looper){
@Override
public void handleMessage(Message msg) {//子线程收到消息后执行
switch (msg.what){
case CODE_TEST_FOUR:
Log.e(TAG,"收到主线程发送的消息");
break;
}
}
};

handler2.sendEmptyMessage(CODE_TEST_FOUR);//在主线程中发送消息
break;
}
}

private class TestThread extends Thread{
private Looper looper;

@Override
public void run() {
super.run();
Looper.prepare();//创建该子线程的Looper实例
looper = Looper.myLooper();//取出该子线程的Looper实例
Looper.loop();//开始循环
}
}
}

当然上面的代码只是简单地体验一下手动创建Looper的过程，实际上系统已经为我们封装好了HandlerThread类，它帮助我们完成了创建Looper、开启循环等一系列操作，因此使用HandlerThread会更加方便和安全。以上述同样的操作为例，这次我们直接继承HandlerThread创建子线程：

public class HandlerTestActivity extends AppCompatActivity {
private HandlerThread handlerThread;
private Handler handler2;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);

handlerThread = new HandlerThread("MyHandlerThread");
handlerThread.start();
handler2 = new Handler(handlerThread.getLooper()){
@Override
public void handleMessage(Message msg) {//子线程收到消息后执行
switch (msg.what){
case CODE_TEST_FOUR:
Log.e(TAG,"收到主线程发送的消息");
break;
}
}
};
handler2.sendEmptyMessage(CODE_TEST_FOUR);//在主线程中发送消息
}

@Override
protected void onDestroy() {
super.onDestroy();
handlerThread.quit();
}
}

有关HandlerThread更详细的资料大家可以看这篇博客

Android 进阶15：HandlerThread 使用场景及源码解析

子线程向子线程发送消息

子线程向子线程发送消息的过程和之前讲的差不多，就不赘述了

protected void onCreate(Bundle savedInstanceState) {
//省略部分代码...
handlerThread = new HandlerThread("MyHandlerThread");
handlerThread.start();
handler2 = new Handler(handlerThread.getLooper()){
@Override
public void handleMessage(Message msg) {//子线程收到消息后执行
switch (msg.what){
case CODE_TEST_FOUR:
Log.e(TAG,"收到另一个子线程发送的消息");
break;
}
}
};

Thread testThread = new Thread(new Runnable() {
@Override
public void run() {
handler2.sendEmptyMessage(CODE_TEST_FOUR);//在另一个子线程中发送消息
}
});
testThread.start();
}

附录一：Handler发送消息

Handler发送消息多种方法，但无论我们使用哪种方法，其最终都是利用MessageQueue.enqueueMessage方法将消息插入到消息队列中。各种方法内部的执行顺序如下图所示，我们可以从红框内任意一步出发，只需注意该方法的作用及传入参数的区别即可