1.概念介绍
1)、成员介绍
Message:主要功能是进行消息的封装,同时可以指定消息的操作形式;
Looper:消息循环泵,用来为一个线程跑一个消息循环。每一个线程最多只可以拥有一个。
MessageQueue:就是一个消息队列,存放消息的地方。每一个线程最多只可以拥有一个。
Handler:消息的处理者,handler 负责将需要传递的信息封装成Message,发送给Looper,继而由Looper将Message放入MessageQueue中。当Looper对象看到MessageQueue中含有Message,就将其广播出去。该handler 对象收到该消息后,调用相应的handler 对象的handleMessage()方法对其进行处理。
2)、同线程各成员的关系及数量
①一个线程中只能有一个Looper,只能有一个MessageQueue,可以有多个Handler,多个Messge;
②一个Looper只能维护唯一一个MessageQueue,可以接受多个Handler发来的消息;
③一个Message只能属于唯一一个Handler;
④同一个Handler只能处理自己发送给Looper的那些Message;
2.问题1:如果一个Activity有多个handler时候,怎样知道handler1发送的消息不会被handler2接收,同理handler2发送的消息不会被handler1接收。
一般操作Handler的两种方式:
首先在Activity中新建一个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();
方式2:使用 Handler.post
private Handler mHandler;//全局变量
@Override
protected void onCreate(Bundle savedInstanceState) {
mHandler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);//在子线程有一段耗时操作,比如请求网络
mHandler.post(new Runnable() {
@Override
public void run() {
mTestTV.setText("This is post");//更新UI
}
});
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
问题2:给post方法传了个Runnable,像是开了个子线程, 但实际上,run()是在主线程中执行的,这又是什么原因??得通过源码来分析。
2.1 Handler的构造方法
1.
public Handler() {
this(null, false);
}
2.
public Handler(Callback callback) {
this(callback, false);
}
3.
public Handler(Looper looper) {
this(looper, null, false);
}
4.
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
5.
public Handler(boolean async) {
this(null, async);
}
6.
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();
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;
}
7.
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
第6个构造方法中,mLooper = Looper.myLooper();获取了主线程中的那个looper对象,判断mLooper==null的时候,抛出了一个异常,说明了不能在线程里面创建handler,如果必须要用的话,需要调用Looper.prepare()方法。mLooper不为null的情况下,mQueue = mLooper.mQueue,获取的是MessageQueue队列
看看Looper.prepare()的源码:
/** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
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.prepare()的时候,相当于new Looper(quitAllowed)了一个新Looper设置到新线程中。这样一个thread就有了一个Looper.
继续看当我们调用sendMessage的时候,我们看一下源码里面是怎么执行的:
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);
}
一步一步的往下走我们看到在enqueueMessage()方法里面有一个,
msg.target = this;这句话就是重点,就是说我们通过sendMesasge(msg)一层一层的传递消息,最后这个msg.target=this就是把当前的这个handler标记给这个当前我们发送的msg,然后再把这个打好标记的信息添加到消息队列中。
这是sendMessage的源码分析,我们再来看看post()
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);//getPostMessage方法是两种发送消息的不同之处
}
方法只有一句,内部实现和普通的sendMessage是一样的,但是只有一点不同,那就是
getPostMessage(r) 这个方法:
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
这个方法我们发现也是将我们传入的参数封装成了一个消息,只是这次是
m.callback = r,刚才是
msg.what=what
我们再看看Looper里面的源码:
/**
* 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) {
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
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg);
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();
}
}
我们看到 msg.target.dispatchMessage(msg);这一句是,直接将这个消息交给了发送这个消息的handler处理。
/**
* 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);
}
}
可以看到Looper把消息分发给handler, handler最终拿到消息调用handleMessage(msg),此时我们在前台调用的时候重写的handleMessage(msg)拿到的这个msg就是我们需要处理的Message.这样就完成了handler1把消息传递,然后把这个消息打上这个handler1的标记,最后looper再拿到打上这个handler1标记的消息,再分发给handler1,此时handler1拿到的就是它上次发送的那个消息.
这样问题1就清楚了: Activity中可以有多个handler,同时handler发送消息,各自接收各自的消息,这样有序的进行。
对于问题2:
handleCallback(Message message) 调用了 message.callback.run();
- msg的callback不为空,调用handleCallback方法(message.callback.run())
- mCallback不为空,调用mCallback.handleMessage(msg)
- 最后如果其他都为空,执行Handler自身的 handleMessage(msg) 方法
继续看如果msg.callback为空的情况下的mCallback, 我们看handler的构造函数6和7
具体的实现就只有最后两个,已经知道mCallback是怎么来的了,在构造方法中传入就行。
最后如果这两个回调都为空的话就执行Handler自身的handleMessage(msg)方法,也就是我们熟知的新建Handler重写的那个handleMessage方法。