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;
}
![android中Bitmap用法(显示,保存,缩放,旋转)实例分析](http://www.51sjk.com/Upload/Articles/1/0/308/308239_20221009142638355_1.png)
![android 仿微信聊天气泡效果实现思路](http://www.51sjk.com/Upload/Articles/1/0/296/296180_20221009150030724_1.png)
![Android的尺度,drawable-xxxxxxx](http://www.51sjk.com/Upload/Articles/1/0/260/260488_20210701003840119.png)
![Codeforces Round #656 (Div. 3) (C、D题)](http://www.51sjk.com/Upload/ArticleCategories/1/0/0/6_20210816103305180_1.jpg)
![Android之handler异步消息处理机制解析](http://www.51sjk.com/Upload/Articles/1/0/260/260443_20210701003811842.png)
![GridView中图片显示出现上下间距过大,左右图片显示类似瀑布流的问题](http://www.51sjk.com/Upload/Articles/1/0/260/260430_20210701003800067.png)
![AsyncTask的简单使用](http://www.51sjk.com/Upload/Articles/1/0/260/260410_20210701003747598.png)
![两个简单Fragment之间的通信(三种方式)](http://www.51sjk.com/Upload/Articles/1/0/260/260395_20210701003731723.png)
![uboot修改设置boot参数命令](http://www.51sjk.com/Upload/ArticleCategories/1/0/0/6_20210816103305180_1.jpg)
![android中实现从相册中一次性获取多张图片与拍照,并将选中的图片显示出来](http://www.51sjk.com/Upload/ArticleCategories/1/0/0/6_20210816103305180_1.jpg)