android-handlerThread

记住一点Handler是子线程到主线程，HandlerThread是主线程到子线程通信

一、HandlerThread简介

HandlerThread是一个轻量级的异步类，可以实现多线程，并且可以实现线程间的通信（HandlerThread主要应用是实现主线程到子线程的通信，子线程到主线程通信可以通过Handler机制）。

二、HandlerThread原理

既然已经有Handler可以实现线程间通信，为什么又设计了HandlerThread？

HandlerThread通过字面意思我们可以看到，它是Handler+Thread，那么我们猜测它应该实现了Handler和Thread功能，到底是不是呢，我们向下看。

首先，HandlerThread继承了Thread类，也就是说HandlerThread可以创建一个新的线程。

其次，HandlerThread内封装了Handler类，并自动创建了Looper和MessageQueue，也就是说我们使用HandlerThread线程时，不需要手动创建Looper。

优点：

之前我们使用Handler时，必须自己创建线程，并且自己创建Looper等相关的功能，而HandlerThread则提供了一种方便的方式，相当于内部已经集成了这些功能，不需要我们再手动创建Looper。

三、HandlerThread使用实例

使用步骤：

//1、创建HandlerThread对象，即创建了一个新的线程，参数为线程名，仅仅是标记线程用的

HandlerThread mHandlerThread = new HandlerThread("mHandlerThread");

//2、开启线程，第一步创建了一个新的线程，此处开启线程。

mHandlerThread.start();

//3、创建Handler，并重写handleMessage()方法

//new Handler(mHandlerThread.getLooper())，即把该Handler绑定到mHandlerThread线程的Looper，

//进而绑定到了线程mHandlerThread

Handler mHandlerInHandlerThread = new Handler(mHandlerThread.getLooper()){

@Override

public void handleMessage(Message msg) { 这个是在子线程

//对信息的相关处理操作

//在子线程mHandlerThread中运行

super.handleMessage(msg);

}

};

//4、创建消息并发送消息

//在主线程中

Message msg = Message.obtain();

//主线程向子线程mHandlerThread发送消息通信

mHandlerInHandlerThread.sendMessage(msg);

//5、结束线程。之前开启线程，当工作结束不再使用该线程时，应该结束该线程

//即停止了线程的消息循环

mHandlerThread.quit();

通过使用步骤我们可以看到，HandlerThread实现的功能主要就是主线程向子线程通信，另外可以在使用Handler实现子线程到主线程的通信，进而就可以实现主线程到子线程间的双向通信.

使用实例：

//功能介绍：点击按钮实现延时操作，延时时间到后更新UI。

public class MainActivity extends AppCompatActivity {

TextView mTxtShowTest;

Button mBtnInnerClass ,mBtnHandlerThread, mBtnQuit;

//1、创建HandlerThread对象，即创建了一个新的线程，参数为线程名，仅仅是标记线程用的

HandlerThread mHandlerThread = new HandlerThread("mHandlerThread");

//匿名内部类，用于子线程向主线程通信用

private Handler mhandlerInnerClass = new Handler(){

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

switch (msg.what){

case 1:

//执行的UI操作

mTxtShowTest.setText("点击了mBtnInnerClass");

break;

case 2:

//执行的UI操作

mTxtShowTest.setText("来自于mHandlerInHandlerThread的请求更新");

break;

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

mTxtShowTest = (TextView) findViewById(R.id.mTxtShowTest);

mBtnInnerClass = (Button) findViewById(R.id.mBtnInnerClass);

mBtnHandlerThread = (Button) findViewById(R.id.mBtnHandlerThread);

mBtnQuit = (Button) findViewById(R.id.mBtnQuit);

//2、开启线程，第一步创建了一个新的线程，此处开启线程。

mHandlerThread.start();

//3、创建Handler，并重写handleMessage()方法

//new Handler(mHandlerThread.getLooper())，即把该Handler绑定

//到了mHandlerThread线程的Looper，进而绑定到了线程mHandlerThread

final Handler mHandlerInHandlerThread = new Handler(mHandlerThread.getLooper()){

@Override

public void handleMessage(Message msg) {

//已经是在子线程mHandlerThread中运行了

//可以进行一些耗时等操作

try{

Thread.sleep(10000); //延时操作

}catch (Exception e){

e.getMessage();

}

//子线程向主线程通信

Message msg1 = Message.obtain();

msg1.what = 2;

mhandlerInnerClass.sendMessage(msg1);

super.handleMessage(msg);

}

};

mBtnInnerClass.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

new Thread(new Runnable() {

@Override

public void run() {

Message msg = Message.obtain();

msg.what = 1;

mhandlerInnerClass.sendMessage(msg);

}

}).start();

}

});

mBtnHandlerThread.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

//4、创建消息并发送消息

//主线程中

Message msg = Message.obtain();

//主线程向子线程发送信息，通信

mHandlerInHandlerThread.sendMessage(msg);

}

});

mBtnQuit.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

//5、结束线程。之前开启线程，当工作结束不再使用该线程时，应该结束该线程

//即停止了线程的消息循环

mHandlerThread.quit();

}

});

}

注意：

当连续多次点击按钮mBtnHandlerThread是，mTxtShowTest中显示，并不是同时显示的，而是先显示第一次，间隔延时10s（这个10s是在复写handleMessage()方法时自己写的 Thread.sleep(10000)）后显示第二次,再间隔延时的10s显示第三次。当我们连续多次点击mBtnHandlerThread按钮时，消息入队列，取出消息执行时，有一个延时10s，之后更新UI，这个消息才算执行完成，然后从消息队列中取出下一个消息，同样有一个延时10s，之后才是更新UI，所以即便时快速连续多次点击按钮，但是执行时每次都间隔一个延时10s.

总结：

以上就是HandlerThread的使用步骤和使用实例，已经测试过可以使用。首先点击按钮mBtnInnerClass， mTxtShowTest显示"点击了mBtnInnerClass"，之后再点击按钮mBtnHandlerThread，十秒之后，mTxtShowTest显示"来自于mHandlerInHandlerThread的请求更新"。多次点击按钮mBtnHandlerThread，然后点击mBtnInnerClass，mTxtShowTest显示"点击了mBtnInnerClass"，10s后mTxtShowTest显示"来自于mHandlerInHandlerThread的请求更新"，之后再点击mBtnInnerClass，mTxtShowTest显示"点击了mBtnInnerClass"，10s后又会mTxtShowTest显示"来自于mHandlerInHandlerThread的请求更新"，即可证明前面注意中说明的问题。

四、HandlerThread源码分析

在第三部分使用实例中的使用步骤可以看到，使用HandlerThread大概需要5步，具体如下：

使用步骤：

//1、创建HandlerThread对象，即创建了一个新的线程，参数为线程名，仅仅是标记线程用的

HandlerThread mHandlerThread = new HandlerThread("mHandlerThread");

//2、开启线程，第一步创建了一个新的线程，此处开启线程。

mHandlerThread.start();

//3、创建Handler，并重写handleMessage()方法

//new Handler(mHandlerThread.getLooper())，即把该Handler绑定到mHandlerThread线程的Looper，

//进而绑定到了线程mHandlerThread

Handler mHandlerInHandlerThread = new Handler(mHandlerThread.getLooper()){

@Override

public void handleMessage(Message msg) {

//对信息的相关处理操作

//在子线程mHandlerThread中运行

super.handleMessage(msg);

}

};

//4、创建消息并发送消息

//在主线程中

Message msg = Message.obtain();

//主线程向子线程mHandlerThread发送消息通信

mHandlerInHandlerThread.sendMessage(msg);

//5、结束线程。之前开启线程，当工作结束不再使用该线程时，应该结束该线程

//即停止了线程的消息循环

mHandlerThread.quit();

我们根据使用步骤，一步一步的去看源码。

步骤1、创建HandlerThread对象

源码分析：HandlerThread mHandlerThread = new HandlerThread("mHandlerThread");

/**

* Handy class for starting a new thread that has a looper. The looper can then be

* used to create handler classes. Note that start() must still be called.

//通过HandlerThread 的定义，其继承Thread ，可知HandlerThread 就是个线程

public class HandlerThread extends Thread {

int mPriority;//优先级

int mTid = -1;

Looper mLooper;//当前线程的Looper

private @Nullable Handler mHandler;

public HandlerThread(String name) {

super(name);

mPriority = Process.THREAD_PRIORITY_DEFAULT;

}

public HandlerThread(String name, int priority) {

super(name);

mPriority = priority;

}

...

}

总结：

HandlerThread就是个线程，继承了Thread。创建HandlerThread 时，就相当于创建了一个新的线程，并设置了该线程的优先级。

步骤二、开启线程 mHandlerThread.start();

源码分析：

//Causes this thread to begin execution; the Java Virtual Machine

//calls the run method of this thread.

public synchronized void start() {...}

//调用mHandlerThread的start()，最终将调用mHandlerThread的run()方法。

@Override

public void run() {

mTid = Process.myTid();//获取当前线程的ID

Looper.prepare();//创建Looper和MessageQueue

//通过锁机制，获取当前线程的Looper对象

synchronized (this) {

//获取当前线程的Looper对象

mLooper = Looper.myLooper();

//发送通知，已经获取当前线程的Looper对象

//主要是在第三步创建Handler中的mHandlerThread.getLooper()内使用

notifyAll();

}

Process.setThreadPriority(mPriority);//设置线程的优先级

//主要是做一些开启消息循环前的准备工作 -->>分析1

onLooperPrepared();

//开启消息循环

Looper.loop();

mTid = -1;

}

分析1： onLooperPrepared()

/**

* Call back method that can be explicitly overridden if needed to execute some

* setup before Looper loops.

protected void onLooperPrepared() {

}

总结：

第一步创建了线程，第二步开启该线程。开启线程时，会创建Looper和MessageQueue，成功后线程会进入消息循环，不断从消息队列中取出消息并分发消息。

步骤三、创建Handler，并重写handleMessage()方法

使用方法：

Handler mHandlerInHandlerThread = new Handler(mHandlerThread.getLooper()){

@Override

public void handleMessage(Message msg) {

//对信息的相关处理操作

//在子线程mHandlerThread中运行

super.handleMessage(msg);

}

};

//创建Handler时传入Looper对象，此时Handler就与该Looper绑定，进而与Looper所在的线程也绑定

//获取当前线程（即mHandlerThread线程）的Looper对象

public Looper getLooper() {

if (!isAlive()) {

return null;

}

// If the thread has been started, wait until the looper has been created.

synchronized (this) {

while (isAlive() && mLooper == null) {

try {

//等待，直到mHandlerThread的run()方法创建了Looper

//并 notifyAll()发送通知

wait();

} catch (InterruptedException e) {

}

return mLooper;

}

总结：

复写handleMessage()方法，该方法是在子线程mHandlerThread中运行，而非主线程，要注意。因为是在子线程中，所以可以进行一些耗时相关的操作。另外，通过Handler机制，可以实现该子线程与主线程的通信，进而更新UI。

步骤四、创建消息并发送消息

//在主线程中

Message msg = Message.obtain();

//主线程向子线程mHandlerThread发送消息通信

mHandlerInHandlerThread.sendMessage(msg);

//与Handler中的使用方法一样，就不多做介绍了。

步骤五、结束线程

//之前开启线程，当工作结束不再使用该线程时，应该结束该线程

//即停止了线程的消息循环

//源码分析：mHandlerThread.quit();

public boolean quit() {

//获取当前Looper

Looper looper = getLooper();

if (looper != null) {

//调用Looper的quit()方法 -->>分析1

looper.quit();

return true;

}

return false;

}

//分析1： looper.quit();

public void quit() {

//调用MessageQueue的quit()方法 -->>分析2

mQueue.quit(false);

}

//通过looper.quit()退出是一种不安全的退出方法，

//还有一种安全的退出方法，即looper.quitSafely();

public boolean quitSafely() {

Looper looper = getLooper();

if (looper != null) {

looper.quitSafely();//-->>分析a

return true;

}

return false;

}

//分析a looper.quitSafely()的源码实现：

public void quitSafely() {

//通过源码，截至到目前可以看出，安全不安全主要是mQueue.quit()方法

//内的boolean变量是true还是false

mQueue.quit(true);// -->>分析2

}

分析2： mQueue.quit(false);

void quit(boolean safe) {

synchronized (this) {

if (mQuitting) {

return;

}

mQuitting = true;

if (safe) {//安全的退出方式

removeAllFutureMessagesLocked();// -->>分析4（请先看分析3）

} else {//非安全的退出方式

removeAllMessagesLocked();// -->>分析3

}

// We can assume mPtr != 0 because mQuitting was previously false.

nativeWake(mPtr);

}

//分析3、 removeAllMessagesLocked()

//不管该消息是否在使用，把消息队列中的所有消息都回收

private void removeAllMessagesLocked() {

Message p = mMessages;

while (p != null) {

Message n = p.next;

//Recycles a Message that may be in-use.

//这里，不管Message是否在使用，都回收销毁，

//所以也就决定了它肯定是不安全的

p.recycleUnchecked();

p = n;

}

mMessages = null;

}

//分析4、 removeAllFutureMessagesLocked()

//首先判断是否有消息再使用中，如果没有就按照分析3的方法全部回收，

//如果有消息正在使用中，这个使用的消息不做回收，它依然能够正常执行完成，

//而其他的所有的没有正在执行的全部回收

private void removeAllFutureMessagesLocked() {

//Returns milliseconds since boot, not counting time spent in deep sleep.

final long now = SystemClock.uptimeMillis();

Message p = mMessages;

if (p != null) {

if (p.when > now) {

//判断消息队列现在是否正在处理消息，如果没有则直接把所有消息回收

//通过时间来判定的

removeAllMessagesLocked();

} else {

//有正在处理的消息，则处理完成后再退出

Message n;

for (;;) {

n = p.next;

if (n == null) {

return;

}

if (n.when > now) {

break;

}

p = n;

}

p.next = null;

do {

p = n;

n = p.next;

p.recycleUnchecked();

} while (n != null);

}

总结：

所谓的安全与否，关键是对正在使用中的消息如何处理来判断的，如果直接回收消息就是不安全，等待它处理完成就是安全的。

五、总结

本文对HandlerThread做了全部分析，从原理、使用实例，到源码分析，希望对您有帮助。

原文链接：https://blog.csdn.net/haovin/article/details/89787721