Handler的消息机制(简单讲解)
平时听的最多就是子线程不能更新UI线程,否则会引发异常,进程崩溃。所以我们通常会在主线程当中new一个Handler来更新UI线程。我是个初学者,不知道为什么,反正就是这样用的。今天看了源码,剖析了一下,原来在这样的原理。
首先,简单屡一下思路,Handler是和Looper、MessageQueue之间是密切相关的,相信大家百度过的也知道。不知道大家是否还记得这样的用法:
public class MainActivity extends Activity {
private TextView mTv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTv= (TextView) findViewById(R.id.mTv);
mTv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(new Runnable() {
@Override
public void run() {
mTv.setText("子线程想要更改界面");
}
}).start();
}
});
}
然后就报异常了。。。。
然后在主线程中,我们通常会这样子来出来:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mHandler=new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MSG_UPDATE_TEXT:
mTv.setText("让Handler更改界面");
break;
case MSG_UPDATE_WAY_TWO:
mTv.setText("让Handler更改界面方式二");
break;
}
}
};
mTv= (TextView) findViewById(R.id.mTv);
mTv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.d("Test", "点击文字");
// 方式一和方式二可以达到相同的效果,就是更改界面
// 方式一: mHandler.sendEmptyMessage(MSG_UPDATE_TEXT);
// 方式二:
Message msg =Message.obtain();
msg.what= MSG_UPDATE_WAY_TWO;
mHandler.sendMessage(msg);//---------------请注意,在这里标记发送这条消息的Handler对象
}
});
}
}
然而,它究竟为何要这样做的呢?实际上, mHandler.sendMessage(msg);
这个语句,仅仅是将这条消息添加
到主线程的消息队列
中,并非他内部接着就调用 handleMessage(Message msg) ,这个 handleMessage(Message msg) 函数,是在主线程中,Looper
不断地从消息队列取出
一条消息,然后再分发
到Handler对象
(这里指的是刚刚发送消息的 mHandler),才执行
这个函数,所以 handleMessage(Message msg)是在主线程调用
的,在这里更新UI自然就情有可原了。
然而,问题又来了,主线程在分发这个消息的时候,怎么知道是分发给哪个Handler对象的呢?如果我们一个大程序很多个Handler对象,他是怎么唯一标识的呢?(或许这样表达很low,我曾经就是这样low过来的,说不定现在有人恰好需要这样表达,不喜勿喷^_^)
其实当构造这条消息的时候,已经把这条消息的Handler标记了
先看一下Message 的成员变量:注释省略掉了
public final class Message implements Parcelable {
public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
public int sendingUid = -1;
/*package*/ static final int FLAG_IN_USE = 1 << 0;
/** If set message is asynchronous */
/*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;
/** Flags to clear in the copyFrom method */
/*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
/*package*/ int flags;
/*package*/ long when;
/*package*/ Bundle data;
/*package*/ Handler target;//----------------------------------- 请看这里
/*package*/ Runnable callback;
// sometimes we store linked lists of these things
/*package*/ Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
那么,他是在哪里保存这个Handler的引用的呢?请看: mHandler.sendMessage(msg);
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;这时候把这个message的target保存起来。也就是说,当把消息发送给消息对象时候就标记好了,等从消息队列中取出消息,就直接调用这个Handler的 handleMessage(Message msg),就可以在主线程更新UI了。
那么,取出消息又是怎么个过程呢?
当程序跑起来,它会进入消息循环,例如平时我们看到程序一直在显示(或者在后台一直跑),实际上就是死循环,让他不断的显示(不断的跑),直到这个死循环跳出来,进程就关闭。具体是怎么跑的呢?
先从主线程的入口开始看:
public final class ActivityThread {
//------------------------------------------------省略多余代码
public static void main(String[] args) {
SamplingProfilerIntegration.start();//------------------------------启动安卓性能分析工具
CloseGuard.setEnabled(false);//-------------------------------------暂时关闭检测,稍后打开
Environment.initForCurrentUser();//---------------------------------当前用户初始化环境参数
EventLogger.setReporter(new EventLoggingReporter());
Security.addProvider(new AndroidKeyStoreProvider());//---------------系统安全算法
//------------------------------------------------------------------信用凭证
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");//-------------------启动标志,主循环准备初始化
Looper.prepareMainLooper();//-------------------------------------------主线程准备
//前面都是准备工作,这里到下面就是程序一直执行的核心
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {//-----------------------------------获取主线程的Handler
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();//---------------------------------------------------------主线程循环
//-----------------------------------------------------------执行到这里,说明出现异常
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}
}
程序一直在主循环,看看里面发生了什么?
public static void loop() {
//部分代码省略
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
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);从消息队列中,取出消息,然后执行 dispatchMessage(msg);
接下来看看dispatchMessage(msg);
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
主线程调用 handleMessage(msg);就会执行最开始我们定义的Handler的 handleMessage(msg)了。