Handler消息处理机制

Handler消息处理机制

1.概述。

Handler消息处理机制对于初学者来说，应该算是一块心病，几乎每次面试都会被问到，今天我抽时间从源码的角度总结一下相关知识点。先看一下我们平时是怎么用的，如下代码实例：

public class MainActivity extends AppCompatActivity {

private TextView text;

private Handler mHandler;

int i=0;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(https://www.360docs.net/doc/0214408773.html,yout.activity_main);

text = (TextView) findViewById(R.id.text);

mHandler = new Handler(){

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

text.setText("变为："+msg.what);

}

};

}

public void sendMes(View view){

mHandler.sendEmptyMessage(i);

i++;

}

}

很简单，onCreat()方法中实例化了一个Handler实例，实现其handlerMessage(Message msg)方法，在方法中改变TextView的显示内容，在布局文件中放了一个Button设置其android:onClick="sendMes"，看一下效果：

相信每一个开发Android的人都会使用Handler更新页面，但是我们还要知道它是如何实现的，下面我们就剖析一下它的源码吧。

2.源码解析

我们都知道Handler机制涉及到了几个类，他们分别是Handler、Message、MessageQueue、Looper，先来了解一下这几个类的作用：

1.Message：个人认为可以看成是我们要传递消息的载体，我们可以将信息设置到它的what属性，arg属性等。

2.MessageQueue：统一存储Message的类，我们发出的每一个消息都将保存到MessageQueue中，我们可以从里边取消息进行处理。

3.Looper：统一管理message，循环取出MessageQueue中存储的消息进行处理的类。

4.Handler：发送Message,处理Message的类。

下面我们先看一下Looper这个类，这个类有两个方法非常重要：prepare()、loop(),瞅瞅prepare()方法的实现：

public static void prepare() {

prepare(true);

}

调用了单参数的重载方法，传的是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));

}

在这里用到了ThreadLocal类，这个类为每一个用到它的线程提供一个副本，每一个线程只能访问自己的数据。判断不为空保证了我们这个方法只能被调用一次，创建了Looper实例，并将我们的true继续传递，那么我们看一下Looper 的构造函数：

private Looper(boolean quitAllowed) {

mQueue = new MessageQueue(quitAllowed);

mThread = Thread.currentThread();

}

在Looper中创建了MessageQueue对象，并传递true，大家也行会问这个true 是干嘛的，它是后续用来判断消息循环是否可以终止的，系统在UI线程里边调用时传递的false，后边会介绍到，再看看他的MessageQueue中又做了什么呢？MessageQueue(boolean quitAllowed) {

mQuitAllowed = quitAllowed;

mPtr = nativeInit();

}

保存了传递进来的boolean值。这样我们就看完了Looper的prepare()方法的实现流程，总结一下：

创建了当前线程对应的Looper对象并保存的mThreadLocal对象中，同时创建了与之对应的MessageQueue对象。

下边看一下Looper.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;

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

for (;;) {

Message msg = queue.next(); // might block

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 traceTag = me.mTraceTag;

if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {

Trace.traceBegin(traceTag, msg.target.getTraceName(msg));

}

try {

msg.target.dispatchMessage(msg);

} finally {

if (traceTag != 0) {

Trace.traceEnd(traceTag);

}

}

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

}

}

这个方法稍微长一点，但是并不难，首先调用myLooper()方法从mThreadLocal 对象中获取保存的Looper对象，并从Looper中拿到对应的MessageQueue对象，一个for循环获取queue中的每一个Message，最终调用了

msg.target.dispatchMessage(msg);嗯？这个target是什么？其实就是我们实例化的mHandler对象，这里先记住，后边会说到，去Handler类中找一下dispatchMessage()方法：public void dispatchMessage(Message msg) {

if (msg.callback != null) {

handleCallback(msg);

} else {

if (mCallback != null) {

if (mCallback.handleMessage(msg)) {

return;

}

}

handleMessage(msg);

}

}

看到没，系统在这里调用了handlerMessage(msg)方法，看一下：

public void handleMessage(Message msg) {

}

咦，是个空实现，没错，因为我们在实例化Handler的时候重写了handlerMessage(Message msg)方法，所以会执行到我们更新页面UI的代码。到这，我们Looper.loop()方法也介绍完了，总结一下：

通过myLooper()方法获取当前线程对应的Looper对象，并取到对应的MessageQueue，创建一个for()的无限循环，去取MessageQueue中的Message，取到message中保存的Handler 对象调用其dispatchMessage()方法，最终执行到我们的handlerMessage(Message msg)方法更新UI。看到这里，你是不是稍微明白了一点，没事，接着往下看，看完了你就明白了，上述的这两个方法只是做了一些前期准备，那么下面我们就看一下当我们实例化一个handler时系统做了些什么。

public Handler() {

this(null, false);

}

调用了重载方法：

public Handler(Callback callback, boolean async) {

if (FIND_POTENTIAL_LEAKS) {

final Class 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;

}

参数通过单词也能明白个大概，看重要的，类似Looper.loop()方法，也是获取了对应的Looper对象及Queue对象并且赋值callback与mAsynchronous。这个方法挺简单的，没什么太多逻辑，就是一个获取信息。下边看一下当我们调用mHandler.sendEmptyMessage(i)时系统又做了一些什么？

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

}

经过一系列方法的调用，在这里我们发现了msg.target属性被赋值了this，也就是说对应了我们当前的Handler,这下你应该明白上边发送message时的那段代码了吧，接着向下看，最终调用了queue.enqueueMessage(msg, uptimeMillis)方法：

boolean enqueueMessage(Message msg, long when) {

if (msg.target == null) {

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) {

// New head, wake up the event queue if blocked.

msg.next = p;

mMessages = msg;

needWake = mBlocked;

} else {

// Inserted within the middle of the queue. Usually we don't have to wake

// up the event queue unless there is a barrier at the head of the queue // and the message is the earliest asynchronous message in the queue. 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;

}

这段代码就是将我们当前发送的消息插入到了消息队列中。因为之前在Looper.loop()方法中有一个，无限循环在一直取消息，所以当我们加入新的消息时，就会在loop()方法中被取出来，并执行相应message中target的dispatchMessage()方法，最终执行到我们Handler 实例中的handlMessage()方法中更新UI界面，现在你应该明白了吧。

整体总结一下：

1.首先调用Looper.prepare()方法，创建Looper实例，保存到ThreadLocal中，并创建与之对应的MessageQueue对象；

2.调用Looper.loop()方法，获取到对应的messageQueue对象，创建无限循环取出messageQueue中的Message中的target（Handler）执行其dispatchMessage()方法最终执行到handleMessage（）方法中更新UI，如果没有message进入等待状态。

3.创建Handler实例对象，管理Looper对象与MessageQueue对象。

4.调用sendMessage（）方法，创建Message对象，赋值target，添加到messageQueue中。

5.Looper.loop()中无限循环最终取出我们新加入的Message并执行相关方法更新UI。

也许你会说我从来没有用过Looper.prepare()方法与Looper.loop()方法啊，没错，因为在主线程中系统已经为我们调用了，所以不用我们调用。看一下ActivityThread中的main

方法的实现：

public static void main(String[] args) {

Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain"); SamplingProfilerIntegration.start();

// CloseGuard defaults to true and can be quite spammy. We

// disable it here, but selectively enable it later (via

// StrictMode) on debug builds, but using DropBox, not logs.

CloseGuard.setEnabled(false);

Environment.initForCurrentUser();

// Set the reporter for event logging in libcore

EventLogger.setReporter(new EventLoggingReporter());

// Make sure TrustedCertificateStore looks in the right place for CA certificates final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId()); TrustedCertificateStore.setDefaultUserDirectory(configDir);

Process.setArgV0("");

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

}

// End of event ActivityThreadMain.

Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

Looper.loop();

throw new RuntimeException("Main thread loop unexpectedly exited");

}

可以看到在这里系统调用的是Looper.prepareMainLooper()方法，并发我们讲的Looper.prepare(),有什么区别呢？看一下：

public static void prepareMainLooper() {

prepare(false);

synchronized (Looper.class) {

if (sMainLooper != null) {

throw new IllegalStateException("The main Looper has already been prepared."); }

sMainLooper = myLooper();

}

}

看到没，系统在这里也是调用了prepare（false）方法，只不过它传递的是false，并不是我们之前的true，那我们看一下在MessageQueue中哪用到了这个参数，就知道他是干嘛得了：

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

}

}

就这一个地方用到了，通过他判断了，是否可以停止。如果是主线程因为系统传递的是false，所以是不能停止消息循环的。到这里，整篇文章的疑问都解决了。

最后看一下Handler.post(Runnable r);方法的实现：

public final boolean post(Runnable r)

{

return sendMessageDelayed(getPostMessage(r), 0);

}

调用了一个getPostMessage（r）方法：

private static Message getPostMessage(Runnable r) {

Message m = Message.obtain();

m.callback = r;

return m;

}

可以看到它是被付给了message的callback参数，在handler的dispatchMessage()方法中有用到：

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

}

它会判断并执行run方法。

到这里，我们这篇文章就算是写完了，我们在源码的角度分析了Handler消息处理机制，希望对大家有所帮助。