一、前言：
Android中的消息机制是通过Handler来实现的。随着EventBus和RxJava等依托观察者模式的消息传递机制的出现，当前在Android开发中Handler的使用已经不如之前那么重要，但是Android系统所提供的Handler中的各种编程思路和设计方案，对我们在编程思想的提升还是有很大益处的。
gitHub 地址：https://github.com/lyyRunning/ThreadDemo0629.git
1.Handler是什么?
Handler是Android给我们提供用于更新UI的一套机制，也是一套消息处理机制。我们用它可以发送消息，也可以用它处理消息。在Android开发中有着非常重要的地位。
2.为什么要使用Handler?
当一个应用程序运行时，它会创建一个进程。这个进程就是我们的主线程(UI线程&Activity Thread) 。在主线程中，会默认为我们在系统中默认创建一个Looper，这个Looper会与我们的Message Queue 和 主线程有一定联系。 在main线程中，主要是运行一个Message Queue，管理着顶级的应用程序(Activity，Boardcast Receiver…)这些顶级应用程序在默认情况下都会在主线程中创建。这就是为什么我们需要在主线程中更新UI。
Android在设计的过程中，就封装了一套消息创建、传递、处理的机制。如果不遵循这样的机制，是没有办法更新UI信息的，会抛出异常信息。
非主线程更新UI的后果
我们可以尝试在一个新的线程中更新UI，会发现程序崩溃了。查看Logcat可以看到这样的一句提示
Only the original thread that created a view hierarchy can touch its views.
这告诉我们，在实际开发中，我们需要遵循Google为我们设定的这样的机制。
那么如何在其他线程达到更新UI的目的呢？使用Handler就是其中一种办法。
3.Handler的作用
根据Android Developer网站上的描述，Handler主要有两个用途
- 定时地去发送一个Message或Runnable对象
- 可以跳转到另一个线程中去执行一些操作
4.Handler的使用方式
关于Message
参数
public int arg1(arg2)：如果只需要存储几个整型数据，arg1 和 arg2是setData()的低成本替代品。
public Object obj： 发送给接收者的任意对象。当使用Message对象在线程间传递消息时，如果它包含一个Parcelable的结构类（不是由应用程序实现的类），此字段必须为非空（non-null）。其他的数据传输则使用setData(Bundle)方法。
public Messenger replyTo：用户自定义的消息代码，这样接受者可以了解这个消息的信息。每个handler各自包含自己的消息代码，所以不用担心自定义的消息跟其他handlers有冲突。
方法
另外 ，用Message来传递还可通过Message的setData(Bundle)方法来传递。获取时调用getData()方法。与sendData相似的还有peekData。
public void setData(*Bundle data)：设置一个任意数据值的Bundle对象。如果可以，使用arg1和arg2域发送一些整型值以减少消耗。
public Bundle peekData()：与getData()相似，但是并不延迟创建Bundle。如果Bundle对象不存在返回null。
public Bundle getData()：获取附加在此事件上的任意数据的Bundle对象，需要时延迟创建。通过调用setData(Bundle)来设置Bundle的值。需要注意的是，如果通过Messenger对象在进程间传递数据时，需要调用Bundle类的Bundle.setClassLoader()方法来设置ClassLoader，这样当接收到消息时可以实例化Bundle里的对象。
public static Message obtain()： 从全局池中返回一个新的Message实例。在大多数情况下这样可以避免分配新的对象。
5.handleMessage方法
handleMessage方法用于接收Message对象并进行相应的处理，对应Handler的sendMessage方法。
使用时应在handler中重写此方法。当在其他线程调用sendMessage方法时，handleMessage方法便会被回调，并携带sendMessage方法调用者在Message中存入的信息。当我们想要在其他线程更新UI时，就可以用主线程中创建的Handler调用sendMessage方法，然后在该Handler重写的handleMessage方法中做相应的处理。
比如此处，我们在handleMessage方法中进行更新TextView的操作，并把Message的arg1作为文本的内容。
private Handler mHandler = new Handler(){
public void handleMessage(Message msg){
mTextView.setText(""+msg.arg1+"-"+msg.arg2);
};
};
new Thread(){
@Override
public void run() {
try {
Thread.sleep(2000);
Message message = new Message();
message.arg1 = 88;
mHandler.sendMessage(message);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
6.post方法
刚刚的异常我们已经看到，那如何才能使用Handler在这个新建的线程更新UI呢？
我们可以这样做：在主线程中创建一个Handler。然后在子线程中，我们可以调用Handler的post方法，并向其中传递一个Runnable为参数，在Runnable中更新UI即可。
private TextView mTextView;
private Handler mHandler = new Handler();
mTextView = findViewById(R.id.tv_text);
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
mHandler.post(new Runnable() {
@Override
public void run() {
mTextView.setText("update");
}
});
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
7.postDelayed方法
postDelayed与post方法非常接近，仅仅是参数多了一个long类型的参数delayMills。它与post的区别就是它会在delayMills这段时间之后再去执行Runnable的方法，也就是延迟执行。
有时候我们需要定时的完成一些事情(比如定时更换TextView的文字)时，就可以利用它延迟执行的这一特点来实现。做法是分别在主函数中以及它所执行的Runnable中postDelayed一段时间。这样就可以达到定时地完成某件任务的工作。
比如下例就简单地实现了每隔一秒切换一次TextView文字的作用。
8.removeCallbacks方法
比如我们这里有个定时更新TextView的文本的代码，如果想要按下按钮，停止定时更换文本，就可以通过removeCallbacks方法，传入该Runnable来中止消息。
二、Handler运行机制
Handler的消息机制如下图所示，主要包含两个消息队列，一个是消息的回收队列，另一个是Message Q队列。
1. 消息的回收队列：消息回收队列是为Handler提供消息对象的，当Handler需要发送消息时，首先从消息回收队列中获取已被清空数据的消息对象，若消息对队列中此时没有消息对象，则创建新的消息对象。当消息对象被使用后，不会直接被当做垃圾回收，而是会进入消息的回收队列，在该队列中会将消息对象上的所有数据清空，之后在队列中等待被使用。
2. 获取消息 ：直接通过以下两种方式中的任一种获取消息。
Message message = Message.obtain();
message.what = MAIN_UI;
message.obj = "main发送消息的线程名称"
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 创建完毕后，这个时候内部的 Looper 以及 MessageQueue 就可以和 Handler 一起协调工作了，然后通过 Handler 的 post 方法将一个 Runnable 投递到 Handler 内部的 Looper 中去处理，也可以通过 Handler 的 send 方法发送一个消息，这个消息同样会在 Looper 中去处理。其实 post 方法最终也是通过 send 方法发送消息的。
接下来看一下 send 的工作过程：当 Handler 的 send 方法被调用时，它会调用 MessageQueueMessage 方法将这个消息放入消息队列中，然后 Looper 发现有新消息到来时，就会处理这个消息，最终消息中的 Runnable 或者是 Handler 的 handlerMessage 方法会被调用。注意 Looper 是运行在创建 Handler 所在的线程中的，这样一来 Handler 中的业务逻辑就被切换到创建 Handler 所在的线程中去执行了。
三、使用Handler向主线程发送消息
通过handler向主线程发送消息是Handler使用过程中最常规的一种方式，也是最普遍的一种使用方式。当创建Handler对象时，若使用空参构造创建，则创建出的Handler默认使用UI线程中的Looper，这个时候通过Looper.loop()取出的消息在handlerMessage()中进行处理时，是在UI线程中进行处理的。这也就是为什么大家常说：Handler是运行在主线程中的。
这又分成两种情况：
1. 主线程->主线程 发送消息：在主线程中通过创建好的handler调用sendMessage()方法发送消息即可。
2. 子线程->主线程 发送消息：在子线程中通过创建好的handler调用sendMessage()方法发送消息即可。
本次以主线程和子线程向主线程发送消息为例：
public class MainActivity extends AppCompatActivity {
@BindView(R.id.btn1)
Button btn1;
@BindView(R.id.btn2)
Button btn2;
@BindView(R.id.tv_message)
TextView tvMessage;
private static final int HANDLER_UI = 1;
private static final int MAIN_UI = 2;
/**
* 运行在主线程的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;
tvMessage.setText(strData);
break;
case MAIN_UI:
String strData2 = (String) msg.obj;
tvMessage.setText(strData2);
break;
default:
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
tvMessage.setText("主线程发送 Handler");
}
@OnClick({R.id.btn1, R.id.btn2, R.id.btn3})
public void onViewClicked(View view) {
switch (view.getId()) {
case R.id.btn1:
//主线程发送
Message message = Message.obtain();
message.what = MAIN_UI;
message.obj = "main发送消息的线程名称：" + Thread.currentThread().getName();
handlerUI.sendMessage(message);
break;
case R.id.btn2:
//子线程发送
new Thread(new Runnable() {
@Override
public void run() {
Message message = Message.obtain();
message.what = HANDLER_UI;
message.obj = "子线程发送消息的线程名称：" + Thread.currentThread().getName();
handlerUI.sendMessage(message);
}
}).start();
break;
case R.id.btn3:
ThreadActivity.launch(MainActivity.this);
break;
default:
}
}
}
上述代码有一定的隐患，因为如此使用Handler会导致内存泄露，此处是为了举例简洁才如此使用，正常使用Handler时要避免这种方式，解决这种导致内存泄露可通过——WeakReference（弱引用），后面会详细介绍。
四、使用Handler向子线程发送消息
上述说的是Handler常规的使用方式，但有时因为业务需求，需要向子线程发送消息。这时候就需要寻找突破点了，仔细观察其实很容易发现，消息机制最核心的点就是消息的Looper机制，UI线程之所以能够进行消息的实现是因为Android默认提供了一个Looper，含有Looper的线程被称为UI线程，UI线程和子线程之间唯一的区别就是一个有Looper另外的一个没有。既然突破点已经找到，那直接创建一个含有Looper的子线程，即可实现向该子线程发送消息。那如何创建一个含有Looer的子线程能？需要两步：
在创建的子线程的run()方法中进行Looper相关的配置。
在创建Hander时的构造方法中传入1线程中的Looper。
代码实现如下：
public class ThreadActivity extends AppCompatActivity {
@BindView(R.id.tv_message)
TextView tvMessage;
@BindView(R.id.btn1)
Button btn1;
@BindView(R.id.btn2)
Button btn2;
private Handler threadHandler;
private static final int HANDLER_THREAD = 3;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
tvMessage.setText("子线程处理Handler，原始用法");
createLooperHandler();
}
@OnClick({R.id.btn1, R.id.btn2, R.id.btn3})
public void onViewClicked(View view) {
switch (view.getId()) {
case R.id.btn1:
break;
case R.id.btn2:
//子线程发送
new Thread(new Runnable() {
@Override
public void run() {
Message message = Message.obtain();
message.what = HANDLER_THREAD;
message.obj = "子线程发送消息的线程名称：" + Thread.currentThread().getName();
threadHandler.sendMessage(message);
}
}).start();
break;
case R.id.btn3:
ThirdActivity.launch(ThreadActivity.this);
break;
default:
}
}
/**
* 创建一个可以包含looper的子线程，并开启
*/
private void createLooperHandler() {
MyThread myThread = new MyThread();
myThread.start();
//注释1
SystemClock.sleep(100);
threadHandler = new Handler(myThread.threadLooper) {
@Override
public void handleMessage(final Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case HANDLER_THREAD:
//添加上当前线程名称
final String thrMsg = (String) msg.obj + "\n 收到的线程：" + Thread
.currentThread().getName();
runOnUiThread(new Runnable() {
@Override
public void run() {
tvMessage.setText(thrMsg);
}
});
break;
default:
break;
}
}
};
}
public static void launch(Context context) {
Intent intent = new Intent(context, ThreadActivity.class);
context.startActivity(intent);
}
private class MyThread extends Thread {
private Looper threadLooper;
@Override
public void run() {
Looper.prepare();
threadLooper = Looper.myLooper();
Looper.loop();
}
}
}
通过上面的方法，确实可以实现向子线程发送消息，但是其实还是有隐患的，眼尖的人已经看到上面81行（注释1）处的代码了，为什么要进行睡眠100毫秒，其实是因为MyThread在调用start方法后，代码向下运行，进行了创建Handler的操作，在创建Handler时需要在构造方法中传入MyThread的Looper，而只有当MyThread开启调用run()方法后才会创建出Looper，两者操作是在不同线程中，所以不能确定谁会先被执行。故，如果不进行睡眠的话，就会概率性出现空指针异常。那如何才能保证既可以向子线程发送消息，主线程又不用出现睡眠等待呢？其实android也知道这种情况，所以向我们提供了一个类HandlerThread来解决上述问题。
五、HandlerThread的使用
HnadlerThread是Thread的子类，是专门向子线程发送消息使用的。使用步骤如下：
public class ThirdActivity extends AppCompatActivity {
@BindView(R.id.tv_message)
TextView tvMessage;
@BindView(R.id.btn1)
Button btn1;
@BindView(R.id.btn2)
Button btn2;
private Handler handlerThreadHandler;
private static final int HANDLER_THREAD = 3;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
tvMessage.setText("子线程处理Handler，正常用法");
createLooperHandler();
}
@OnClick({R.id.btn1, R.id.btn2})
public void onViewClicked(View view) {
switch (view.getId()) {
case R.id.btn1:
break;
case R.id.btn2:
//子线程发送
new Thread(new Runnable() {
@Override
public void run() {
Message message = Message.obtain();
message.what = HANDLER_THREAD;
message.obj = "发送的线程：" + Thread.currentThread().getName();
handlerThreadHandler.sendMessage(message);
}
}).start();
break;
default:
}
}
/**
* 创建一个可以包含looper的子线程，并开启
*/
private void createLooperHandler() {
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:
//添加上当前线程名称
final String thrMsg = (String) msg.obj + "\n 收到的线程：" + Thread
.currentThread().getName();
runOnUiThread(new Runnable() {
@Override
public void run() {
tvMessage.setText(thrMsg);
}
});
break;
default:
break;
}
}
};
}
public static void launch(Context context) {
Intent intent = new Intent(context, ThirdActivity.class);
context.startActivity(intent);
}
}
六、Handler内存泄露
Handler使用过程中，我们需要特别注意一个问题，那就是Handler可能会导致内存泄漏。
具体原因如下：
Handler的生命周期与Activity不同，Handler会关联Looper来管理Message Queue。这个队列在整个Application的生命周期中存在，因此Handler不会因Activity的finish()方法而被销毁。
非静态（匿名）内部类会持有外部对象，当我们这样重写Handler时它就成为了一个匿名内部类，这样如果调用finish方法时Handler有Message未处理的话，就会导致Activity不能被销毁。
解决方法：
- 可以在外部新建一个类，这样便可解决这个问题。但这样无疑过于麻烦了，内部类更方便些。
- 可以同时使用静态内部类和弱引用，当一个对象只被弱引用依赖时它便可以被GC回收。
注意：要static和弱引用要同时使用，否则由于非静态内部类隐式持有了外部类Activity的引用，而导致Activity无法被释放
public static class MyHandler extends Handler {
WeakReference mWeakReference;
public MyHandler(Activity activity) {
mWeakReference = new WeakReference(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;
}
}
}
七、总结
Looper 中还有一个特殊概念，那就是 ThreadLocal，ThreadLocal并不是线程，它的作用是可以在每个线程中存储数据。ThreadLocal可以在不同的线程中互不干扰地存储并提供数据，通过ThreadLocal可以轻松获取每个线程的 Looper。当然需要注意的是，线程是默认没有 Looper 的，如果需要使用 Handler 就必须为线程创建 Looper。
主线程之所以可以接收Handler消息，是因为主线程在启动时，已经创建了Looper对象，这也是在主线程默认可以使用 Handler 的原因。
Handler 的工作主要包含消息的发送和接受过程。消息的发布主要post 的一系列方法以及 send 的一系列方法来实现的，post 的一系列方法最终通过 send 的一系列方法来实现的。
八、原理总结：
1. ThreadLocal 的工作原理：
ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其他线程来说则无法获取到数据。
对于 Handler 来说，它需要获取当前线程的 Looper，很显然 Looper 的作用域就是线程，并且不同的线程具有不同的 Looper，这个时候通过 ThreadLocal 就可以轻松实现 Looper 在线程中的存取。
2. 消息队列的工作原理：
消息队列在 Android 中指的是 MessageQueue，MessageQueue主要包含两个操作：插入和读取。读取操作本身会伴随着删除操作，插入和读取对应的方法分别为 enqueueMessage 和 next，其中
- enqueueMessage的作用是往消息队列中插入一条消息；
- next 的作用是从消息队列中取出一条消息并将其从消息队列中移除；
尽管，MessageQueue叫消息队列，但是它的内部实现并不是用的队列，实际上它是通过一个单链表的数据结构来维护消息列表，单链表在插入和删除上比较有优势。
3. Looper 的工作原理：
Looper在 Android 的消息机制中扮演着消息循环的角色，具体来说就是不停地从MessageQueue 中查看是否有新的消息，如果有新的消息就会立刻处理，否则就一直阻塞在那里。
Handler 的工作需要 Looper，没有 Looper 的线程就会报错，那么如何为一个线程创建 Looper 呢？其实很简单，通过 Looper.prepare()即可为当前线程创建一个 Looper，接着通过 Looper.loop()来开启消息循环，如下所示：
new Thread(){
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}.start();
loop方法是一个死循环，唯一跳出循环的方式 MessageQueue 的 next 方法返回 null。
当 Looper 的 quit 方法被调用时，Looper 就会调用 MessageQueue 的 quit 或者 quitSafely 方法来通知消息队列退出，当消息对列被标记为退出状态是，它的 next 方法就会返回 null。
4. Handler 原理：
Handler 的工作主要包含消息的发送和接收过程。消息的发送可以通过post 的一系列方法以及 send 的一系列方法来实现，post 的一系列方法最终是通过 send 方法的一系列方法来实现的。
Handler 发送消息的过程仅仅是向消息队列中插入了一条消息，MessageQueue 的 next 方法就会返回这条消息给 Looper，Looper 接收到消息后就开始处理了，最终消息由 Looper 交 Handler处理，即 Handler 的 dispatchMessage 方法就会被调用，这时 Handler 就进入了处理消息的阶段。
参考博客
作者：N0tExpectErr0r
地址：https://blog.csdn.net/qq_21556263/article/details/82759061