Android异步消息处理机制(2)源码解析，android异步
Android异步消息处理机制(2)源码解析，android异步
上一章讲解了Android异步消息处理机制的基本使用，下面将简单地探寻一下异步机制背后的奥妙，源码版本为：API22。
首先，声明一下本文是在我参考了一下各位大神的文章之后才慢慢熟悉的， 若有不足之处，还望各位批评指正！。菜鸟上路，，，，
郭霖博客
鸿洋博客
刘超 深入解析android5.0系统
任玉刚博客
先后顺序按照拼音排序，无关技术本身。
先简单地总结一下Looper，MessageQueue，Message和Handler四者之间的关系：
- Looper和MessageQueue
Looper对象是线程的消息循环处理器，每个线程只能有一个Looper。Looper内部有一个消息队列MessageQueue对象，所有该线程的消息都存放在该队列（按照时间排序）中，Looper不断从MessageQueue中取出消息，然后调用消息对应的Handler进行处理消息。android在启动时为主线程（UI线程）自动创建一个Looper对象，而我们自己创建线程时必须要创建Looper对象（调用Looper.prepare()）。 - Handler（非抽象类）
Handler对象是Message对象的接收者和处理者。用户通过Handler把消息添加到消息队列，同时通过Handler的回调方法hanldeMessage()处理消息。Hanlder在构造时和一个Looper对象关联在一起。Handler和Looper是多对一的关系，多个Handler对象可以和同一个Looper对象建立关系，反之则不行。 - Message
Message是消息的载体，是Parcelable的派生类。
四者涉及到的主要成员变量和方法
Looper类的主要成员变量和方法：
public final class Looper {
// 成员变量
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper;
final MessageQueue mQueue;
final Thread mThread;
// 成员方法
public static void prepare() {...}
private static void prepare(boolean quitAllowed) {...}
public static void prepareMainLooper() {...}
public static Looper getMainLooper() {...}
public static void loop() {...}
public static Looper myLooper() {...}
public static MessageQueue myQueue() {...}
}
MessageQueue类中的主要成员方法：
public final class MessageQueue {
Message next() {...}
boolean enqueueMessage(Message msg, long when){...}
}
Handler类中的主要成员变量和方法：
public class Handler {
//内部接口
public interface Callback {
public boolean handleMessage(Message msg);
}
//处理消息相关方法
public void handleMessage(Message msg) {}
public void dispatchMessage(Message msg) {...}
private static void handleCallback(Message message) {...}
// 构造器相关方法
public Handler() {...}
public Handler(Callback callback) {...}
public Handler(Looper looper) {...}
public Handler(Looper looper, Callback callback) {...}
public Handler(boolean async) {...}
public Handler(Callback callback, boolean async) {...}
public Handler(Looper looper, Callback callback, boolean async) {...}
// 获取Message相关方法
public final Message obtainMessage(){...}
public final Message obtainMessage(int what){...}
public final Message obtainMessage(int what, Object obj){...}
public final Message obtainMessage(int what, int arg1, int arg2){...}
public final Message obtainMessage(int what, int arg1, int arg2, Object obj){...}
// post相关方法
public final boolean post(Runnable r){...}
public final boolean postAtTime(Runnable r, long uptimeMillis){...}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis){...}
public final boolean postDelayed(Runnable r, long delayMillis){...}
public final boolean postAtFrontOfQueue(Runnable r){...}
// send相关方法
public final boolean sendMessage(Message msg){...}
public final boolean sendEmptyMessage(int what){...}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {...}
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {...}
public final boolean sendMessageDelayed(Message msg, long delayMillis){...}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {...}
public final boolean sendMessageAtFrontOfQueue(Message msg) {...}
// 进出消息队列
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {...}
}
Message类中的主要成员变量和方法：
public final class Message implements Parcelable {
// 主要成员变量
public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
// 主要成员方法
public Message() {} // 不建议使用
// 获取Message相关方法
public static Message obtain() {...}
public static Message obtain(Message orig) {...}
public static Message obtain(Handler h) {...}
public static Message obtain(Handler h, Runnable callback) {...}
public static Message obtain(Handler h, int what) {...}
public static Message obtain(Handler h, int what, Object obj) {...}
public static Message obtain(Handler h, int what, int arg1, int arg2) {...}
public static Message obtain(Handler h, int what, int arg1, int arg2, Object obj) {...}
public void setTarget(Handler target) {...}
public void sendToTarget() {...}
public Handler getTarget() {...}
}
下面将以问答的方式解析异步消息处理机制。
问答解析
1. ThreadLocal的作用？
解析：ThreadLocal是Thread Local Variable即线程本地变量的意思，通过把数据放在ThreadLocal中就可以让每个线程创建一个该变量的副本，从而避免并发访问的线程安全问题。这里保存Looper类的实例对象。
2. 为什么在UI线程中实例化Handler并不需要Looper.prepare()，而在子线程中则需要Looper.prepare()？
解析：这是因为在ActivityThread类中的main()方法调用了Looper.prepareMainLooper()，简单代码如下：
public static void main(String[] args) {
...// 前面的省略了
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
可以看到main()方法中调用了Looper.prepareMainLooper()，而Looper.prepareMainLooper()源码为：
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
// 若不存在Looper对象，则从sThreadLocal获取
sMainLooper = myLooper();
}
}
而prepare(boolean)代码如下：
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
到这里我们可以看到main()方法中调用了Looper.prepareMainLooper()，而Looper.prepareMainLooper()又调用了prepare(boolean)。prepare(boolean)方法就会创建一个Looper对象并保存在静态变量sThreadLocal（ThreadLocal类实例）。我们来看一下Looper的构造器：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
该构造器为私有的，且创建了一个消息队列实例，并将当前线程保存下来。
同时在prepare(boolean)可以看到若sThreadLocal已经有一个Looper对象后再创建就会出现异常。这说明了两点：1. 一个线程中只能有一个Looper对象；2. 一个线程中只能最多调用一次prepare相关的方法（prepare()（内部也是调用prepare(boolean)），prepare(boolean)，prepareMainLooper()（UI线程中调用），）。
而我们在子线程中调用的是Looper.prepare()，来看一下这个方法的源码：
public static void prepare() {
prepare(true);
}
可以看到同样也是调用了prepare(boolean)。
3. 实例化Handler系统为我们做了哪些事情？
解析：该问题主要涉及到Handler中以下几个方法：
public Handler() {this(null, false);}
public Handler(Callback callback) {this(callback, false);}
public Handler(Looper looper) {this(looper, null, false);}
public Handler(Looper looper, Callback callback) {this(looper, callback, false);}
public Handler(boolean async) {this(null, async);}
public Handler(Callback callback, boolean async) {
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());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
在上述构造器中可能传递的参数为：
- Looper对象，用于指定Handler将消息发送到的Looper对象。因此在实例化Handler对象之前需要调用
Looper.prepare()方法。 - Callback接口对象，用于处理Handler发送的消息。
- boolean值，是否是异步操作。针对Handler来说这里都是传递的false。
首先，在Handler(Callback callback, boolean async)中我们看到调用了Looper.myLooper()返回Looper对象，若Looper对象为null则会抛出异常。
根据以上构造器，我们能够有多种方式实例化一个handler对象，前五个构造器最终都会调用下面两个构造器。对于Handler(Callback callback, boolean async)这个构造器没有指定Handler的Looper对象，则使用当前线程的Looper对象。同时我们看到传递了Callback接口对象，将其值赋值给了mCallback，我们来看一下相关的源码：
public interface Callback {public boolean handleMessage(Message msg);}
final Callback mCallback;
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
通过上述代码我们可以看到，若传递Callback接口对象的话，在dispatchMessage(Message msg)中将不会执行handleMessage(msg)（当然这之前先判断msg.callback是否为空，这个问题之后再讲），而是调用mCallback.handleMessage(msg)，而该方法就是我们传递的Callback接口对象实现的方法。因此，我们也可以通过这种方式处理消息。若不传递Callback接口对象的话，那么就会执行handleMessage(msg)，我们可以通过继承Handler实现该方法处理消息。
4. 实例化Handler对象之后，为什么要调用Looper.loop()?
为了解决这个问题我们先看一下loop()源码：
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
.....
for (;;) {
// 取一条消息，没有就会阻塞
Message msg = queue.next(); // might block
if (msg == null) {
// msg等于null，就会退出
return;
}
.....
msg.target.dispatchMessage(msg);
.....
msg.recycleUnchecked(); // 保证消息循环利用。
}
}
在loop()中首先获取Looper对象me，然后根据该对象获取对应的消息队列queue，下面就进入一个for(;;)死循环不断地从queue取消息，若没有则next()（该方法比较复杂，我没怎么看懂，，，）方法就会阻塞。
若消息为空的话就会退出loop()；下面有一句：msg.target.dispatchMessage(msg);，这个消息msg的target属性就是Handler对象，那么这个消息就是由该Handler来处理的。我们可以通过Message的重载方法obtainXXX()和setTarget()设置Handler对象。
通过loop()，就能实现不断处理发送过来的消息。
我们再来看一下Message的sendToTarget():
public void sendToTarget() {
target.sendMessage(this);
}
可以看到通过这个方法发送消息和通过Handler发送消息一样。
5. Handler中的sendMessage()是如何将消息发送到消息队列中的，而消息队列又是如何管理消息的？
首先，看一下，send相关方法：
// send相关方法
public final boolean sendMessage(Message msg){...} // 发送的消息希望及时处理，但不插队
public final boolean sendEmptyMessage(int what){...} // 只发送带有what属性的消息，希望消息及时处理即可
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {...} // 希望延迟处理
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {...} // 希望消息在指定的时间处理
public final boolean sendMessageDelayed(Message msg, long delayMillis){...} // 希望延迟处理
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {...} // 希望消息在指定的时间处理
public final boolean sendMessageAtFrontOfQueue(Message msg) {...} // 消息插队，希望马上处理
带有Empty的方法甚至发送的不是消息，只是what！！注意一下。
上面的send方法，除了sendMessageAtFrontOfQueue(Message)，都会调用sendMessageAtTime(Message,long)。而这两个方法中则会返回消息队列的enqueueMessage(Message,long)的方法，该方法就是将消息按照时间顺序插入到消息队列中。其实，消息队列是用链表实现的，排序方式是按照时间进行排列的。enqueueMessage(Message,long)源码如下：
boolean enqueueMessage(Message msg, long when) {
....
synchronized (this) {
....
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
....
}
return true;
}
可以看到首先通过if判断插入的消息的时间是否最小，若是的话直接插入到链表头部，否则进入for(;;)依次遍历链表直到时间小于链表值，然后再插入。消息队列以mMessages为表头进行保存。
以上方法就通过Handler的send方法将消息插入到消息队列中。此时还是在同一个线程中。
6. 线程之间是如何转换的？
通过上述两步实现了A线程和B线程之间的通信。
7. 创建消息的方式
创建消息的方式有很多种，我们来对比一下：
- Handler的
obtainMessage()系列； - Message的静态方法
obtain()系列； - 使用构造器创建。
Handler中的方法实际上都是调用Message的静态方法obtain()系列，而obtain()系列最终都会调用obtain()方法。我们来看一下它的源码：
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
可以看到当前存在多余的消息时，则我们可以直接使用，而不是再创建一个新的消息，循环使用消息减少资源浪费。能够循环使用消息的原因是：每当处理完一个消息时都会调用消息的recycleUnchecked()该方法就会将使用过的消息进行保存。源码如下：
void recycleUnchecked() {
... // 清空消息内容
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
sPool是静态成员变量，保存链表的头，当处理过一个消息时，（消息池大小小于给定值50时）该消息就会采用头插法插入链表中。
8. Handler的post方法是干什么用的？
我们首先回过头来看一下dispatchMessage()方法，其中有一个判断：
if (msg.callback != null) {
handleCallback(msg);
}
只有当msg.callback为空时才会执行下面的。消息的callback属性是Runnable变量，那么该属性是在哪里赋值的呢？我们发现在post系列中都会调用一个方法getPostMessage():
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到该方法可以对callback属性进行赋值，也就是说，通过post方法发送消息的话和send一样可以完成处理消息（实际上在post中也是调用send方法），只不过不在handleMessage()中处理消息，而是在handleCallback()中处理消息。该方法的源码会让我们大吃一惊的：
private static void handleCallback(Message message) {
message.callback.run();
}
直接调用了Runnable对象的run()方法，这样一来就不是创建新线程，而是直接调用。
当然也可以在消息的obtain()中设置callback属性。
post方法和send方法的区别
post方法在内部会调用send方法，并且post方法发送的是带有处理方法的消息，而send方法发送的是不带有处理方法的消息。前者消息在自己携带的方法中处理，后者则只能通过handleMessage()处理
版权声明：本文为博主原创文章，未经博主允许不得转载。
用户评论