为什么要有Android消息机制
我们经常需要在子线程进行耗时的I/O操作,例如读取文件或者是访问网络等,当耗时操作完成以后需要在UI上做些改变,由于android开发规范的限制,我们并不能在子线程中访问UI控件,否则就会触发程序异常,这个时候通过Handler就可以将更新UI的操作切换到主线程执行。
android规定访问UI只能在主线程中进行,如果在子线程中访问UI,那么程序就会抛出异常。ViewRootImpImpI对UI操作做了验证,这个验证工作是由ViewRootImpI的checkThread方法来完成的,如下所示。
void checkThread(){
if(mThread != Thread.currentThread()){
throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can touch its views.");
}
}
再延伸一下,为什么系统不允许在子线程中访问UI呢?这是因为Android的UI控件不是线程安全的,如果在多线程中访问UI控件则会导致不可预期的状态。那为什么不对UI控件访问加锁呢?缺点有两个:首先加锁会让UI控件的访问的逻辑变的复杂;其次,锁机制会降低UI的访问效率。那我们不用线程来操作不就行了吗?但这是不可能的,因为Android的主线程不能执行耗时操作,否则会出现ANR(不知道ANR的自己去百度吧)。所以,从各方面来说,Android消息机制是为了解决在子线程中无法访问UI的矛盾。
Android消息机制概述
Android消息机制相关概念
- 主线程(UI线程)
- 定义:当程序第一次启动时,Android会同时启动一条主线程(Main Thread)
- 作用:主线程主要负责处理与UI相关的事件
- Message(消息)
- 定义:Handler接收和处理的消息对象(Bean对象)
- 作用:通信时相关信息的存放和传递
- ThreadLocal
- 定义:线程内部的数据存储类
- 作用:负责存储和获取本线程的Looper
- Message Queue(消息队列)
- 定义:采用单链表的数据结构来存储消息列表
- 作用:用来存放通过Handler发过来的Message,按照先进先出执行
- Handler(处理者)
- 定义:Message的主要处理者
- 作用:负责发送Message到消息队列&处理Looper分派过来的Message
- Looper(循环器)
- 定义:扮演Message Queue和Handler之间桥梁的角色
- 作用:
消息循环:循环取出Message Queue的Message
消息派发:将取出的Message交付给相应的Handler
他们之间的联系
Looper中存放有MessageQueuen,MessageQueuen中又有很多Message,当我们的Handler发送消息的时候,会获取当前的Looper,并在当前的Looper的MessageQueuen当中存放我们发送的消息,而我们的MessageQueuen也会在Looper的带动下,一直循环的读取Message信息,并将Message信息发送给Handler,并执行HandlerMessage()方法。
Looper源码分析
Looper在消息机制里扮演着消息循环的角色,它不停的从消息队列里查看是否有新消息,如果有,则立即处理新消息,没有则一直阻塞在那里。当需要为一个线程创建一个Looper的时候,需要调用Looper的两个静态方法就可以给这个线程创建一个Looper对象了,这两个方法是Looper.prepare();和Looper.loop()。
Looper在子线程的创建过程
new Thread(){
@override
public void run(){
//创建消息循环Looper
Looper.prepare();
Handler handler = new Handler();
//执行消息循环Looper
Looper.loop();
}
}.start();
看下Looper.prepare()方法
private static void prepare(boolean quitAllowed) {
//判断sThreadLocal是否为null,否则抛出异常
//即Looper.prepare()方法不能被调用两次
//也就是说,一个线程中只能对应一个Looper实例
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//初始化Looper对象设置到ThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
看下Looper的构造方法
private Looper(boolean quitAllowed) {
//创建了一个MessageQueue(消息队列)
//这说明,当创建一个Looper实例时,会自动创建一个与之配对的MessageQueue(消息队列)
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
整个Looper的初始化准备工作就完了,这里做了哪几件事:
- Looper的创建会关联一个MessageQueen的创建
- Looper对象只能被创建一次
- Looper对象创建后被存放在sThreadLocal中
再延伸一下Looper在主线程中的创建
public static void main(String[] args) {
...
Process.setArgV0("<pre-initialized>");
//1. 创建消息循环Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
//2. 执行消息循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
Looper在主线程中调用Looper.prepareMainLooper()方法,其本质也是通过prepare方法来实现的。
public static void prepareMainLooper() {
//在这里会调用prepare(boolean quitAllowed)方法
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
下面看下Looper.loop()方法
public static void loop() {
//myLooper()方法作用是返回sThreadLocal存储的Looper实例,如果me为null,loop()则抛出异常
//也就是说loop方法的执行必须在prepare方法之后运行
//也就是说,消息循环必须要先在线程当中创建Looper实例
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//获取looper实例中的mQueue(消息队列)
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
//进入消息循环
for (;;) {
//next()方法用于取出消息队列里的消息
Message msg = queue.next();
if (msg == null) {
return;
}
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
//消息派发:把消息派发给msg的target属性,然后用dispatchMessage方法去处理
//Msg的target其实就是handler对象,下面会继续分析
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
//释放消息占据的资源
msg.recycleUnchecked();
}
}
说明:首先是获取到当前线程的Looper对象和绑定到Looper对象的消息队列,接着就是一个死循环,唯一跳出循环的方式就是MessageQueue的next方法返回了null(即调用quit或者quitSafely方法标记为退出状态,当消息队列表标记为退出状态时,next方法就会返回null);当有消息时,则通过Handler(msg.target是一个Handler对象)的dispatchMessage方法来处理这个消息,也就到了Handler里面去执行了,这样就成功地将代码逻辑切换到指定的线程中去了。
整个Looper的循环过程就完了,这里做了哪几件事:
- 取出Looper和MessageQueen
- 进入消息循环,有消息则分发出去
- 消息资源的回收
Looper的退出
Looper提供了两个方法可以退出一个Looper:
- quit():quit会直接退出Looper
- quitSafety():quitSafety只是设定一个退出标记使MessageQueue的next方法返回null,从而退出looper方法,此方法会把消息队列中的已有消息处理完毕后退出Looper
注:
1.当Looper退出后,通过Handler发送的消息会失败,这个时候Handler的send方法会返回false;
2. 在子线程中,如果手动为其创建了Looper,那么在所有消息处理完成之后应该调用quit方法来终止消息循环,否则这个子线程就会一直处于等待状态(MessageQueue的next方法是个阻塞操作,当没有消息时,next方法会一直阻塞在那,这也导致looper方法一直阻塞在那),而如果退出Looper以后,这个线程就会立刻终止,因此建议不需要的时候终止Looper。
MessageQueue源码分析
消息队列在android中指的是MessageQueue,MessageQueue主要包含两个操作:插入(插入一条消息到消息队列中)和读取(从消息队列中取出一条消息,并把它从消息队列中移除),两个操作对应的方法为enqueue和next。MessageQueue通过一个单链表的数据结构来维护消息队列,单链表在插入和删除上比较有优势。
enqueueMessage方法
由于Handler使用Post()方法将Message传递到MessageQueen中,在MessageQueen中会使用enqueueMessage()方法存储Message,其实现的方式是通过单链表的数据结构来存储消息列表。
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;
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
这里做了哪几件事:
- 首先判断消息队列里有没有消息,没有的话则将当前插入的消息作为队头,并且这时消息队列如果处于等待状态的话则将其唤醒
- 若是在中间插入,则根据Message创建的时间进行插入
next方法
存消息是Handler存进来的,那么取消息就应该是Looper取了,从Looper的源码可以看出,消息就是在Looper中取出的,其实现是用MessageQueen里面的next()方法。
Message next() {
......
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// nativePollOnce方法在native层,若是nextPollTimeoutMillis为-1,这时候消息队列处于等待状态。
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
//按照我们设置的时间取出消息
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// 如果消息队列中没有消息,将nextPollTimeoutMillis设为-1,下次循环消息队列则处于等待状态
nextPollTimeoutMillis = -1;
}
//退出消息队列,返回null,这时候Looper中的消息循环也会终止。
if (mQuitting) {
dispose();
return null;
}
......
}
.....
}
}
Message
其实这个Message就是用来存储Message中各种信息的Bean对象,从源码中可以其属性,这里例举我们常用的几个。
public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
int flags;
long when;
Bundle data;
Handler target;
Runnable callback;
Handler源码分析
Handler的工作主要包含消息的发送和接收过程,消息的发送可以通过post一系列方法以及send的一系列方法来实现的(其实post的一系列方法最终是通过send一系列方法实现),消息的处理通过调用dispatchMessage方法实现。
Handler的创建
Handler的创建会关联一个Looper对象,而Looper对象是关联着MessageQueen对象,所以在Handler创建时候,取出Looper和MessageQueen。
public Handler(Callback callback, boolean async) {
...
//取出Looper
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//取出Looper中的MessageQueen
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
前面我们也说过了Looper是存放在ThreadLocal里面的,可以看到下面的源码就知道了
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
整个创建的过程就完了,这里做了哪几件事:
- 取出Looper
- 取出Looper中的MessageQueen
Handler发送消息
方式一、sendMessage(Message msg)
//从这里开始
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
//往下追踪
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
//往下追踪
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
//往下追踪
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
//直接获取MessageQueue
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
//调用sendMessage方法其实最后是调用了enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//为msg.target赋值为this,也就是把当前的handler作为msg的target属性
//如果大家还记得Looper的loop()方法会取出每个msg然后执行msg.target.dispatchMessage(msg)去处理消息,其实就是派发给相应的Handler
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//最终调用queue的enqueueMessage的方法,也就是说handler发出的消息,最终会保存到消息队列中去
return queue.enqueueMessage(msg, uptimeMillis);
}
方式二、psot(Runnable r)
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
其实post()方法最终也会保存到消息队列中去,和上面不同的是它传进来的是一个Runnable对象,执行了getPostMessage()方法,我们往下追踪
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
Handler消息处理
dispatchMessage()方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
//1. post()方法的处理方法
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//2. sendMessage()方法的处理方法
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
public void handleMessage(Message msg) {
}
1.首先就是判断Message的callback是否为null,如果不为null,则通过handleCallback方法调用callback的run方法,callback其实是一个Runnable的对象,实际上是通过Handler的post方法所传递的。
2.如果Message的callback为null,则再判断mCallback是否为null,如果不为null,则调用mCallback的handleMessage方法来处理,mCallback是一个接口可以通过Handler handler = new Handler(new CallBack)实现。
3.如果都为null,最后通过handler的handleMessage方法来处理。
总结:Android通信机制中Message、Handler、MessageQueen、Looper的之间的关系
首先,是这个MessageQueen,MessageQueen是一个消息队列,它可以存储Handler发送过来的消息,其内部提供了进队和出队的方法来管理这个消息队列,其出队和进队的原理是采用单链表的数据结构进行插入和删除的,即enqueueMessage()方法和next()方法。这里提到的Message,其实就是一个Bean对象,里面的属性用来记录Message的各种信息。
然后,是这个Looper,Looper是一个循环器,它可以循环的取出MessageQueen中的Message,其内部提供了Looper的初始化和循环出去Message的方法,即prepare()方法和loop()方法。在prepare()方法中,Looper会关联一个MessageQueen,而且将Looper存进一个ThreadLocal中,在loop()方法中,通过ThreadLocal取出Looper,使用MessageQueen的next()方法取出Message后,判断Message是否为空,如果是则Looper阻塞,如果不是,则通过dispatchMessage()方法分发该Message到Handler中,而Handler执行handlerMessage()方法,由于handlerMessage()方法是个空方法,这也是为什么需要在Handler中重写handlerMessage()方法的原因。这里要注意的是Looper只能在一个线程中只能存在一个。这里提到的ThreadLocal,其实就是一个对象,用来在不同线程中存放对应线程的Looper。
最后,是这个Handler,Handler是Looper和MessageQueen的桥梁,Handler内部提供了发送Message的一系列方法,最终会通过MessageQueen的enqueueMessage()方法将Message存进MessageQueen中。我们平时可以直接在主线程中使用Handler,那是因为在应用程序启动时,在入口的main方法中已经默认为我们创建好了Looper。