转载于:
http://blog.csdn.net/guolin_blog/article/details/9991569
http://www.cnblogs.com/JczmDeveloper/p/4403129.html
1.前言
Android UI是线程不安全的,如果在子线程中尝试进行UI操作,程序就有可能会崩溃。
在一个Activity中,当有多个线程更新UI时,并且没有枷锁机制,就会出现更新界面混乱,但是如果有枷锁机制的话,又会导致性能下降,此时使用Handler机制,通过消息队列,保证了消息处理的先后顺序,进而很好的更新了界面。解决的方案应该也是早已烂熟于心,即创建一个Message对象,然后借助Handler发送出去,之后在Handler的handleMessage()方法中获得刚才发送的Message对象,然后在这里进行UI操作就不会再出现崩溃了,解决多线程并发的问题。
在下面介绍handler机制前,首先得了解以下几个概念:
Message
消息,理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI,则可发送一条包含更新信息的Message给UI线程。Message Queue
消息队列,用来存放通过Handler发布的消息,按照先进先出(FIFO)执行。Handler
Handler是Message的主要处理者,负责将Message添加到消息队列以及对消息队列中的Message进行处理。Looper
循环器,扮演Message Queue和Handler之间桥梁的角色,循环取出Message Queue里面的Message,并交付给相应的Handler进行处理。线程
UI thread 通常就是main thread,而Android启动程序时会替它建立一个Message Queue。
每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里,可以定义Handler的子类别来接收Looper所送出的消息。
2.代码分析
(1)Handler的作用
- 传递message
用于接受子线程发送的数据,并用此数据配合主线程更新UI。
sendEmptyMessage(int what);
sendMessage(Message msg);
sendMessageAtTime(Message msg,long uptimeMillis);//uptimeMillis 自系统开机到当前时间的毫秒数再加上延迟时间
sendMessageDelayed(Message msg,long delayMillis);
sendMessageAtFrontOfQueue(Message msg);
- 传递Runnable对象
post(Runnable run);
postAtTime(Runnable run,long uptimeMillis);
postDelayed(Runnable run,long delayMillis);
- 传递Callback对象
Callback用于截获handler发送的消息,如果返回true,就截获成功,不再往下传递。
如果返回false,则继续执行下面的handleMessage方法。
public Handler m = new Handler(new Handler.Callback(){
public boolean handleMessage(Message msg) {
Toast.makeText(context, "handle intercept", Toast.LENGTH_LONG).show();
return true;
};
}){
public void handleMessage(Message msg) {
Toast.makeText(context, "handleMessage", Toast.LENGTH_LONG).show();
};
};
(2)Handler的原理
handler封装了message的发送
Looper内部包含一个Message Queue消息队列,所有handler发送的消息都走向这个队列 。
Looper.loop()方法是一个for死循环,不断从Message Queue取消息,有消息就处理消息,没有消息就阻塞Message Queue消息队列,可以添加消息,处理消息
Handler负责发送message,Looper负责接受Handler发送的message,并直接把message回传给handler自己,Message Queue就是一个存储消息的容器。
下图展示了具体流程:
一个线程中只有一个Looper实例,一个MessageQueue实例,可以有多个Handler实例。
如下图:
(3)子线程中创建Handler
1.自定义子线程并创建Handler
class MyThread extends Thread{
private Handler m_Handler = null;
@Override
public void run() {
Looper.prepare();
handler = new Handler(){
@Override
public void handleMessage(Message msg) {
if(1==msg.what){
super.handleMessage(msg);
try {
Thread.sleep(10000);
Toast.makeText(getApplicationContext(), "currentThread:"+Thread.currentThread().getName(), Toast.LENGTH_LONG).show();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
m_Handler.sendEmptyMessage(1);
Looper.loop();
}
}
//启动线程处理耗时操作
new MyThread().start();
一般UI主线程中不宜做耗时操作,此时就可以通过子线程中的消息机制来处理耗时操作。
主线程中创建Handler时,不需要调用Looper.prepare()和Looper.loop(),是因为系统已经帮我们自动调用们调用了。
子线程中创建的Handler时,需要先调用Looper.prepare(),否则会导致 crash:Can’t create handler inside thread that has not called Looper.prepare(),而且之后还需要调用Looper.loop()来循环从消息队列处理消息。之所以会这样,我们需要看下Handler源码:
public Handler() {
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 = null;
}
源码中调用了Looper.myLooper()方法获取了一个Looper对象,如果Looper对象为空,则会抛出一个运行时异常,提示的错误正是 Can’t create handler inside thread that has not called Looper.prepare()!那什么时候Looper对象才可能为空呢?这就要看看Looper.myLooper()中的代码了,如下所示:
public static final Looper myLooper() {
return (Looper)sThreadLocal.get();
}
从sThreadLocal对象中取出Looper。如果sThreadLocal中有Looper存在就返回Looper,如果没有Looper存在自然就返回空了。因此你可以想象得到是在哪里给sThreadLocal设置Looper了吧,当然是Looper.prepare()方法!我们来看下它的源码:
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
首先判断sThreadLocal中是否已经存在Looper了,如果还没有则创建一个新的Looper设置进去。这样也就完全解释了为什么我们要先调用Looper.prepare()方法,才能创建Handler对象。同时也可以看出每个线程中最多只会有一个Looper对象。
接下来就是发送消息,除了sendMessageAtFrontOfQueue()方法之外,其它的发送消息方法最终都会辗转调用到sendMessageAtTime()方法中,这个方法的源码如下所示:
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
sendMessageAtTime()方法接收两个参数,其中msg参数就是我们发送的Message对象,而uptimeMillis参数则表示发送消息的时间,它的值等于自系统开机到当前时间的毫秒数再加上延迟时间,如果你调用的不是sendMessageDelayed()方法,延迟时间就为0,然后将这两个参数都传递到MessageQueue的enqueueMessage()方法中。这个MessageQueue又是什么东西呢?其实从名字上就可以看出了,它是一个消息队列,用于将所有收到的消息以队列的形式进行排列,并提供入队和出队的方法。这个类是在Looper的构造函数中创建的,因此一个Looper也就对应了一个MessageQueue。
enqueueMessage()方法毫无疑问就是入队的方法了,我们来看下这个方法的源码:
final boolean enqueueMessage(Message msg, long when) {
if (msg.when != 0) {
throw new AndroidRuntimeException(msg + " This message is already in use.");
}
if (msg.target == null && !mQuitAllowed) {
throw new RuntimeException("Main thread not allowed to quit");
}
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
return false;
} else if (msg.target == null) {
mQuiting = true;
}
msg.when = when;
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
this.notify();
} else {
Message prev = null;
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
msg.next = prev.next;
prev.next = msg;
this.notify();
}
}
return true;
}
MessageQueue并没有使用一个集合把所有的消息都保存起来,它只使用了一个mMessages对象表示当前待处理的消息。然后观察上面的代码的16~31行我们就可以看出,所谓的入队其实就是将所有的消息按时间来进行排序,这个时间当然就是我们刚才介绍的uptimeMillis参数。具体的操作方法就根据时间的顺序调用msg.next,从而为每一个消息指定它的下一个消息是什么。当然如果你是通过sendMessageAtFrontOfQueue()方法来发送消息的,它也会调用enqueueMessage()来让消息入队,只不过时间为0,这时会把mMessages赋值为新入队的这条消息,然后将这条消息的next指定为刚才的mMessages,这样也就完成了添加消息到队列头部的操作。
现在入队操作我们就已经看明白了,那出队操作是在哪里进行的呢?这个就需要看一看Looper.loop()方法的源码了,如下所示:
public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
while (true) {
Message msg = queue.next(); // might block
if (msg != null) {
if (msg.target == null) {
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
msg.target.dispatchMessage(msg);
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
msg.recycle();
}
}
}
可以看到,这个方法从第4行开始,进入了一个死循环,然后不断地调用的MessageQueue的next()方法,我想你已经猜到了,这个next()方法就是消息队列的出队方法。不过由于这个方法的代码稍微有点长,我就不贴出来了,它的简单逻辑就是如果当前MessageQueue中存在mMessages(即待处理消息),就将这个消息出队,然后让下一条消息成为mMessages,否则就进入一个阻塞状态,一直等到有新的消息入队。继续看loop()方法的第14行,每当有一个消息出队,就将它传递到msg.target的dispatchMessage()方法中,那这里msg.target又是什么呢?其实就是Handler啦,你观察一下上面sendMessageAtTime()方法的第6行就可以看出来了。接下来当然就要看一看Handler中dispatchMessage()方法的源码了,如下所示:
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
在第5行进行判断,如果mCallback不为空,则调用mCallback的handleMessage()方法,否则直接调用Handler的handleMessage()方法,并将消息对象作为参数传递过去。这样我相信大家就都明白了为什么handleMessage()方法中可以获取到之前发送的消息了吧!
2.使用HandlerThread子线程
HandlerThread继承自Thread,它与普通Thread的区别在于内部有个Looper成员变量,这个Looper对象就是对消息队列以及消息队列逻辑处理的封装。当我们需要一个工作线程,且不是用过就废弃的话,就可以使用它。
private Handler mHandler;
private HandlerThread mHandlerThread;
private void setRunnableToWorker(Runnable r){
if(null == mHandlerThread){
mHandlerThread = new HandlerThread("WorkThread");
mHandlerThread.setPriority(Thread.MIN_PRIORITY);
mHandlerThread.start();
}
if(null == mHandler){
mHandler = new Handler(mHandlerThread.getLooper());
mHandler.post(r);
}
}
(4)主线程与子线程通过Handler信息交互
//方式一:
private Handler mThreadHandler;//创建工作线程handler
private HandlerThread mHandlerThread;//工作线程
private void setRunnableToWorker(Runnable r){
if(null == mHandlerThread){
mHandlerThread = new HandlerThread("WorkThread");
mHandlerThread.setPriority(Thread.MIN_PRIORITY);
mHandlerThread.start();
}
if(null == mThreadHandler){
mThreadHandler = new Handler(mHandlerThread.getLooper());
mThreadHandler.post(r);
}
}
//创建主线程handler
private Handler m_Handler = new Handler(){
public void handleMessage(Message msg) {
if(msg.what == 1){
Toast.makeText(getApplicationContext(), "update UI", Toast.LENGTH_LONG).show();
tv.setText("hi");
}
};
};
//onResume()中调用setRunnableToWorker()处理耗时操作,并通过handler更新UI
setRunnableToWorker(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(10000);
m_Handler.sendEmptyMessage(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Toast.makeText(getApplicationContext(), "update UI", Toast.LENGTH_LONG).show();
}
});
//方式二:
private WorkHandler mWorkHandler;//创建工作线程的Handler
private class WorkHandler extends Handler{
public WorkHandler(Looper l){
super(l);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if(msg.what == 2){
try {
Thread.sleep(10000);
m_Handler.sendEmptyMessage(1);//耗时操作处理完毕,发送消息给主线程更新UI
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
//创建主线程handler
private Handler m_Handler = new Handler(){
public void handleMessage(Message msg) {
if(msg.what == 1){
Toast.makeText(getApplicationContext(), "update UI", Toast.LENGTH_LONG).show();
tv.setText("hi");
}
};
};
//创建工作线程
private HandlerThread mWorkThread;
//onResume()中
mWorkThread = new HandlerThread("workThread");
mWorkThread.start();
mWorkHandler = new WorkHandler(mWorkThread.getLooper());
mWorkHandler.sendEmptyMessage(2);//发送消息给工作线程,让其处理耗时操作
(5)Android中更新UI的方式
1.Handler的post()方法
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
//调用了sendMessageDelayed()方法去发送一条消息,并且还使用了getPostMessage()方法将Runnable对象转换成了一条消息
private final Message getPostMessage(Runnable r) {
Message m = Message.obtain();//可以避免重复创建Message对象
m.callback = r;
return m;
}
//在这个方法中将消息的callback字段的值指定为传入的Runnable对象。咦?这个callback字段看起来有些眼熟啊,喔!在Handler的dispatchMessage()方法中原来有做一个检查,如果Message的callback等于null才会去调用handleMessage()方法,否则就调用handleCallback()方法。
private final void handleCallback(Message message) {
message.callback.run();
}
//直接调用了一开始传入的Runnable对象的run()方法。因此在子线程中通过Handler的post()方法进行UI操作就可以这么写:
public class MainActivity extends Activity {
private Handler handler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
handler.post(new Runnable() {
@Override
public void run() {
// 在这里进行UI操作
}
});
}
}).start();
}
}
2.Activity的runOnUiThread()方法
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}
//如果当前的线程不等于UI线程(主线程),就去调用Handler的post()方法,否则就直接调用Runnable对象的run()方法。
3.View的post()方法
public boolean post(Runnable action) {
Handler handler;
if (mAttachInfo != null) {
handler = mAttachInfo.mHandler;
} else {
ViewRoot.getRunQueue().post(action);
return true;
}
return handler.post(action);
}
//最终调用的还是handler的post方法
4.Handler的sendMessage方法
见上述分析