Android-异步消息处理机制2以及HandlerThread的介绍
之间在上篇文章中介绍过了Android的异步消息处理机制，这里再进行一些补充，说下多线程中的消息处理以及HandlerThread的介绍，如果你还不是很了解handler的机制，可以先看看上篇文章Android-异步消息处理机制(Handler,Looper,Message)
在上篇文章中开头说过我们平时在子线程中去更新ui的操作一般是通过handler来发送message的方式进行处理，但是其实还有几种更简便的方式来进行ui的操作：
Handler的post()方法
View的post()方法
Activity的runOnUiThread()方法
代码如下：
new Thread(new Runnable() {
@Override
public void run() {
//1.普遍的方式
//发送消息
Message msg = Message.obtain();
msg.what = 111;
Bundle bundle=new Bundle();
bundle.putString("huan","hello");
msg.setData(bundle);
mHandler.sendMessage(msg);
//2.post的方式
mHandler.post(new Runnable() {
@Override
public void run() {
//可以直接在这儿进行ui的更新
}
});
//3.view.post方式
mTvHelloWord.post(new Runnable() {
@Override
public void run() {
//可以直接在这儿进行ui的更新
}
});
//4.runOnUiThread方式
runOnUiThread(new Runnable() {
@Override
public void run() {
//可以直接在这儿进行ui的更新
}
});
}
}).start();
从代码中可以明显的看出，后面三种方式要简便的多，而且是一种比一种简便，都不需要通过Message 的创建去封装消息；第二种方式还需要使用handler作为载体，第三种方式需要使用view来作为载体，第四种方式直接用runOnUiThread方法即可。为什么可以这样写也能达到目的？进去看看知道了。
1.先说下handler post方式的使用，我们不需要再去创建一个Message对象，把数据封装在Message中，然后在handler的callback中进行ui的操作，而是直接可以在run中进行操作。进入到post方法中：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
所噶，原来还是通过sendMessageDelayed(Message msg, long delayMillis)这个方法来进行操作的，并且将我们传入的runnable对象通过getPostMessage方法转为了一个Message;那我们再进入getPostMessage方法中一看应该就能明了了：
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
创建了一个消息，并把这个消息的callback设置为了我们传入的runnnable；还记得我们上篇文章说过的在Looper进行消息循环的时候，取出来的消息将会通过dispatchMessage这个方法进行处理：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
首先判断的就是msg的callback是否为null，如果不为null就会执行handleCallback(msg)：
private static void handleCallback(Message message) {
message.callback.run();
}
直接调用了msg的runnable对象也就是我们一开始传给msg的runnable对象，瞬间就很清晰明了了。
2.view.post方式
view.post方法和handler的写法几乎一致，看看它的里面实现了什么：
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
return attachInfo.mHandler.post(action);
}
// Assume that post will succeed later
ViewRootImpl.getRunQueue().post(action);
return true;
}
原来就是通过attachInfo获取到了handler，然后执行handler的post方法而已。换汤不换药。
3.runOnUiThread方式
这个方法其实是属于Activity的方法，也就是只能在Activity中才能使用，代码如下：
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}
首先判断了当前线程是否是ui线程，如果不是，就用handler post的方式；否则就直接run。
看完了这三种方式的源代码发现其实底层都是通过handler发送message 的方式来进行消息的处理；所以平时我们在开发android的过程中如果明白了handler的消息机制；那么这几种方法你都是可以任意使用的，哪种方便用哪种。
Looper和handler的同步关系：
接下来说下在多线程中handler和looper的处理；先模拟一个运行场景：
- 主线程中开启一个线程1；线程1开启的时候会启动线程2；
- 线程2启动后获取到Looper,并执行looper.loop ；
- 将线程2中的looper对象赋值给线程1中的looper对象
- 通过线程1中的looper对象，在主线程中创建一个hanlder对象；
- 通过handler发送一个msg，请问这个msg是在哪个线程中收到这个消息并进行处理；
看下代码：
线程1:
public class LooperThread1 extends Thread {
/**
* 定义一个public的成员变量Looper
*/
public Looper myLooper = null;
/**
* 初始化Looper,开启消息循环
*/
public void initLooper(){
Looper.prepare();
myLooper = Looper.myLooper();
Looper.loop();
}
@Override
public void run() {
//开启另一个线程
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
initLooper();
}
});
thread2.start();
Log.e("test", "thread2 id:" + thread2.getId());
}
}
主线程：
//主线程id
Log.e("test", "Main Thread:" + Thread.currentThread().getId());
LooperThread1 myLooperThread1=new LooperThread1();
myLooperThread1.start();
//线程1 id
Log.e("test","thread1 id:"+myLooperThread1.getId());
Looper looper=myLooperThread1.myLooper;
android.os.Handler handler=new android.os.Handler(looper, new android.os.Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
if(msg.what==111){
Log.e("test","handleMessage :111");
//当前线程
Log.e("test","current Thread:"+Thread.currentThread().getId());
}
return false;
}
});
handler.sendEmptyMessage(111);
最开始我是为了验证这个handler发送的消息最终是在哪个线程中接收，但是其实这段代码是有问题的，一运行会报java.lang.NullPointerException。具体的原因就在与：创建handler的时候，传入的这个looper为空。我们在获取线程1的looper对象时，这个时候可能线程2还没有执行完获取到looper；所以问题就出在这儿；不过我们可以加一个同步锁的方式来解决，但是如果每次写你都去这样操作那不是很麻烦？ 所以，android给我们推荐了一个 HandlerThread线程来解决多线程中handler和looper之间同步的问题。
HandlerThread中的源码：
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
/**
* This method returns the Looper associated with this thread. If this thread not been started
* or for any reason is isAlive() returns false, this method will return null. If this thread
* has been started, this method will block until the looper has been initialized.
* @return The 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 {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
其实就是加上了一个同步锁的机制，并且在run中自动帮我们创建好了looper；那么我们接下来再来验证下消息的处理是在哪个线程：
//主线程id
Log.e("test", "Main Thread:" + Thread.currentThread().getId());
HandlerThread handlerThread = new HandlerThread("handler_thread");
handlerThread.start();
Log.e("test", "HandlerThread:" + handlerThread.getId());
android.os.Handler handler=new android.os.Handler(handlerThread.getLooper(), new android.os.Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
if(msg.what==222){
Log.e("test","receiveMsh thread id:"+Thread.currentThread().getId());
}
return false;
}
});
handler.sendEmptyMessage(222);
打印log为：
得出结论：handler发送的Message处理，不会依赖与创建handler时所在的线程，依赖与传入的looper对象所在的线程，looper所在的线程来执行msg的处理；
到这里，通过两篇文章总算是将handler这个知识点大部分总结完了；接下来会继续总结其他技术点的知识；如果文章有疏漏，错误，望君能给我评论指出。谢谢！
