Android之handler异步消息处理机制解析
- 作者: 锐63094547
- 来源: 51数据库
- 2021-09-04
Android UI线程是不安全的，如果尝试在子线程中更新ui，程序就会奔溃，所以我们经常会使用Handler，AsyncTask,HandlerThread,IntentService 来进行处理以便达到在主线程中更新ui的操作，这种机制被称为异步消息处理机制
1:创建Handler对象
我们在子线程以及主线程中各创建一个Handler
Handler handler1;
Handler handler2;
handler1 = new Handler();
Log.i("handler1", "onCreate: " + Thread.currentThread().getName());// main
new Thread(new Runnable() {
@Override
public void run() {
Log.i("handler2", "onCreate: " + Thread.currentThread().getName());// thread
handler2 = new Handler();
}
}).start();
我们发现在子线程中创建handler报运行时错误，说没有调用Looper.prepare()不能在子线程中创建Handler
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:200)
at android.os.Handler.<init>(Handler.java:114)
at com.adnonstop.beautymall.MainActivity$2.run(MainActivity.java:53)
at java.lang.Thread.run(Thread.java:818)
public Handler() {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
// 获取looper
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
// 获取MessageQueue
mQueue = mLooper.mQueue;
mCallback = null;
}
可以看到，初始化handler时调用了Looper.myLooper()方法获取了一个Looper对象，如果Looper对象为空，则会抛出一个运行时异常，提示的错误正是 Can’t create handler inside thread that has not called Looper.prepare()！那什么时候Looper对象才可能为空呢？这就要看看Looper.myLooper()中的代码了，如下所示：
public static final Looper myLooper() {
return (Looper)sThreadLocal.get();
}
这个方法非常简单，就是从sThreadLocal对象中取出Looper。如果sThreadLocal中有Looper存在就返回Looper，如果没有Looper存在自然就返回空了。因此你可以想象得到是在哪里给sThreadLocal设置Looper了吧，当然是Looper.prepare()方法！我们来看下它的源码：
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
首先判断sThreadLocal中是否已经存在Looper了，如果还没有则创建一个新的Looper设置进去。这样也就完全解释了为什么我们要先调用Looper.prepare()方法，才能创建Handler对象。同时也可以看出每个线程中最多只会有一个Looper对象。
子线程中的我们弄明白了，那为什么主线程中的不需要初始化looper呢，这其实时由于在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。查看ActivityThread中的main()方法，代码如下所示：
public static void main(String[] args) {
...
//内部其实调用的时Looper.prepare（）
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
if (false) {
Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();// 从消息队列去消息出来，给handler.handleMessage处理
throw new RuntimeException("Main thread loop unexpectedly exited");
}
这样基本就将Handler的创建过程完全搞明白了，总结一下就是在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare()才能创建Handler对象。
初始化之后我们要创建消息Message，然后再将消息发送出去
Message创建以及源码分析
Handler中提供了很多个发送消息的方法，其中除了sendMessageAtFrontOfQueue()方法之外，其它的发送消息方法最终都会辗转调用到sendMessageAtTime()方法中，
public boolean sendMessageAtTime(Message msg, long uptimeMillis){
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
//msg.target
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
sendMessageAtTime()方法接收两个参数：
msg参数就是我们发送的Message对象，
uptimeMillis参数则表示发送消息的时间，它的值等于自系统开机到当前时间的毫秒数再加上延迟时间
sendMessageAtTime方法里面的两个参数全部交由MessageQueue 来处理，并且判断queue是否为null,如果为null的话则报 没有queue无法发送消息的错误，那这个时什么时候创建的呢，细心的会发现在获取Looper之后会调用mQueue = mLooper.mQueue;来获取的，简单的来说它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。
final boolean enqueueMessage(Message msg, long when) {
if (msg.when != 0) {
throw new AndroidRuntimeException(msg + " This message is already in use.");
}
if (msg.target == null && !mQuitAllowed) {
throw new RuntimeException("Main thread not allowed to quit");
}
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
return false;
} else if (msg.target == null) {
mQuiting = true;
}
msg.when = when;
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
this.notify();
} else {
Message prev = null;
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
msg.next = prev.next;
prev.next = msg;
this.notify();
}
}
return true;
}
MessageQueue单链表来进行保存message，入队其实就是将所有的消息按时间uptimeMillis来进行排序。具体的操作方法就根据时间的顺序调用msg.next，从而为每一个消息指定它的下一个消息是什么。
现在入队操作我们就已经看明白了，那出队操作是在哪里进行的呢?这个就需要看一看Looper.loop()方法的源码了
public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
while (true) {
Message msg = queue.next(); // might block
if (msg != null) {
if (msg.target == null) {
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
msg.target.dispatchMessage(msg);
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
msg.recycle();
}
}
}
可以看到，该方法进入了一个死循环，然后不断地调用的MessageQueue的next()方法取出对列中的消息。它的简单逻辑就是如果当前MessageQueue中存在mMessages(即待处理消息)，就将这个消息出队，然后让下一条消息成为mMessages，否则就进入一个阻塞状态，一直等到有新的消息入队。
每当有一个消息出队，就将它传递到msg.target的dispatchMessage()方法中，那这里msg.target又是什么呢？其实就是Handler，sendMessageAtTime方法里面给每个消息标注了msg.target = this this指代的就是当前的handler
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
// callback 其实是一个Runnable
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
如果mCallback不为空，则调用mCallback的handleMessage()方法，否则直接调用Handler的handleMessage()方法，并将消息对象作为参数传递过去。
一个最标准的异步消息处理线程的写法应该是这样
class handlerThread extends Thread {
private Handler handler;
@Override
public void run() {
Looper.prepare();
handler = new Handler() {
@SuppressLint("HandlerLeak")
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
Looper.loop();
}
}
除了发送消息之外，我们还有几种方式来在主线程中更新ui
- Handler的post()方法
- View的post()方法
- Activity的runOnUiThread()方法
内部原理其实就是将任务runnable赋值给message中的callback
Message中的变量 Runnable callback;
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
