目录
写在最前端
Handler运行机制
使用Handler向主线程发送消息
使用Handler向子线程发送消息
HandlerThread的使用
Handler内存泄露
总结
写在最前端
和现实社会一样，消息机制在Android开发中也尤为重要。Android中的消息机制是通过Handler来实现的。随着EventBus和RxJava等依托观察者模式的消息传递机制的出现，当前在Android开发中Handler的使用已经不如之前那么重要，但是Android系统所提供的Handler中的各种编程思路和设计方案，对我们在编程思想的提升还是有很大益处的。
转发请标明出处
Handler运行机制
Handler的消息机制如下图所示，主要包含两个消息队列，一个是消息的回收队列，另一个是Message Q队列。
1 消息的回收队列：消息回收队列是为Handler提供消息对象的，当Handler需要发送消息时，首先从消息回收队列中获取已被清空数据的消息对象，若消息对队列中此时没有消息对象，则创建新的消息对象。当消息对象被使用后，不会直接被当做垃圾回收，而是会进入消息的回收队列，在该队列中会将消息对象上的所有数据清空，之后在队列中等待被使用。
2 获取消息 ：直接通过以下两种方式中的任一种获取消息。
Message message = Message.obtain();
Message message1 = new Message();3 创建Handler对象： 直接通过如下方式创建Handler对象即可。该Handler默认使用Android提供的Looper。
Handler handler= new Handler();
4 发送消息：通过如下等方式进行消息的发送。
handlerUI.sendEmptyMessage(11);//立刻发送空的消息
handlerUI.sendMessage(message);//立刻发送携带数据的消息
handlerUI.sendMessageDelayed(message,1000);//延迟1000ms后发送携带数据的消息5 Message Q队列：消息队列，用来管理消息，会根据消息的执行时间对消息进行排序。并通过Looper.loop对消息进行轮询取出，当队列中有消息时就将消息取出交给Handler的handlerMessage()回调进行消息的处理，当队列中没有消息时就进行阻塞等待，这种机制又被称作等待唤醒机制。Android中的等待唤醒机制是使用的Linux内核的管道流机制。
6 消息的处理：通过Looper.loop()取出消息队列中待处理的消息，通过handler的handlerMessage()回调进行消息的处理。处理完成的消息对象会进入消息的回收队列进行回收。
使用Handler向主线程发送消息
通过handler向主线程发送消息是Handler使用过程中最常规的一种方式，也是最普遍的一种使用方式。当创建Handler对象时，若使用空参构造创建，则创建出的Handler默认使用UI线程中的Looper，这个时候通过Looper.loop()取出的消息在handlerMessage()中进行处理时，是在UI线程中进行处理的。这也就是为什么大家常说：Handler是运行在主线程中的。
这又分成两种情况：
1 主线程->主线程 发送消息：在主线程中通过创建好的handler调用sendMessage()方法发送消息即可。
2 子线程->主线程 发送消息：在子线程中通过创建好的handler调用sendMessage()方法发送消息即可。
本次以子线程向主线程发送消息为例：
public class MainActivity extends AppCompatActivity {
private TextView textView;
private static final int HANDLER_UI = 1;
//运行在主线程的Handler：使用Android默认的UI线程中的Looper
public Handler handlerUI = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case HANDLER_UI:
String strData = (String) msg.obj;
textView.setText(strData);
break;
default:
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = (TextView) findViewById(R.id.tv);
findViewById(R.id.btn_ui).setOnClickListener(v->{
new Thread(()->{
Message message = Message.obtain();
message.what = HANDLER_UI;
message.obj = "发送消息的线程名称：" + Thread.currentThread().getName();
handlerUI.sendMessage(message);
}).start();
});
}
}运行结果如下：
上述代码有一定的隐患，因为如此使用Handler会导致内存泄露，此处是为了举例简洁才如此使用，正常使用Handler时要避免这种方式，解决这种导致内存泄露可通过——WeakReference（弱引用），后面会详细介绍。
使用Handler向子线程发送消息
上述说的是Handler常规的使用方式，但有时因为业（zi）务（ji）需（xia）求（xiang），需要向子线程发送消息。这时候就需要寻找突破点了，仔细观察其实很容易发现，消息机制最核心的点就是消息的Looper机制，UI线程之所以能够进行消息的实现是因为Android默认提供了一个Looper，含有Looper的线程被称为UI线程，UI线程和子线程之间唯一的区别就是一个有Looper另外的一个没有。既然突破点已经找到，那直接创建一个含有Looper的子线程，即可实现向该子线程发送消息。那如何创建一个含有Looer的子线程能？需要两步：
1 在创建的子线程的run()方法中进行Looper相关的配置。
2 在创建Hander时的构造方法中传入1线程中的Looper。
代码实现如下：
private Handler threadHandler;
private static final int HANDLER_THREAD = 2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
createLooperHandler();
textView = (TextView) findViewById(R.id.tv);
findViewById(R.id.btn_thread).setOnClickListener(v -> {
new Thread(() -> {
Message message = Message.obtain();
message.what = HANDLER_THREAD;
message.obj = "发送的线程：" + Thread.currentThread().getName();
threadHandler.sendMessage(message);
}).start();
});
}
/**
* 创建一个可以包含looper的子线程，并开启
*/
private void createLooperHandler() {
MyThread myThread = new MyThread();
myThread.start();
SystemClock.sleep(100); //注释1
threadHandler = new Handler(myThread.threadLooper) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case HANDLER_THREAD:
//添加上当前线程名称
String thrMsg = (String) msg.obj + "\n 收到的线程：" + Thread
.currentThread().getName();
runOnUiThread(() -> textView.setText(thrMsg));
break;
default:
break;
}
}
};
}
private class MyThread extends Thread {
private Looper threadLooper;
@Override
public void run() {
Looper.prepare();
threadLooper = Looper.myLooper();
Looper.loop();
}
}
}运行结果如下：
通过上面的方法，确实可以实现向子线程发送消息，但是其实还是有隐患的，眼尖的人已经看到上面29行（注释1）处的代码了，为什么要进行睡眠100毫秒，其实是因为MyThread在调用start方法后，代码向下运行，进行了创建Handler的操作，在创建Handler时需要在构造方法中传入MyThread的Looper，而只有当MyThread开启调用run()方法后才会创建出Looper，两者操作是在不同线程中，所以不能确定谁会先被执行。故，如果不进行睡眠的话，就会概率性出现空指针异常。那如何才能保证既可以向子线程发送消息，主线程又不用出现睡眠等待呢？其实android也知道这种情况，所以向我们提供了一个类HandlerThread来解决上述问题。
HandlerThread的使用
HnadlerThread是Thread的子类，是专门向子线程发送消息使用的。使用步骤如下：
private Handler handlerThreadHandler;
private static final int HANDLER_THREAD_HANDLER = 3;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
createHandlerThread();
findViewById(R.id.btn_handler_thread).setOnClickListener(v -> {
new Thread(() -> {
Message message = Message.obtain();
message.what = HANDLER_THREAD_HANDLER;
message.obj = "发送的线程：" + Thread.currentThread().getName();
handlerThreadHandler.sendMessage(message);
}).start();
});
}
private void createHandlerThread() {
HandlerThread handlerThread = new HandlerThread("handler_name1");
handlerThread.start();
handlerThreadHandler = new Handler(handlerThread.getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case HANDLER_THREAD_HANDLER:
//添加上当前线程名称
String thrMsg = (String) msg.obj + "\n 收到的线程：" + Thread
.currentThread().getName();
runOnUiThread(() -> textView.setText(thrMsg));
break;
default:
break;
}
}
};
}运行结果如下：
Handler内存泄露
前面说到，使用Handler时最需要注意的就是内存泄露问题，内存泄露通俗来讲就是：对象使用完成将要回收，但是对象的引用还被其他类所持有，导致对象无法被GC回收。当前通用的解决方案是：Handler使用静态类，内部通过弱引用的方式来持有对象的引用。具体如下：
public static class MyHandler extends Handler {
WeakReference<Activity> mWeakReference;
public MyHandler(Activity activity) {
mWeakReference = new WeakReference<Activity>(activity);
}
@Override
public void handleMessage(Message msg) {
Activity activity = mWeakReference.get();
if (activity == null) {
return;
}
switch (msg.what) {
case 101:
adapter.notifyDataSetChanged();
break;
default:
break;
}
}
}
总结
以上只是对Handler使用的一个整体概述，包含向主线程发送消息和向子线程发送消息，基本囊括了Handler使用的所有场景。指示探索过程中，总有未知和不足，不足之处还望指正。
