解android的Handler之谜
来源:互联网 发布:汽车导航软件安装 编辑:程序博客网 时间:2024/06/08 10:37
说到Android的Handler,我们用到最多的就是用来在子线程中通知主线程更新UI,但是,我们有思考过它们内部是怎么实现的吗,现在就带大家一步一步来揭开它的神秘面纱吧。
要说Handler,当然得先从它的构造函数说起:
public Handler() { this(null, false); } public Handler(Callback callback) { this(callback, false); } public Handler(Looper looper) { this(looper, null, false); } public Handler(Looper looper, Callback callback) { this(looper, callback, false); } public Handler(Looper looper, Callback callback, boolean async) { mLooper = looper; mQueue = looper.mQueue; mCallback = callback; mAsynchronous = async; } 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; }从上面的构造函数当中可以看出,最关键的几个参数有looper、looper.mQueue、callback、async,针对这几个参数,这里稍微做下介绍:
looper::一个循环工具,用来循环取出消息队列中的消息;
looper.mQueue: looper当中的消息队列,用来存放消息的;
callback:handler中用来对handleMessage方法进行拦截的回调(后面的分析中大家可以看到);
async:是否异步,默认都是异步;
看到这里,我们先停下对上面几个类的进一步分析,先按照正常的使用流程来说,一般我们定义好一个handler后,在使用的时候一般是调用相关sendMeassge方法:
public final boolean sendMessage(Message msg) { return sendMessageDelayed(msg, 0); } public final boolean sendEmptyMessage(int what) { return sendEmptyMessageDelayed(what, 0); } public final boolean sendEmptyMessageDelayed(int what, long delayMillis) { Message msg = Message.obtain(); msg.what = what; return sendMessageDelayed(msg, delayMillis); } public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) { Message msg = Message.obtain(); msg.what = what; return sendMessageAtTime(msg, uptimeMillis); } 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); }
我们看到,最终都是调用了enqueueMessage方法,那就进去一探究竟:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis); }好了, 关键点来了,这里有一个关键的赋值,后面要用到,那就是把handler本身赋值给了message.target,然后把消息存入了消息队列MessageQueue,handler发送消息也就到此结束了。
那么handler的handleMessage方法究竟是怎么触发的呢,说到这里,我们就来扒一扒上面提到的几个类:
Looper:
打开API文档,我们看到有这样一段注释:
* <pre> * class LooperThread extends Thread { * public Handler mHandler; * * public void run() { * Looper.prepare(); * * mHandler = new Handler() { * public void handleMessage(Message msg) { * // process incoming messages here * } * }; * * Looper.loop(); * } * }</pre>
我们看到,在new Handler之前,要先调用Looper.prepare(),那么这个方法里面做了什么呢?
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)); }可以看到,这里最后调用到了sThreadLocal.set()方法,把创建好的looper对象存入sThreadLocal中,sThreadLocal可以看作一个全局静态容器(具体代码分析就不在这里做继续展开了),用来存放looper的,并且一个线程当中只能存在一个looper,也就是说,一个线程当中只能调用一次prepare方法。
再来看看Looper的构造函数中做了什么事情呢:
private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }我们看到 这里最主要做了两件事情,new出来消息队列,由单个线程中looper的唯一,可以知道messageQueue也是唯一的,该构造函数做的第二件事情就是把当前线程的ID赋值到一个变量,后续用来做是否在当前线程的判断。
好了 Looper.prepare()方法我们我们分析过了,new Handler我们也分析过来,接下来就是Looper.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 final Printer logging = me.mLogging; if (logging != null) { logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what); } final long traceTag = me.mTraceTag; if (traceTag != 0 && Trace.isTagEnabled(traceTag)) { Trace.traceBegin(traceTag, msg.target.getTraceName(msg)); } try { msg.target.dispatchMessage(msg); } finally { if (traceTag != 0) { Trace.traceEnd(traceTag); } } 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(); } }方法比较长,我们慢慢分析:
final Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); }这里获取当前线程的looper,如果为null,则会抛出异常,所以在一开始的时候,我们要调用Looper.prepare()方法创建looper对象。
// 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();确定当前的线程是否是创建looper的线程,并继续跟踪
for (;;) { Message msg = queue.next(); // might block if (msg == null) { // No message indicates that the message queue is quitting. return; }关键代码到了,我们看到,这是一个死循环,目的就是循环从消息队列当中取出消息,如果消息为null,则跳出循环了。
try { msg.target.dispatchMessage(msg); } finally { if (traceTag != 0) { Trace.traceEnd(traceTag); } }省去了部代码的分析,到了这里就是我们整篇文章的关键了,看看,msg.target这个是什么,如果不记得了,看看本文之前提到的,msg.target就是消息message在创建的时候赋值的handler对象,这里就直接调用了handler的dispachMessage()方法分发消息了。
那么我们来分析下handler的dispachMessage()方法中做了什么:
public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }这个方法很简单,大家自行分析哈。(前面提到的handler中callback对handleMesage的拦截也是在这里实现的)。
好了,到了这里,整个Handler之谜,我们已经理清了基本流程了,下面就做一下基本的总结:
1、Looper.prepare():创建当前线程的looper,且一个线程只能调用一次
2、new Handler():创建handler,用来发送和接受消息,在构造函数中,关联了looper和looper中的消息队列管理器MessageQueue。
3、Looper.loop():开始死循环,循环从消息管理队列MessageQueue当中取出消息,取出消息后调用message.target(也就是handler)的dispachMessage()方法分发消息。
4、总体来说就是:在线程A当中创建一个消息队列,并开启一个死循环,不停读取消息队列中的消息,然后在B线程中调用A线程创建的handler往A线程的消息队列中存入消息,这时A的死循环Looper对象就能取到这个消息了。
本文写的比较粗糙,如有错误欢迎留言指出
- 解android的Handler之谜
- Android之handler的使用
- android之handler的总结
- Android 之 Handler的分析
- android之handler的刨根问底
- android之Handler的使用
- Android之Handler的用法
- Android之Handler的使用
- android之路之Handler的使用
- Android之我对handler的理解
- Android学习之Handler的使用
- Android学习之Handler的使用
- Mars之android的Handler(2)
- Android开发之Handler的使用
- android基础之Handler的使用(一)
- Android之Handler与AsyncTask的区别
- Android之Handler的用法(笔记)
- Android之Handler的用法(笔记)
- 新建一个IOS工程步骤
- Contest 2:Temperature Conversion
- 【技术详解】SequoiaDB数据分区简介
- MethodReplacer替换方法实例
- 图像匹配 一些基本算法
- 解android的Handler之谜
- java向上转型和向下转型
- 原子操作
- jvm概念梳理
- (六)MapReduce特点
- Burp Suite 介绍
- 使用Filter-policy Route-policy ACL 实现对RIP路由发布的控制
- datasets api 问题
- webview内的iframe中的事件不可用