Android Handler机制
Posted ITRenj
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android Handler机制相关的知识,希望对你有一定的参考价值。
- 《Android Handler机制》
- 《Android Handler分析(一) Handler和Message详解》
- 《Android Handler分析 (二) MessageQueue详解》
- 《Android Handler分析 (三) Looper详解和Handler其他知识》
- 《Android 中的 HandlerThread 类详解》
作为一个android程序员,我想大家都知道在做一些比较耗时的操作的时候都不会放在主线程,比如网络请求、数据库操作等(尤其是网络请求,在Android4.0之后强制不能放在主线程中执行,否则抛出android.os.NetworkOnMainThreadException异常),而更新UI的操作的都是由UI线程处理。那么有这样一个需求,我在一个新的线程中获取到数据,然后设置到界面上,这就涉及到了两个线程,用于更新界面的UI线程不知道什么时候数据获取完成可以更新界面了,那怎么办呢?Google就给我们提供了一个解决方案,也就是我们今天主要说明的内容——Android中的Handler消息机制。
首先来一个简单使用:
private static final int HANDLER_TEST_WHAT = 0x01; // 定义测试what
// 创建Handler对象,并重写handleMessage()方法处理消息
private Handler handler = new Handler()
@Override
public void handleMessage(Message msg)
int what = msg.what; // 获取消息的what
// 通过what对消息进行判断,不同消息不同的处理
if(what == HANDLER_TEST_WHAT)
// 处理消息
;
// 创建一个子线程发送消息
new Thread()
@Override
public void run()
Message message = Message.obtain(); // 创建一个消息对象,使用obtain()重用回收的消息对象
message.what = HANDLER_TEST_WHAT; // 设置Message的 what
handler.sendMessage(message); // 发送一个消息
.start();
上面就是一个简单的例子,在子线程发送一个消息,然后在主线程就可以对消息进行处理,当然包括更新UI或者其他操作。
下面我们就从源码的角度查看与分析一下Handler消息机制,他是怎样将一个子线程的数据传递到主线程中的。
介绍Handler机制之前,首先了解几个概念:
- **Message:**消息,理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI,则可发送一条包含更新信息的Message给UI线程。
- **MessageQueue:**消息队列,用来存放通过Handler发布的消息并按时间进行排序,按照先进先出执行。
- **Handler:**Handler是Message的主要处理者,负责将Message添加到消息队列以及对消息队列中的Message进行处理。
- **Looper:**轮询器,扮演MessageQueue和Handler之间桥梁的角色,循环取出MessageQueue里面的Message,并交付给相应的Handler进行处理。
消息机制分析
从上面的示例中,我们先创建了一个Handler对象并且重写了 handleMessage()
方法用来处理接收到的消息,而消息的发送是通过 Handler 的sendMessage()
方法。也可以说,Handler机制是由 sendMessage()
方法开始,到 handleMessage()
方法结束,现在我们就来一步一步看看数据是怎样传递的,线程又是怎样切换的。
首先看看创建 Handler
最终调用的是 带两个参数 的构造方法,如下:
public Handler(@Nullable Callback callback, boolean async)
mLooper = Looper.myLooper();
if (mLooper == null)
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
mQueue = mLooper.mQueue;
说明:
-
Looper.myLooper():获取当前线程的 Looper 对象,也就是线程需要是一个 Looper 线程,主线程就是一个 Looper 线程,主线程为什么是一个Looper线程以及怎样将一个线程变为 Looper 线程,在《Android Handler分析 (三) Looper详解和Handler其他知识》中有说到。
public static @Nullable Looper myLooper() return sThreadLocal.get();
-
mLooper.mQueue:就是一个 MessageQueue 对象,他是在 Looper 构造方法中初始化的
private Looper(boolean quitAllowed) mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread();
我们创建了 Handler 对象之后,然后通过 Handler 的 sendMessage()
方法发送一个 Message,接下来看看 sendMessage()
方法做了写什么事
Handler#sendMessage() 方法
public final boolean sendMessage(@NonNull Message msg)
return sendMessageDelayed(msg, 0);
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis)
if (delayMillis < 0)
delayMillis = 0;
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
public boolean sendMessageAtTime(@NonNull 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(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis)
// 注意这行代码,将 Message 的 target 变量赋值成 this,也就是当前 Handler 对象
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous)
msg.setAsynchronous(true);
return queue.enqueueMessage(msg, uptimeMillis);
说明:
sendMessage()
方法调用了一些 Message 类自身的发送方法,主要是处理消息发送时间(立马发送还是延迟发送等)- 最终调用
enqueueMessage()
方法,在这个方法中又调用了queue.enqueueMessage(msg, uptimeMillis)
,queue 就是 MessageQueue,所以查看一下 MessageQueue 中的enqueueMessage()
方法 - 重点注意
enqueueMessage()
方法中的msg.target = this
代码,将 Message 的target
变量赋值成this
,也就是当前 Handler对象
MessageQueue#enqueueMessage() 方法
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)
msg.next = p;
mMessages = msg;
needWake = mBlocked;
else
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;
这个方法所做的事情就是将 Message 对象根据发送时间添加到队列中,方法的具体分析在 《Android Handler分析 (二) MessageQueue详解》中。
Message 消息对象添加到 MessageQueue 中之后,在哪里取出来,并且传递到 handleMessage() 方法呢?
这里我们就有必要先说一下 Looper 线程了,一个类变为Looper线程并且能处理消息,主要有两步:
- 调用 Looper.prepare() 方法
- 调用 Looper.loop() 方法开始轮询
至于这两个方法具内容是什么我们这里就不说了,在《Android Handler分析 (三) Looper详解和Handler其他知识》中有分析,只需要知道 loop()
方法最重要的作用就是不断的循环调用 MessageQueue 的 next()
方法去获取 Message ,然后进行处理,而 MessageQueue 的 next()
方法的消息分析在 《Android Handler分析 (二) MessageQueue详解》中,它的主要作用就是按照顺序从队列里面取出 Message。
所以我们直接看 MessageQueue.next()
取到消息之后 Looper.loop()
方法是怎样处理的,核心代码如下:
public static void loop()
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
Message msg = queue.next();
try
msg.target.dispatchMessage(msg);
catch (Exception exception)
finally
说明:
通过获取的 Message 对象的变量 target
, 调用它的 dispatchMessage()
方法,并且将 msg
对象传递给 dispatchMessage()
方法。在上面,我们已经知道了 target
变量表示的就是 Handler,所以这里调用的就是 Handler 的 dispatchMessage()
方法了。
Handler#dispatchMessage() 方法
public void dispatchMessage(@NonNull Message msg)
if (msg.callback != null)
handleCallback(msg);
else
if (mCallback != null)
if (mCallback.handleMessage(msg))
return;
handleMessage(msg);
在 dispatchMessage()
方法中调用了 handleMessage(msg)
方法并传递 Message,这个方法我们在创建 Handler 时重写了。所以就走到了我们自己处理消息的部分。因为我们的这个Handler是在主线程创建的并且绑定的也是主线程的Looper,所以这个方法就在主线程当中执行了。
以上是关于Android Handler机制的主要内容,如果未能解决你的问题,请参考以下文章