Android Handler学习笔记
已经习惯了挖坑不填,继续任性一下,周一到周五继续挖坑,每周六周日负责填坑。
1.从Android UI线程谈起
出于性能考虑,Android 中的UI操作并不是线程安全的,所以Android中规定只能在主线程中修改Activity中的UI组件,故主线程又称UI线程。Android程序启动时会同时启动UI线程,该线程负责处理UI相关事件,并且进行事件分发。
- 不是线程安全可以理解为两个人同时独立的在一张纸上画画,最后画出来的就是错乱的。实现线程安全可以通过加锁进行数据保护,以后有机会写C++相关博客再介绍多线程问题。
在某些情况下我们需要让新启动的线程周期性更新UI(比如游戏动画中),所以要找一个方式在子线程中发送消息,在主线程接受消息,配合起来更新UI,这时我们就需要Handler了。
2.Handler是个什么鬼
参考资料:
疯狂Android讲义第三章
Handler的主要作用有两个:1)在新线程发送消息,2)在主线程获取和处理消息
先用了再说:
/*
*主线程中使用Handler
*/
private static final String TAG = "HandlerActivity";
private Handler mHandler;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);
//在主线程中创建Hander对象
mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
//接受消息对象并处理
super.handleMessage(msg);
Log.e(TAG,"------------> msg.what = " + msg.what);
}
};
new Thread(new Runnable() {
@Override
public void run() {
SystemClock.sleep(2000);
//在子线程中使用Handler对象发送消息
mHandler.sendEmptyMessage(0);
}
}).start();
}
感觉很好用,说起来就是Android不允许子线程访问UI组件,所以我们要在新线程中发送消息,让系统更新UI组件。在new出来的Handler对象中重写了handleMessage()
,当通过新线程发送消息是,该方法自动被回调。
接下来总结一下Handler中的消息发送和处理方法:
算了,懒得总结,直接看官方文档
常用的有这些:
发送消息:
sendMessage()
,sendEmptyMessage()
,sendMessageDelayed()
,sendEmptyMessageDelayed()
接受处理消息:
handleMessage
,obtainMessage()
等
3.可以在子线程创建Handler吗
/*
*子线程中使用Handler
*/
private static final String TAG = "TestHandlerActivity";
//主线程中的handler
private Handler mHandler;
//子线程中的handler
private Handler mHandlerThread = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);
//创建handler对象
mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//获得刚才发送的Message对象,然后在这里进行UI操作
Log.e(TAG,"------------> msg.what = " + msg.what);
}
};
new Thread(new Runnable() {
@Override
public void run() {
SystemClock.sleep(2000);
//通过Handler发送一个消息切换回主线程(mHandler所在的线程)
mHandler.sendEmptyMessage(0);
/*
//调用Looper.prepare()方法
Looper.prepare();
*/
//在子线程中创建Handler
mHandlerThread = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//在子线程中调用handleMessage接受和处理message对象
Log.e("sub thread","---------> msg.what = " + msg.what);
}
};
mHandlerThread.sendEmptyMessage(1);
/*
/*
//调用Looper.prepare()方法
Looper.loop();
*/
*/
}
}).start();
}
很不幸,崩溃了!
使用Handler的两个经典异常:
CalledFromWrongThreadException
:这种异常是因为尝试在子线程中去更新UI,进而产生异常。
Can’t create handle inside thread that ha not called Looper.prepared
:是因为我们在子线程中去创建Handler,而产生的异常。
修改方式,调用Looper.prepare()
方法,将上面的注释放开。
4.异步消息处理——Handler
深入源码解析Android中的Handler,Message,MessageQueue,Looper
Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系
Handler 、 Looper 、Message 这三者都与Android异步消息处理线程相关的概念。那么什么叫异步消息处理线程呢?
异步消息处理线程启动之后处于无限循环体中,每循环一次,则从内部消息队列中取出一条消息,然后回掉相关消息处理函数。
执行完一个消息之后会继续循环,若消息队列为空,则线程阻塞等待。
Looper负责创建一个MessageQueue,然后进入一个无限循环体不断从该MessageQueue中读取消息,而消息的创建者就是一个或多个Handler 。
Looper的核心方法
Looper的构造方法:
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
//构造方法主要是创建消息队列
mRun = true;
mThread = Thread.currentThread();
}
prepare()方法
public static final void prepare() {
//sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量。
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(true));
}
第5行行代码中将一个Looper的实例放入了ThreadLocal,并且2-4行判断了sThreadLocal是否为null,否则抛出异常。这也就说明了Looper.prepare()方法不能被调用两次,同时也保证了一个线程中只有一个Looper实例。
loop方法:
public static void loop() {
final Looper me = myLooper();
//返回了sThreadLocal存储的Looper实例,如果me为null则抛出异常,也就是说looper方法必须在prepare方法之后运行。
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//拿到该looper实例中的mQueue(消息队列)
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);
//把消息交给msg的target的dispatchMessage方法去处理,即实现消息分发。
//Msg的target是什么呢?其实就是handler对象
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.recycle();
}
}
Looper主要作用:
1、 与当前线程绑定,保证一个线程只会有一个Looper实例,同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法,不断从MessageQueue中去取消息,交给消息的target属性的dispatchMessage去处理。
好了,我们的异步消息处理线程已经有了消息队列(MessageQueue),也有了在无限循环体中取出消息的哥们,现在缺的就是发送消息的对象了,于是乎:Handler登场了。
5.理解一下
Android系统中专门启动一个线程用于异步消息处理,从都源码可以看到该线程为sLocalThread
,该线程中启动一个Looper对象,Looper对象中的Loop()
函数负责遍历消息队列和分发消息,每一个Looper中有且仅有一个MessageQueue,该对象用于保存所有的msg。
可以理解为 one loop per thread (陈硕在muduo的设计理念中提到)。