Android 进阶14:源码解读 Android 消息机制( Message MessageQueue Handler Looper)
- 不要心急,一点一点的进步才是最靠谱的。
读完本文你将了解:
- 前言
- Message
- 如何获取一个消息
- Message.obtain()
- 消息的回收利用
- MessageQueue
- MessageQueue 的属性
- 何时初始化
- 消息入队的过程
- 消息出队的过程
- Looper
- 线程相关 ThreadLocal
- 无限循环调度
- 如何停止
- Handler
- Handler 的属性
- 发送消息
- 处理消息
- 移除消息
- 主线程消息机制
- 总结
- Thanks
前言
本来我以为自己很了解 Handler,在印象中 Android 消息机制无非就是:
- Handler 给 MessageQueue 添加消息
- 然后 Looper 无限循环读取消息
- 再调用 Handler 处理消息
整体的流程有了,但是一直没有结合源码捋一捋。
直到有一天在使用 Handler 发送消息时遇到了一个问题:
This message is already in use.
这才去翻了翻源码,今天总结一下。
Android 消息机制主要涉及 4 个类:
Message
MessageQueue
Handler
Looper
我们依次结合源码分析一下。
Message
“消息机制”,其中要传递的就是 Message,官方对它的描述是:
包含任意类型的对象和描述信息,可以被发送给 Handler。
Message
的主要属性如下:
//用来标识一个消息,接收消息方可以根据它知道这个消息是做什么的public int what;//如果你的消息要传递的数据是整型的,可以直接使用 arg1 和 arg2,而不需要使用构造一个 Bundlepublic int arg1;public int arg2;//一个任意类型的对象,在使用 Messenger 跨进程传递消息时,通常使用它传递给接收者//在其他场景下我们一般使用 setData() 方法public Object obj;//负责回复消息的 Messenger,有的场景下(比如接受者、发送者模型)需要使用它public Messenger replyTo;//当前消息的标志,只在被 Messenger 传递消息时使用,其他情况下都是 -1public int sendingUid = -1;//标识当前消息是否在被使用//当一个消息入队时这个标志会被改变,在被重新获取后重置//当一个消息已经在被使用时,二次入队或者回收会报错(这就是我前言中提到的错误原因)/*package*/static final int FLAG_IN_USE = 1 << 0;//标识当前 消息是否是异步的/*package*/static final int FLAG_ASYNCHRONOUS = 1 << 1;//在 copyFrom 方法中要清除的标志/*package*/static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;/*package*/int flags;/*package*/long when;//很关键的数据部分/*package*/Bundle data;//发送和处理消息关联的 Handler/*package*/Handler target;//消息的回调/*package*/Runnable callback;//在有些场景下还会以链表的形式关联后一个消息/*package*/Message next;//消息池private static final Object sPoolSync = new Object();private static Message sPool; //回收消息链表private static int sPoolSize = 0;private static final int MAX_POOL_SIZE = 50;private static boolean gCheckRecycle = true;
Pasted from: http://book2s.com/java/src/package/android/os/message.html#a940ebe121994bfb7f9629bca79beab6
可以看到,Message 中比较关键的属性有:
- 标识干什么的 what
- 两个简易的整型数据存储对象 arg1 arg2
- 存储复杂点的对象 Bundle
- 跨进程通信绑定数据的 object
- 与之关联的 Handler
- 还有一些标志位,和消息池什么的
如何获取一个消息
消息机制最开始肯定需要构建一个消息。
虽然 Message 的构造函数是 public
的,但是官方还是建议我们使用以下 2 种方式获取一个 Message 对象:
Message.obtain()
Handler.obtainMessage()
原因是这两个方法会从一个消息回收池里获取消息,而不是新建一个,这样可以节省内存。
Handler.obtainMessage()
也是调用的 Message.obtain()
:
public final Message obtainMessage() {return Message.obtain(this);}
去看一下 Message.obtain()
源码。
Message.obtain()
Message.obtain()
有 7 个重载方法,基本就是在获取一个 Message 对象的同时直接赋值:
我们选最复杂的一个看下源码:
public static Message obtain(Handler h, int what, int arg1, int arg2,Object obj) {Message m = obtain();m.target = h;m.what = what;m.arg1 = arg1;m.arg2 = arg2;m.obj = obj;return m;}
Pasted from: http://book2s.com/java/src/package/android/os/message.html#50de1a696587dcd5ae3c91eb63985af2
的确就是在 obtainI()
的基础上加了一些赋值。
Message.obtain()
源码如下:
public static Message obtain() {synchronized (sPoolSync) {if (sPool != null) {Message m = sPool;sPool = m.next;m.next = null;m.flags = 0; // 获取一个复用的消息时,会重置标志位,之前它是 FLAG_IN_USEsPoolSize--;return m;}}return new Message();}
Pasted from: http://book2s.com/java/src/package/android/os/message.html#62dadbbac34056e7ad4fad36d757d6ef
可以看到,这个方法会获取前面提到的 private static Message sPool;
,如果 sPool
存在就从复用消息链表头部取一个消息,然后重置它的标志位;如果不存在复用消息链表就新建一个消息。
那什么时候往消息池中添加消息呢?
消息的回收利用
消息的回收在 Message.recyclerUnchecked()
方法:
void recycleUnchecked() {flags = FLAG_IN_USE; //当前消息被回收时,会标志为 FLAG_IN_USEwhat = 0;arg1 = 0;arg2 = 0;obj = null;replyTo = null;sendingUid = -1;when = 0;target = null;callback = null;data = null;synchronized (sPoolSync) {if (sPoolSize < MAX_POOL_SIZE) {next = sPool;sPool = this;sPoolSize++;}}}
可以看到 recycleUnchecked
方法将当前 Message 标志为 FLAG_IN_USE,这样如果这个方法在被入队,就会报错。此外它还清除了其他数据,然后把这个消息加入了回收消息的链表中。
那 recycleUnchecked()
什么时候会被调用呢?
在 MessageQueue
和 Looper
中都有。
MessageQueue.removeMessages()
方法:
void removeMessages(Handler h, int what, Object object) {if (h == null) {return;}synchronized (this) {Message p = mMessages;// Remove all messages at front.while (p != null && p.target == h && p.what == what&& (object == null || p.obj == object)) {Message n = p.next;mMessages = n;p.recycleUnchecked(); //这里调用了p = n;}// Remove all messages after front.while (p != null) {Message n = p.next;if (n != null) {if (n.target == h && n.what == what&& (object == null || n.obj == object)) {Message nn = n.next;n.recycleUnchecked(); //这里也调用了p.next = nn;continue;}}p = n;}}}
Pasted from: http://book2s.com/java/src/package/android/os/messagequeue.html#0dbba2b975383e8b440199e5d69c73de
Looper.loop()
方法:
public static void loop() {//...for (;;) {Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;}//...msg.recycleUnchecked();}}
Pasted from: http://book2s.com/java/src/package/android/os/looper.html
至此我们可以看到,一个消息在被 Looper 处理时或者移出队列时会被标识为 FLAG_IN_USE
,然后会被加入回收的消息链表,这样我们调用 Message.obtain()
方法时就可以从回收的消息池中获取一个旧的消息,从而节约成本。
MessageQueue
MessageQueue
管理着一个 Message
的列表,Handlers
为它添加消息,Looper
从中取消息。
MessageQueue
的属性
// 队列是否可以退出private final boolean mQuitAllowed;@SuppressWarnings("unused")private long mPtr; //底层使用的 code//消息链表的开头Message mMessages;private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();private SparseArray<FileDescriptorRecord> mFileDescriptorRecords;private IdleHandler[] mPendingIdleHandlers;private boolean mQuitting;//指出获取下一个消息的方法 next() 是否阻塞private boolean mBlocked;// Barriers are indicated by messages with a null target whose arg1 field carries the token.//后一个屏障的 token private int mNextBarrierToken;
可以看到,MessageQueue
虽然叫“消息队列”,持有的其实是一个消息链表的节点。
何时初始化
MessageQueue
一般不直接访问,都是通过 Looper.myQueue()
方法获取一个消息队列。
消息队列在 Looper 的构造函数中初始化:
private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread();
}
MessageQueue(boolean quitAllowed) {mQuitAllowed = quitAllowed;mPtr = nativeInit();
}
MessageQueue 的构造函数中传入一个是否允许中途退出的标志,然后调用 Native 方法初始化。
这篇文章暂不研究 Native 层源码。
消息入队的过程
消息入队的方法是 enqueueMessage()
方法:
boolean enqueueMessage(Message msg, long when) {if (msg.target == null) { //这里要求消息必须跟 Handler 关联throw new IllegalArgumentException("Message must have a target.");}if (msg.isInUse()) { throw new IllegalStateException(msg + " This message is already in use.");}synchronized (this) {if (mQuitting) { //如果消息队列已经退出,还入队就报错IllegalStateException e = new IllegalStateException(msg.target + " sending message to a Handler on a dead thread");Log.w(TAG, e.getMessage(), e);msg.recycle();return false;}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.nextprev.next = msg;}// We can assume mPtr != 0 because mQuitting is false.if (needWake) {nativeWake(mPtr);}}return true;
}
Message.enqueueMessage()
方法中会检查入队的消息是否在被使用,如果是的话会报错:
if (msg.isInUse()) { throw new IllegalStateException(msg + " This message is already in use.");}
现在我们清楚了,文章开头我遇到的:
This message is already in use.
是因为我二次使用了已经在使用的消息,在入队时 MessageQueue 检查发现后报的错。
所以每次调用 Handler.sendMessage()
时,都必须是 obtain()
或者 new 一个新的 Message 对象才行。
此外,如果消息队列已经退出,还添加消息入队就会报错。
消息出队的过程
消息出队的方法是 MessageQueue.next()
方法:
Message next() {//如果消息的 looper 退出,就退出这个方法final long ptr = mPtr;if (ptr == 0) {return null;}int pendingIdleHandlerCount = -1; // -1 only during first iterationint nextPollTimeoutMillis = 0;//也是一个循环,有合适的消息就返回,没有就阻塞for (;;) {if (nextPollTimeoutMillis != 0) { //如果有需要过段时间再处理的消息,先调用 Binder 的这个方法Binder.flushPendingCommands();}nativePollOnce(ptr, nextPollTimeoutMillis);synchronized (this) {//获取下一个消息final long now = SystemClock.uptimeMillis();Message prevMsg = null;Message msg = mMessages; //当前链表的头结点if (msg != null && msg.target == null) {//如果消息没有 target,那它就是一个屏障,需要一直往后遍历找到第一个异步的消息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;}//如果收到退出的消息,并且所有等待处理的消息都处理完时,调用 Native 方法销毁队列if (mQuitting) {dispose();return null;}//有消息等待过段时间执行时,pendingIdleHandlerCount 增加if (pendingIdleHandlerCount < 0&& (mMessages == null || now < mMessages.when)) {pendingIdleHandlerCount = mIdleHandlers.size();}if (pendingIdleHandlerCount <= 0) {mBlocked = true;continue;}if (mPendingIdleHandlers == null) {mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];}mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);}for (int i = 0; i < pendingIdleHandlerCount; i++) {final IdleHandler idler = mPendingIdleHandlers[i];mPendingIdleHandlers[i] = null; // release the reference to the handlerboolean keep = false;try {keep = idler.queueIdle();} catch (Throwable t) {Log.wtf(TAG, "IdleHandler threw exception", t);}if (!keep) {synchronized (this) {mIdleHandlers.remove(idler);}}}// Reset the idle handler count to 0 so we do not run them again.pendingIdleHandlerCount = 0;// While calling an idle handler, a new message could have been delivered// so go back and look again for a pending message without waiting.nextPollTimeoutMillis = 0;}
}
可以看到,MessageQueue.next()
方法里有一个循环,在这个循环中遍历消息链表,找到下一个可以处理的、target 不为空的消息并且执行时间不在未来的消息,就返回,否则就继续往后找。
如果有阻塞(没有消息了或者只有 Delay 的消息),会把 mBlocked这个变量标记为 true,在下一个 Message 进队时会判断这个message 的位置,如果在队首就会调用 nativeWake() 方法唤醒线程!
其中看到个 IdleHandler
是什么呢?
public static interface IdleHandler {//当消息队列没有消息时会回调这个方法,阻塞等待有消息进入//返回 true 的话表示唤醒阻塞的线程,false 表示移除//如果消息队列中有消息等待在将来执行,也会调用这个方法boolean queueIdle();
}
根据源码和注释我们可以知道 IdleHandler
是一个线程阻塞时回调的接口。
MessageQueue 中提供了监听阻塞回调的注册和移除接口:
public void addIdleHandler(@NonNull IdleHandler handler) {if (handler == null) {throw new NullPointerException("Can't add a null IdleHandler");}synchronized (this) {mIdleHandlers.add(handler);}
}public void removeIdleHandler(@NonNull IdleHandler handler) {synchronized (this) {mIdleHandlers.remove(handler);}
}
当消息队列阻塞时,会回调这些监听阻塞的观察者,告诉他们:我有空了!来找我玩啊!
在 queueIdle()
中做的操作,它会在 handler 空闲时被调用,可以充分利用 handler,我们可以在代码里这样使用:
Handler handler = new Handler();try {Field field = Looper.class.getDeclaredField("mQueue");field.setAccessible(true);MessageQueue queue = (MessageQueue) field.get(handler.getLooper());queue.addIdleHandler(new MessageQueue.IdleHandler() {@Overridepublic boolean queueIdle() {//这里做一些操作return true;}});} catch (Exception e) {}
这里只简单介绍了 Java 层的 MessageQueue,关于 Native 层的可以看这篇文章:http://blog.csdn.net/innost/article/details/47317823
Looper
前面介绍了 Android 消息机制中消息和消息队列,有了传递的消息和存储的队列,接下来我们结合源码了解下进行调度的 Looper。
官方文档对 Looper 的介绍:
Looper 是用于运行一个线程中的消息的类。
Looper 的属性很简单:
// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper; // 主线程中的 Looeprfinal MessageQueue mQueue; //与之管理的消息队列
final Thread mThread; //所在的线程private Printer mLogging;
private long mTraceTag;
线程中默认没有 Looper,我们需要调用 Looper.prepare()
方法为当前线程创建一个 Looper,然后就可以调用 loop()
方法调度消息。
样例代码如下:
class LooperThread extends Thread {public Handler mHandler;public void run() {Looper.prepare();mHandler = new Handler() {public void handleMessage(Message msg) {// process incoming messages here}};Looper.loop();}}
线程相关 ThreadLocal
前面讲了在一个线程中需要调用 Looper.prepare()
方法创建一个 Looper:
public static void prepare() {prepare(true);
}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));
}
可以看到,一个线程中只能有一个 Looper。
创建一个或者或许当前线程的 Looper 都通过 ThreadLocal
,我们来了解下它的主要源码。
ThreadLocal.get()
和 ThreadLocal.set()
源码:
public T get() {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t); if (map != null) {ThreadLocalMap.Entry e = map.getEntry(this);if (e != null)return (T)e.value;}return setInitialValue();
}public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);
}
ThreadLocalMap getMap(Thread t) {return t.threadLocals;
}
ThreadLocalMap
中持有一个 Entry
的数组:
private Entry[] table;
static class Entry extends WeakReference<ThreadLocal> {Object value;Entry(ThreadLocal k, Object v) {super(k);value = v;}
}
可以看到,ThreadLocal
先通过当前线程获取 ThreadLocalMap
,然后在 ThreadLocalMap
中保存 ThreadLocal
和 数据的关联。
也就是一个类似 Map
无限循环调度
在线程中创建一个 Looper
以后,就可以调用 Looper.loop()
循环处理消息了,看下它的源码:
/*** Run the message queue in this thread. Be sure to call* {@link #quit()} to end the loop.*/
public static void loop() {final Looper me = myLooper();if (me == null) { //当前线程必须创建 Looper 才可以执行throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");}final MessageQueue queue = me.mQueue;//底层对 IPC 标识的处理,不用关心 Binder.clearCallingIdentity();final long ident = Binder.clearCallingIdentity();for (;;) { //无限循环模式Message msg = queue.next(); //从消息队列中读取消息,可能会阻塞if (msg == null) { //当消息队列中没有消息时就会返回,不过这只发生在 queue 退出的时候return;}//...try {msg.target.dispatchMessage(msg); //调用消息关联的 Handler 处理消息} finally {if (traceTag != 0) {Trace.traceEnd(traceTag);}}//...msg.recycleUnchecked(); //标记这个消息被回收}
}
可以看到,Looper.loop()
也很简单,就是调用 MessageQueue.next()
方法取消息,如果没有消息的话会阻塞,直到有新的消息进入或者消息队列退出。
拿到消息后调用消息关联的 Handler 处理消息。
可以看到,Looper 并没有执行消息,真正执行消息的还是添加消息到队列中的那个 Handler,真应了那句:解铃还须系铃人啊!
如何停止
loop()
源码中的注释就提醒我们,开启循环调度消息后不要忘记调用 quit()
方法结束循环。
Looper.quit() 和 quitSafely ()
源码:
public void quit() {mQueue.quit(false);
}public void quitSafely() {mQueue.quit(true);
}
两种退出方式都调用的是 MessageQueue.quit(boolean)
方法:
void quit(boolean safe) {if (!mQuitAllowed) {throw new IllegalStateException("Main thread not allowed to quit.");}synchronized (this) {if (mQuitting) {return;}mQuitting = true;if (safe) {removeAllFutureMessagesLocked();} else {removeAllMessagesLocked();}// We can assume mPtr != 0 because mQuitting was previously false.nativeWake(mPtr);}
}
private void removeAllFutureMessagesLocked() {final long now = SystemClock.uptimeMillis();Message p = mMessages;if (p != null) {if (p.when > now) { //`如果链表头部的消息执行时间在将来(也就是一时半会儿没有任务可执行)removeAllMessagesLocked(); //就直接强硬的全部回收了} else { Message n;for (;;) { //否则找到那个执行时间大于现在的消息,把它后面的消息都回收了n = p.next;if (n == null) {return;}if (n.when > now) {break;}p = n;}p.next = null;do {p = n;n = p.next;p.recycleUnchecked();} while (n != null);}}
}
private void removeAllMessagesLocked() {Message p = mMessages;while (p != null) { //挨个遍历链表,把消息都回收了Message n = p.next;p.recycleUnchecked();p = n;}mMessages = null;
}
可以看到 Looper 两种结束方式的区别:
quit()
:立即把消息链表中的所有消息都回收了,比较强硬- 在停止后如果 Handler 还发送消息,会返回 false,表示入队失败
- 这个方法是不安全的,一般建议使用下面那个
quitSafely()
:比上面那个温柔一点- 只会将还未执行的消息回收掉
- 在调用之后添加进入的消息不会被处理,Handler.sendMessage 也会返回 false
当消息队列被标记位退出状态时,它的 next()
方法会返回 null,于是 Looper.loop()
循环就结束了。
Handler
现在我们了解了消息队列和 Looper,接着就该介绍消息机制中最关键的角色 – Handler。
每一个 Handler 都和一个线程的 Looper 以及这个线程中的消息队列关联。
Handler 所做的就是 “线程切换”:
- 在子线程将 Message 或者 Runnable 发送到 MessageQueue 中
- 然后等待 Looper 调度这个消息后,再召唤 Handler 来处理消息
- 这时消息已经在创建 Handler 的线程了
这个“线程切换” 是怎么实现的呢?我们一步步揭晓。
Handler 的属性
Handler 的属性如下:
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;
可以看到 Handler 的属性很简单,其中 mCallback 可以作为构造函数的参数用于新建 Handler。
public Handler(Callback callback) {this(callback, false);
}
public interface Callback {public boolean handleMessage(Message msg);
}
我们平时创建 Handler 都是创建一个 Handler 的子类然后重写它的 handleMessage 方法,有了 Handler.Callback
接口我们可以用这种方式创建 Handler:
Handler mHandler = new Handler(new Handler.Callback() {@Overridepublic boolean handleMessage(Message msg) {//这里处理消息return false;}
});
最终效果和创建 Handler 子类一样,但是需要注意,这里创建了匿名内部类,还是会持有外部引用,导致内存泄漏。
发送消息
Handler 发送的主要有两种类型:
- Message
- Runnable
发送方法有 postXXX()
和 sendXXX()
两种,postXXX 发送的是 Runnable,调用的也是 sendXXX,而 Runnable 也会被转成 Message:
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;}
所以我们直接看 sendXXX 方法:
public final boolean sendMessage(Message msg){return sendMessageDelayed(msg, 0);
}
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 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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {msg.target = this;if (mAsynchronous) {msg.setAsynchronous(true);}return queue.enqueueMessage(msg, uptimeMillis);
}
可以看到 Handler 发送消息最后还是调用了消息队列的 enqueueMessage()
方法。
而我们常用的使用 Handler.sendMessageDelayed()
发送延迟消息,最后其实是在入队时指定这个 msg.when,在 MessageQueue.next()
方法中,会对 msg.when > now 的消息设置延迟处理,具体实现是在 Native 层。
消息入队后,Looper 如果启动了就可以从队列里循环取消息,然后调用 msg.target.dispatchMessage(msg)``` 也就是
Handler.dispatchMessage()“ 方法处理消息。
处理消息
/*** Handle system messages here.*/
public void dispatchMessage(Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}
}
private static void handleCallback(Message message) {message.callback.run();
}
public void handleMessage(Message msg) {
}
可以看到,Handler 在处理消息时,会有三种情况:
- msg.callback 不为空
- 这在使用
Handler.postXXX(Runnable)
发送消息的时候会发生 - 这就直接调用 Runnable 的 run() 方法
- 这在使用
- mCallback 不为空
- 这在我们使用前面介绍的 Handler.Callback 为参数构造 Handler 时会发生
- 那就调用构造函数里传入的
handleMessage()
方法 - 如果返回 true,那就不往下走了
最后就调用
Handler.handleMessage()
方法- 这是一个空实现,需要我们在 Handler 子类里重写
至此 Handler 发送和处理消息的源码我们就了解了。
移除消息
最后再看一下如果移除消息。
由于发送时可以发送 Callback 和 Message,所以取消也有两种:
- removeCallbacks()
- removeMessages()
看一下源码发现调用的其实就是消息队列的出队方法:
public final void removeCallbacks(Runnable r){mQueue.removeMessages(this, r, null);
}
public final void removeMessages(int what) {mQueue.removeMessages(this, what, null);
}
主线程消息机制
我们知道,在主线程中创建 Handler 时不用 papare Looper,这是因为在主线程中系统默认创建了 Looper,它在不停地调度分发消息,因此四大组件的调度、我们的输入事件、绘制请求才能得到处理。
ActivityThread 就是我们说的主线程,而它的 main()
方法就是当主线程的入口:
public static void main(String[] args) {/...Process.setArgV0("<pre-initialized>");Looper.prepareMainLooper();ActivityThread thread = new ActivityThread();thread.attach(false);if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}if (false) {Looper.myLooper().setMessageLogging(newLogPrinter(Log.DEBUG, "ActivityThread"));}// End of event ActivityThreadMain.Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);Looper.loop();}
可以看到在主线程的 main()
方法中初始化了一个 Looper,然后调用了 Looper.loop()
方法开始调度消息。
发送和处理主线程中的消息的 Handler 叫做 H:
private class H extends Handler {public static final int LAUNCH_ACTIVITY = 100;public static final int PAUSE_ACTIVITY = 101;public static final int PAUSE_ACTIVITY_FINISHING= 102;public static final int STOP_ACTIVITY_SHOW = 103;public static final int STOP_ACTIVITY_HIDE = 104;public static final int SHOW_WINDOW = 105;public static final int HIDE_WINDOW = 106;public static final int RESUME_ACTIVITY = 107;public static final int SEND_RESULT = 108;public static final int DESTROY_ACTIVITY = 109;public static final int BIND_APPLICATION = 110;public static final int EXIT_APPLICATION = 111;public static final int NEW_INTENT = 112;public static final int RECEIVER = 113;public static final int CREATE_SERVICE = 114;public static final int SERVICE_ARGS = 115;public static final int STOP_SERVICE = 116;//...public void handleMessage(Message msg) {if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));switch (msg.what) {case LAUNCH_ACTIVITY: {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");final ActivityClientRecord r = (ActivityClientRecord) msg.obj;r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);handleLaunchActivity(r, null);Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);} break;case RELAUNCH_ACTIVITY: {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");ActivityClientRecord r = (ActivityClientRecord)msg.obj;handleRelaunchActivity(r);Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);} break;//...}if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));}
H 的代码很多,我们只节选一部分。从上述代码可以看到,H 内部定义了消息类型,然后根据消息的类型进行不同的处理。
主线程的消息机制如下:
- ActivityThread 通过 ApplicationThread 与 AMS 进行进程通信
- AMS 以进程通信的方式完成 ActviityThread 的请求后回调 ApplicationThread 的 Binder
- 然后 ApplicationThread 向 H 发送消息,H 将消息切换到主线程,然后进行处理
总结
这篇文章结合源码完整的看了一遍 Message MessageQueue Handler Looper,现在看着上面的图,可以自信地说我“熟悉 Android 消息机制”了哈哈。
结合 Android 性能优化:多线程 理解会更深一些!
Thanks
《Android 开发艺术探索》
http://book2s.com/java/src/package/android/os/handler.html#d0bdd75e69340e6c9e876ee32501beae
http://book2s.com/java/src/package/android/os/looper.html
http://book2s.com/java/src/package/android/os/message.html
Android 进阶14:源码解读 Android 消息机制( Message MessageQueue Handler Looper)相关推荐
- Android的消息机制: Message/MessageQueue/Handler/Looper
概览 * Message:消息.消息里面可包含简单数据.Object和Bundle,还可以包含一个Runnable(实际上可看做回调). * MessageQueue:消息队列,供Looper线程消费 ...
- PackageManagerService Android 8.1 源码解读 02
接上文:PackageManagerService Android 8.1 源码解读 01 d.第三步细节:PKMS.main(),main函数主要工作: [检查]Package编译相关系统属性 [调 ...
- 【Android】OkHttp源码解读逐字稿(2)-OkHttpClient
目录 0.前言 1.各个属性浅析 01.dispatcher 02.connectionPool 03.interceptors&networkInterceptors 04.eventLis ...
- PackageManagerService Android 8.1 源码解读 01
一.PackageManagerService 是什么? 答: PackageManagerService(简称 [PKMS]),是 Android 系统中核心服务之一,负责应用程序的安装,卸载,信息 ...
- android 普通蓝牙源码解读
一:概述 上一篇博客讲了下蓝牙4.0在android中的应用,这里讲讲普通蓝牙之间如何操作. 我记得在大二的时候还做了个比较烂的游戏,当时喜欢打dota就做了个蓝牙之间对战坦克的游戏,可以去看看,确实 ...
- 【Android】OkHttp源码解读逐字稿(1)-拦截器
目录 0.前言 1.OkHttp的简单使用 2.浅析开始 拦截器 链式调用流程示意图 第 0 个拦截器 第一个 拦截器 RetryAndFollowUpInterceptor 第二个拦截器 Bridg ...
- Android进阶——Small源码分析之启动流程详解
前言 插件化现在已经是Android工程师必备的技能之一,只是学会怎么使用是不行的,所以蹭有时间研究一下Small的源码.对于插件化主要解决的问题是四大组件的加载和资源的加载,读懂所有Small源码需 ...
- 别人家SDK的设计模式——Android Retrofit库源码解读
作者:网易合作产品部·李若昆 我们在日常编写代码中免不了会用到各种各样第三方库,网络请求.图片加载.数据库等等.有些lib接入可能方便到几行代码搞定,有些lib可能从demo.文档到测试都是坑(比如l ...
- Android进阶——ExoPlayer源码分析之宽带预测策略的算法详解
前言 由于国内基础设施非常优秀,在平时的开发中,很少会关注网络情况,很容易忽略弱网情况下的网络状况,如果项目属于国外App,则需要考虑到当前的基础设施和网络情况,特别是播放视频的时候,需要通过动态调整 ...
最新文章
- BI+Tableau
- fcntl函数完成 set_fl()函数还有clr_fl()函数的封装
- javascript:使用document.getElementById读取数据为空分析
- 为什么卫星天线长得像口大锅?
- 浅析五种C语言内存分配的方法及区别
- java写html的多选框,Selenium+java - 单选框及复选框处理
- html5圆盘抽奖,HTML5 Canvas圆盘抽奖运用DEMO
- 如何解决“配置系统未能初始化“ 错误的解决方案?
- python输入两个数 求和_Python两数相加
- 孩子成长-跟同学相处
- winedit 永久试用的办法
- 预应力锚具的分类和使用领域
- 使用BP网络逼近函数-matlab
- Collections的用法
- c语言最大字符1025,leetcode1025(除数博弈)--C语言实现
- 实时系统中的MCS模式和Sporadic Server算法
- 图像隐写术分析论文笔记:Deep learning for steganalysis via convolutional neural networks
- 【经验分享】拼多多怎么查看帮别人砍价记录?
- 【机器学习】逻辑回归之心脏病预测
- 微视抄袭抖音?马化腾怒怼张一鸣:诽谤