【Android】源码分析 - Handler消息机制再梳理

前言

Activity

Service

Broadcast

ContentProvider

初学Handler

异步更新UI

Handler

AsyncTask

IntentService

Handler

private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0:
mTestTV.setText("This is handleMessage");   //更新UI
break;
}
}
};

new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000); //在子线程有一段耗时操作,比如请求网络
mHandler.sendEmptyMessage(0);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();

mHandler

sendEmptyMessage(0)

mTestTV

Handler源码跟踪

sendEmptyMessage()

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);
}

sendMessageAtTime()

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;    //拿到MessageQueue队列对象
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
//把msg对象入队
return enqueueMessage(queue, msg, uptimeMillis);
}

sendEmptyMessage()

sendMessageAtTime()

MessageQueue

mQueue

Message

msg

MessageQueue对象从哪里来

mQueue

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();    //使用Looper.myLooper()取到了mLooper对象
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;    //原来消息队列来自mLooper对象里的mQueue
mCallback = callback;
mAsynchronous = async;
}

mQueue

Looper

Looper.myLooper()

MessageQueue

final MessageQueue mQueue;

private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed); //初始化MessageQueue对象
mThread = Thread.currentThread();
}

myLooper()

/**
* Return the Looper object associated with the current thread.  Returns
* null if the calling thread is not associated with a Looper.
*/
public static Looper myLooper() {
return sThreadLocal.get();
}

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

ThreadLocal

prepare()

sThreadLocal.get()

prepare()

private static void prepare(boolean quitAllowed) {
//每个线程只允许执行一次该方法，第二次执行时线程的TLS已有数据，则会抛出异常。
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//创建Looper对象，并保存到当前线程的TLS区域
sThreadLocal.set(new Looper(quitAllowed));
}

ThreadLocal

ThreadLocal

Looper.prepare()

Looper.prepare()

ThreadLocal

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

Handler h1 = new Handler();

new Thread(new Runnable() {
@Override public void run() {
Handler h2 = new Handler();     //直接在子线程中new一个Handler
}
}).start();
}

Looper.prepare()

new Handler()

mHandler

Looper.prepare()

public static void main(String[] args) {
...
Looper.prepareMainLooper();     //这里等同于Looper.prepare()
...
Looper.loop();
...
}

Message对象如何入队

enqueueMessage()

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;      //注意此处Handler把自己this赋值给了Message的target变量
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

msg

mHandler

msg

mHandler

MessageQueue

enqueueMessage()

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.next
prev.next = msg;
}

// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}

MessageQueue

next()

Message next() {
//如果消息的 looper 退出，就退出这个方法
final long ptr = mPtr;
if (ptr == 0) {
return null;
}

int pendingIdleHandlerCount = -1; // -1 only during first iteration
int 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 handler

boolean 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

mBlocked

true

message

nativeWake()

MessageQueue.next()

Handler

Looper

Looper如何处理Message

Looper

next()

/**
* 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()

msg.target

dispatchMessage(msg)

msg.target

Handler

sendMessageAtTime()

msg.target

mHandler

dispatchMessage(msg)

/**
* 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.postXXX(Runnable)

handleMessage()

Handler.handleMessage()

整体运行机制

四大主角

MessageQueue.enqueueMessage()

MessageQueue.next()

Handler.sendMessage()

Handler.handleMessage()

Looper.loop()

流程图

Looper

MessageQueue

Message

Handler

Looper

sendMessage()

post()

UI线程

主线程

HandlerThread

Looper

Looper

Looper

Looper.prepare()

Looper.loop()

Looper

Looper.prepare()

java.lang.RuntimeException: Only one Looper may be created per thread

Looper.myLooper()

null

Looper.getMainLooper()

Looper

总结

Looper

prepare()

Looper

ThreadLocal

Looper

MessageQueue

Looper

loop()

MessageQueue.next()

Message

Message

Message

target

Message

Handler

Runnable

Handler

Looper.prepare()

Looper

Handler

Handler

Handler

Handler

Message

target

Looper

Message

Handler

Message

Runnable

Runnable.run()

Handler的内存泄露问题

private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
...
}
};

static class MyHandler extends Handler {
WeakReference<Activity > mActivityReference;
MyHandler(Activity activity) {
mActivityReference= new WeakReference<Activity>(activity);
}
@Override
public void handleMessage(Message msg) {
final Activity activity = mActivityReference.get();
if (activity != null) {
mImageView.setImageBitmap(mBitmap);
}
}
}

进程、线程间通信方式

一、进程间的通信方式

二、线程间的通信方式

参考资料