深入Android的消息机制源码详解HandlerMessageQueue与Looper关系文档格式.docx
- 文档编号:21969020
- 上传时间:2023-02-02
- 格式:DOCX
- 页数:16
- 大小:135.44KB
深入Android的消息机制源码详解HandlerMessageQueue与Looper关系文档格式.docx
《深入Android的消息机制源码详解HandlerMessageQueue与Looper关系文档格式.docx》由会员分享,可在线阅读,更多相关《深入Android的消息机制源码详解HandlerMessageQueue与Looper关系文档格式.docx(16页珍藏版)》请在冰豆网上搜索。
[java]viewplaincopyprint?
在CODE上查看代码片派生到我的代码片
publicclassMainActivityextendsAppCompatActivity{
publicstaticfinalintMSG_FINISH=0X001;
//创建一个Handler的匿名内部类
privateHandlerhandler=newHandler(){
@Override
publicvoidhandleMessage(Messagemsg){
switch(msg.what){
caseMSG_FINISH:
LogUtils.e("
handler所在的线程id是-->
"
+Thread.currentThread().getName());
break;
}
};
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//启动耗时操作
consumeTimeThread(findViewById(R.id.tv));
//handler.post()
//启动一个耗时线程
publicvoidconsumeTimeThread(Viewview){
newThread(){
publicvoidrun(){
try{
耗时子线程的Name是--->
//在子线程运行
Thread.sleep(2000);
//完成后,发送下载完成消息
handler.sendEmptyMessage(MSG_FINISH);
}catch(InterruptedExceptione){
e.printStackTrace();
}.start();
}
运行结果:
上面的例子其实就是Handler的基本使用,在主线中创建了一个Handler对象,然后通过在子线程中模拟一个耗时操作完成后通过sendEmptyMessage(int)方法发送一个消息通知主线程的Handler去执行相应的操作。
通过运行结果我们也可以知道Handler确实也是在主线程运行的。
那么问题来了,通过Handler发送的消息是怎么到达主线程的呢?
接下来我们就来掰掰其中的奥妙,前方高能,请集中注意力!
为了更好的理解Handler的工作原理,我们先来介绍与Handler一起工作的几个组件:
Message:
Handler接收和处理消息的对象。
Looper:
每个线程只能有一个Looper。
它的loop方法负责读取MessageQueue中的消息,读到消息后把消息发送给Handler进行处理。
MessageQueue:
消息队列,它采用先进先出的方式来管理Message。
程序创建Looper对象时,会在它的构造方法中创建MessageQueue对象。
Handler:
它的作用有两个—发送消息和处理消息,程序使用Handler发送消息,由Handler发送的消息必须被送到指定的MessageQueue;
否则消息就没有在MessageQueue进行保存了。
而MessageQueue是由Looper负责管理的,也就是说,如果希望Handler正常工作的话,就必须在当前线程中有一个Looper对象。
我们先对上面的几个组件有大概的了解就好,后面我们都会详细分析,既然消息是从Handler发送出去,那么我们就先从Handler入手吧。
先来看看Handler的构造方法源码:
publicclassHandler{
/**
*未实现的空方法handleMessage()
*/
*我们通常用于创建Handler的构造方法之一
publicHandler(){
this(null,false);
//构造方法的内调用的this(null,false)的具体实现
publicHandler(Callbackcallback,booleanasync){
//检查Handler是否是static的,如果不是的,那么有可能导致内存泄露
if(FIND_POTENTIAL_LEAKS){
finalClass<
?
extendsHandler>
klass=getClass();
if((klass.isAnonymousClass()||klass.isMemberClass()||klass.isLocalClass())&
&
(klass.getModifiers()&
Modifier.STATIC)==0){
Log.w(TAG,"
ThefollowingHandlerclassshouldbestaticorleaksmightoccur:
"
+
klass.getCanonicalName());
//重要的组件出现啦!
Looper我们先理解成一个消息队列的管理者,用来从消息队列中取消息的,后续会详细分析
mLooper=Looper.myLooper();
if(mLooper==null){
//这个异常很熟悉吧,Handler是必须在有Looper的线程上执行,这个也就是为什么我在HandlerThread中初始化Handler
//而没有在Thread里面初始化,如果在Thread里面初始化需要先调用Looper.prepare方法
thrownewRuntimeException(
Can'
tcreatehandlerinsidethreadthathasnotcalledLooper.prepare()"
);
//将mLooper里面的消息队列复制到自身的mQueue,这也就意味着Handler和Looper是公用一个消息队列
mQueue=mLooper.mQueue;
//回调函数默认是Null
mCallback=null;
分析:
Handler的构造方法源码不是很多,也比较简单,但是我们从源码中也可以得知,在创建Handler时,Handler内部会去创建一个Looper对象,这个Looper对象是通过Looper.myLooper()创建的(后续会分析这个方法),同时还会创建一个消息队列MessageQueue,而这个MessageQueue是从Looper中获取的,这也就意味着Handler和Looper共用一个消息队列,当然此时Handler,Looper以及MessageQueue已经捆绑到一起了。
上面还有一个情况要说明的,那就是:
if(mLooper==null){
}<
/span>
这里先回去判断Looper是否为空,如果为null,那么就会报错,这个错误对我们来说应该比较熟悉吧,那为什么会报这个错误呢?
我们在前面说过Handler的作用有两个—发送消息和处理消息,我们在使用Handler发送消息,由Handler发送的消息必须被送到指定的MessageQueue;
否则就无法进行消息循环。
那么又该如何保障当前线程中一定有Looper对象呢?
这里其实分两种情况:
(1)在主UI线程中,系统已经初始化好了一个Looper对象,因此我们可以直接创建Handler并使用即可。
(2)在子线程中,我们就必须自己手动去创建一个Looper对象,并且去启动它,才可以使用Handler进行消息发送与处理。
使用事例如下:
classchildThreadextendsThread{
publicHandlermHandler;
//子线程中必须先创建Looper
Looper.prepare();
mHandler=newHandler(){
super.handleMessage(msg);
//处理消息
//启动looper循环
Looper.loop();
分析完Handler的构造方法,我们接着看看通过Handler发送的消息到底是发送到哪里了?
我们先来看看Handler的几个主要方法源码:
//发送一个空消息的方法,实际上添加到MessagerQueue队列中
publicfinalbooleansendEmptyMessage(intwhat){
returnsendEmptyMessageDelayed(what,0);
//给上一个方法调用
publicfinalbooleansendEmptyMessageDelayed(intwhat,longdelayMillis){
Messagemsg=Message.obtain();
msg.what=what;
returnsendMessageDelayed(msg,delayMillis);
publicfinalbooleansendMessageDelayed(Messagemsg,longdelayMillis){
if(delayMillis<
0){
delayMillis=0;
returnsendMessageAtTime(msg,SystemClock.uptimeMillis()+delayMillis);
publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
MessageQueuequeue=mQueue;
if(ue==null){
RuntimeExceptione=newRuntimeException(this
+"
sendMessageAtTime()calledwithnomQueue"
Log.w("
Looper"
e.getMessage(),e);
returnfalse;
returnenqueueMessage(queue,msg,uptimeMillis);
//最后调用此方法添加到消息队列中
privatebooleanenqueueMessage(MessageQueuequeue,Messagemsg,
longuptimeMillis){
msg.target=this;
//设置发送目标对象是Handler本身
if(mAsynchronous){
msg.setAsynchronous(true);
returnqueue.enqueueMessage(msg,uptimeMillis);
//添加到消息队列中
//在looper类中的loop()方法内部调用的方法
publicvoiddispatchMessage(Messagemsg){
if(msg.callback!
=null){
handleCallback(msg);
}else{
if(mCallback!
if(mCallback.handleMessage(msg)){
return;
handleMessage(msg);
通过源码我们可以知道,当我们调用sendEmptyMessage(int)发送消息后。
最终Handler内部会去调用enqueueMessage(MessageQueuequeue,Messagemsg)方法把发送的消息添加到消息队列MessageQueue中,同时还有设置msg.target=this此时就把当前handler对象绑定到msg.target中了,这样就完成了Handler向消息队列存放消息的过程。
这个还有一个要注意的方法dispatchMessage(Message),这个方法最终会在looper中被调用(这里我们先知道这点就行,后续还会分析)。
话说我们一直在说MessageQueue消息队列,但这个消息队列到底是什么啊?
其实在Android中的消息队列指的也是MessageQueue,MessageQueue主要包含了两种操作,插入和读取,而读取操作本身也会伴随着删除操作,插入和读取对应的分别是enqueueMessage和next,其中enqueueMessage是向消息队列中插入一条消息,而next的作用则是从消息队列中取出一条消息并将其从队列中删除。
虽然我们一直称其为消息队列但是它的内部实现并不是队列,而是通过一个单链表的数据结构来维护消息列表的,因为我们知道单链表在插入和删除上比较有优势。
至内MessageQueue的内部实现,这个属于数据结构的范畴,我们就不过多讨论了,还是回到原来的主题上来,到这里我们都知道Handler发送的消息最终会添加到MessageQueue中,但到达MessageQueue后消息又是如何处理的呢?
还记得我们前面说过MessageQueue是由Looper负责管理的吧,现在我们就来看看Looper到底是如何管理MessageQueue的?
publicfinalclassLooper{
//sThreadLocal.get()willreturnnullunlessyou'
vecalledprepare().
//存放线程的容器类,为确保获取的线程和原来的一样
staticfinalThreadLocal<
Looper>
sThreadLocal=newThreadLocal<
();
privatestaticLoopersMainLooper;
//guardedbyLooper.class
//消息队列
finalMessageQueuemQueue;
finalThreadmThread;
//perpare()方法,用来初始化一个Looper对象
publicstaticvoidprepare(){
prepare(true);
privatestaticvoidprepare(booleanquitAllowed){
if(sThreadLocal.get()!
thrownewRuntimeException("
OnlyoneLoopermaybecreatedperthread"
sThreadLocal.set(newLooper(quitAllowed));
//handler调用的获取Looper对象的方法。
实际是在ThreadLocal中获取。
publicstaticLoopermyLooper(){
returnsThreadLocal.get();
//Looper类的构造方法,可以发现创建Looper的同时也创建了消息队列MessageQueue对象
privateLooper(booleanquitAllowed){
mQueue=newMessageQueue(quitAllowed);
mRun=true;
mThread=Thread.currentThread();
//这个方法是给系统调用的,UI线程通过调用这个线程,从而保证UI线程里有一个Looper
//需要注意:
如果一个线程是UI线程,那么myLooper和getMainLooper是同一个Looper
publicstaticfinalvoidprepareMainLooper(){
prepare();
setMainLooper(myLooper());
if(Process.supportsProcesses()){
myLooper().mQueue.mQuitAllowed=false;
//获得UI线程的Looper,通常我们想Hanlder的handleMessage在UI线程执行时通常会newHandler(getMainLooper());
publicsynchronizedstaticfinalLoopergetMainLooper(){
returnmMainLooper;
//looper中最重要的方法loop(),该方法是个死循环,会不断去消息队列MessageQueue中获取消息,然后调dispatchMessage(msg)方法去执行
publicticvoidloop(){
finalLooperme=myLooper();
if(me==null){
NoLooper;
Looper.prepare()wasn'
tcalledonthisthread."
finalMessageQueuequeue=me.mQueue;
//死循环
for(;
;
){
Messagemsg=queue.next();
//mightblock
if(msg==null){
//Nomessageindicatesthatthemessagequeueisquitting.
//这里其实就是调用handler中的方法,而在Handler的源码中也可以知道dispatchMessage(msg)内部调用的就是handlerMessage()方法
msg.target.dispatchMessage(msg);
msg.recycle();
代码不算多,我们拆分开慢慢说,在Looper源码中我们可以得知其内部是通过一个ThreadLocal的容器来存放Looper的对象本身的,这样就可以确保每个线程获取到的looper都是唯一的
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 深入 Android 消息 机制 源码 详解 HandlerMessageQueue Looper 关系
![提示](https://static.bdocx.com/images/bang_tan.gif)
链接地址:https://www.bdocx.com/doc/21969020.html