Android 消息分发机制
Android
中针对耗时的操作,放在主线程操作,轻者会造成UI
卡顿,重则会直接无响应,造成Force Close
。同时在Android 3.0
以后,禁止在主线程进行网络请求。- 针对耗时或者网络操作,那就不能在主线程进行直接操作了,需要放在子线程或者是工作线程中进行操作,操作完成以后,再更新主线程即
UI
线程。这里就涉及到一个问题了,在子线程执行完成以后,怎么能更新到主线程即 UI 线程呢,针对以上问题,就需要用到 Android 的消息机制了,即:Handler, Message, MessageQueue, Looper
全家桶
文章结构
- 用法
- 常见问题
- Can't create handler inside thread that has not called Looper.prepare()
- 内存泄漏
- 从源码角度解析为什么可以跨线程进行 UI 更新
用法
- 继承
Handler
类,复写handleMessage()
方法,MyHandler
类的构造方法传入当前Activity
,然后就可以对Activity
的UI
进行更新了。当前例子只是弹出一个Toast
static class MyHandler extends Handler {
// 弱引用,防止内存泄漏
WeakReference<MainActivity> weakReference;
MyHandler(MainActivity activity) {
weakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case WHAT:
MainActivity mainActivity = weakReference.get();
if (mainActivity != null) {
Toast.makeText(mainActivity, "Toast", Toast.LENGTH_SHORT).show();
}
break;
default:
break;
}
}
}
- 在
MainActicity onCreate
,初始化Handler
类
MyHandler mHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mHandler = new MyHandler(this);
}
- 点击
Button
按钮,模拟在子线程进行耗时操作,方法执行完成以后,通过mhandler
发送一个Message
public void sendMessage(View view) {
//模拟耗时操作
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(15000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
Message message = Message.obtain();
message.what = WHAT;
mHandler.sendMessage(message);
}
}
}).start();
}
- 在
MyHandler
的hanldeMessage()
方法中,接收到该message
,并弹出Toast
提醒
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case WHAT:
MainActivity mainActivity = weakReference.get();
if (mainActivity != null) {
Toast.makeText(mainActivity, "Toast", Toast.LENGTH_SHORT).show();
}
break;
default:
break;
}
}
- 以上代码,实现了在子线程执行耗时操作,执行完成以后更新
UI
。
完整代码如下:
public class MainActivity extends AppCompatActivity {
public static final int WHAT = 1000;
MyHandler mHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mHandler = new MyHandler(this);
}
@Override
protected void onDestroy() {
super.onDestroy();
mHandler.removeCallbacksAndMessages(null);
}
public void sendMessage(View view) {
//模拟耗时操作
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(15000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
Message message = Message.obtain();
message.what = WHAT;
mHandler.sendMessage(message);
}
}
}).start();
}
static class MyHandler extends Handler {
// 弱引用,防止内存泄漏
WeakReference<MainActivity> weakReference;
MyHandler(MainActivity activity) {
weakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case WHAT:
MainActivity mainActivity = weakReference.get();
if (mainActivity != null) {
Toast.makeText(mainActivity, "Toast", Toast.LENGTH_SHORT).show();
}
break;
default:
break;
}
}
}
}
常见问题
- Can't create handler inside thread that has not called Looper.prepare().
- 在子线程 new 出来的 Handler 发送 message ,会出现该问题
log如下:
06-04 14:55:38.365 16567-16818/cc.lijingbo.paypasswordview E/AndroidRuntime: FATAL EXCEPTION: Thread-1018
Process: cc.lijingbo.paypasswordview, PID: 16567
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 cc.lijingbo.paypasswordview.MainActivity$1.run(MainActivity.java:51)
at java.lang.Thread.run(Thread.java:818)
造成 crash
的代码如下:
public void sendMessage(View view) {
//模拟耗时操作
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(15000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
Message message = Message.obtain();
message.what = WHAT;
new Handler().sendMessage(message);
}
}
}).start();
}
- 如何避免: 假如是更新
UI
的话,只能使用UI
线程的Handler
来发送消息。
- 内存泄漏
- 假如在子线程执行了耗时操作,这时用户操作进入了其他的
acitvity
, 那么MainActivity
就会被内存回收的,但是这个时候发现Handler
还在引用着MainActivity
,内存无法及时回收,造成内存泄漏 Handler
防止内存泄漏常见方法:Handler
继承类,用static
进行修饰,成为静态内部类Handler
中对Activity
进行弱引用Activity
执行onDestroy()
方法时,对Handler
做执行清空操作。
从源码角度解析为什么可以跨线程进行 UI
更新
-
消息机制主要包括:
Handler, Looper , MessageQueue, Message
Handler
: 两个作用,发送消息到MessageQueue
,同时Looper
不断从MessageQueue
拿出消息分发给Handler
,Handler
把消息通过dispathMessage()
和handleMessage()
把消息分发具体的业务Looper
: 初始化MessageQueue
, 内部死循环不断从MessageQueue
中获取数据进行分发给Handler
MessageQueue
: 消息队列,内部使用的是单链表的数据结构,Message
: 被传递的消息
-
先来张时序图,让大脑有个大致的了解。
-
为什么通过
Handler
可以把子线程的结果通知或者携带给 UI 线程- 这里的
Handler
指的是主线程的Handler
,同时与Handler
配套的Looper
,MessageQueue
是在UI
线程初始化的,所以在子线程中调用Handler
发送消息可以更新UI
线程。 Looper
在UI
线程源码, 在ActivityThread
类:
- 这里的
public static void main(String[] args) {
...
Looper.prepareMainLooper(); // 初始化在 UI 线程的 Looper
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop(); // 开启从当前线程的 MessageQueue 中获取 Message
throw new RuntimeException("Main thread loop unexpectedly exited");
}
- Looper
public static void prepareMainLooper() {
prepare(false);// 设置不可退出
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
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
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);// 在UI 线程,传入的是 fasle ,MessageQueue 不可退出。
mThread = Thread.currentThread();
}
源码解析
- 先从 Handler 的 sendMessage() 这个入口开始。
发现sendMessage()
调用了内部方法sendMessageDelayed()
,而sendMessageDelayed()
调用了内部方法sendMessageAtTime()
,sendMessageAtTime()
调用了enqueueMessage()
,enqueueMessage()
调用了MessageQueue
的enqueueMessage()
方法。以上传来传去的这些在Handler
中的方法,都是做各种状态的处理,然后把Message
传到MessageQueue
的enqueueMessage()
方法。
源码如下:
public final boolean sendMessage(Message msg)
{ // 立即发送的消息,设置延迟时间为 0
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) {
// mQueue 从 Looper 中获取的。判断当前 Handler 持有的 MessageQueue 是否为 null ,为 null 的时候抛出 RuntimeException 。
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
// 传入 MessageQueue, Message, Time
return enqueueMessage(queue, msg, uptimeMillis);
}
...
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 设置 Message 的 target 为 当前的 Handler
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
// 把 Message 和 Time 传入到 MessageQueue 的 enqueueMessage() 方法执行。
return queue.enqueueMessage(msg, uptimeMillis);
}
...
- MessageQueue 的 enqueueMessage() 源码
boolean enqueueMessage(Message msg, long when) {
// Message 的target 即 Handler ,不能为 null ,为 null 的时候抛异常
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) { // msg 用过抛出异常
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) {// 退出标志位,要是退出的话, 执行 msg 的回收操作。
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle(); //Message 回收操作
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// MessageQueue 没有消息,或者是 msg 是第一条消息,唤醒阻塞的 MsssageQueue
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// 将消息按时间顺序插入到 MessageQueue, 一般地,不需要唤醒消息队列,除非消息队头存在 barrier ,并且 Message 同时是队列最早的异步消息
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;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
MessageQueue 按照 Message 触发时间的先后顺序排列的,对头的消息是将要最早触发的消息,当有消息需要加入消息队列时,会从队列头开始遍历,直到找到消息应该插入的合适位置,以保证所有消息的时间顺序。
- 取消息
当发送了消息后,由 MessageQueue 维护消息队列,然后在 Looper 中通过 loop() 方法不断的取消息。
public static void loop() {
// 通过 ThreadLocal 获取 存储当前线程的的 Looper。
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;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 死循环,不断的从 MessageQueue 中获取 Message
for (;;) {
Message msg = queue.next(); // MessageQueue 没消息的时候,可能会阻塞
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
// 消息分发,Message 的 target 就是 Handler, 这里调用 Handler 的dispatchMessage() 把消息分发出去
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (slowDispatchThresholdMs > 0) {
final long time = end - start;
if (time > slowDispatchThresholdMs) {
Slog.w(TAG, "Dispatch took " + time + "ms on "
+ Thread.currentThread().getName() + ", h=" +
msg.target + " cb=" + msg.callback + " msg=" + msg.what);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
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();
}
}
Message next() {
// 返回
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
// 当消息循环已经退出则返回
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // 循环迭代首次为-1
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// 阻塞操作,当等待 nextPollTimeoutMillis时长 或者消息队列被唤醒,都会返回
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// 当 msg 的 Handler 为null时,查询 MessageQueue 的下一条异步消息,为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();
// 获取MessageQueue下一条要执行的消息
return msg;
}
} else {
// 没有消息
nextPollTimeoutMillis = -1;
}
// 所有待处理的消息已被处理,消息正在退出,返回null
if (mQuitting) {
dispose();
return null;
}
...
}
}
}
nativePollOnce 是阻塞操作,其中 nextPollTimeoutMillis 代表下一个消息到来前,还需要等待的时长;当 nextPollTimeoutMillis = -1 时,表示消息队列中无消息,会一直等待下去。
可以看出 next() 方法根据消息的触发时间,获取下一条需要执行的消息,队列中消息为空时,则会进行阻塞操作。
- 分发消息
分发消息,由 Handler 的 dispatchMessage() 方法执行
public void dispatchMessage(Message msg) {
// msg 的 callback 不为null,这消息分发给 handleCallback() 执行, 然后调用 message.callback.run() 方法
if (msg.callback != null) {
handleCallback(msg);
} else {
// Handler 的内部接口,不为null ,执行该接口的实现方法 handleMessage();
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// Message 的 Runable 和 Callback 接口都为 null 的情况下,执行 Handler 的handlrMessage() 方法。
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
消息分发流程:
Message 的 msg.callback 不为空的时候,执行 message.callback.run() 方法
Message 成员变量 Callback 不为null 的时候,执行该接口的 handleMessage() 方法
最后调用 Handler 自身的 handleMessage() 方法
- 最后放一张图来整理理解
https://lrh1993.gitbooks.io/android_interview_guide/content/android/basis/message-mechanism.html
直面挑战,躬身入局