Android中的消息系统————Handler,MessageQueue与Looper
来源:互联网 发布:visual c 知乎 编辑:程序博客网 时间:2024/06/14 06:59
我们都知道,Android系统强制要求我们将更新ui等操作放在主线程中进行,而网络请求,读取文件等耗时操作则通常会放到子线程中运行,因此,在Android开发中经常需要在不同的线程之间进行切换。而Android系统为我们提供了消息系统来进行异步消息的处理,因此我们有必要了解一下Android消息系统的工作原理。
Handler,MessageQueue与Looper之间的关系
我们先来看一下Handler,MessageQueue与Looper三者之间的关系。首先,Handler对象负责发出一个消息,这个消息最终会被提交到一个MessageQueue之中,这个MessageQueue则是一个专门用来存储Message的队列集合。而Looper对象内部有一个无限循环,它会不断的从这个MessageQueue中取出消息,并将其交给发出该消息的Handler进行处理。
需要注意的是,我们可以在一个线程中创建很多个Handler对象,但是每个线程只会对应一个Looper和MessageQueue对象。Handler对象在初始化的时候会和该线程所对应的Looper及MessageQueue对象进行绑定。因此,Handler在哪个线程中创建,它发出的消息最终就会在哪个线程中执行。接下来我们通过源码来详细的看一下它们的工作原理。
消息系统的创建
先从消息系统的创建说起。Android中主线程的消息系统会在主线程启动时默认被创建,而子线程的消息系统默认则不会被创建,我们需要在子线程中手动调用Looper.prepare()和Looper.loop()这两个静态方法才可以开启子线程的消息系统。接下来我们以主线程为例看一下消息系统的创建过程。
Android主线程的消息系统是在ActivityThread类的main方法中被创建的,我们看一下main方法的代码:
public static void main(String[] args) { ... Looper.prepareMainLooper(); //先调用prepareMainLooper方法 ActivityThread thread = new ActivityThread(); thread.attach(false); if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } if (false) { Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread")); } Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); Looper.loop(); //然后调用loop方法 throw new RuntimeException("Main thread loop unexpectedly exited");//因为Looper.loop()实际上是执行了一个无限循环,所以一般情况下不会走到这句,除非出现异常导致循环中断 }
我们可以看到,与子线程不同的是,主线程的消息系统在启动时调用的是Looper.prepareMainLooper方法而非prepare方法。在调用完prepareMainLooper方法之后又调用了Looper.loop方法。我们看一下prepareMainLooper方法:
public static void prepareMainLooper() { prepare(false);//调用prepare方法 synchronized (Looper.class) { if (sMainLooper != null) { throw new IllegalStateException("The main Looper has already been prepared."); } sMainLooper = myLooper();//通过myLooper方法将创建好的looper对象赋值给sMainLooper全局对象 } }
可以看到prepareMianLooper方法中其实也是调用的prepare方法,prepare方法的源码如下:
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)); }
在prepare方法中,系统直接通过new关键字创建了一个Looper对象,并将这个Looper对象放在了一个名为sThreadLocal的全局对象中。
这个sThreadLocal对象是一个定义在Looper中的类型为ThreadLocal的全局对象,并且被static final所修饰。ThreadLocal是java所提供的一个类,我们可以通过ThreadLocal的set(T value)方法来给这个ThreadLocal对象设置一个变量,但值得注意的是,通过ThreadLocal来维护的变量是线程私有的,各个线程通过ThreadLocal.get()方法取得的对象都是独立的,他们之间的操作都互不影响的。主线程将一个Looper对象设置给了一个ThreadLocal,其他子线程是无法通过这个ThreadLocal对象来获取主线程的Looper对象的。因此,Android通过ThreadLocal来维护Looper对象,就做到了每个线程对应一个独立的Looper对象。
我们再来看一下Looper的构造方法:
private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }
可见Looper对象在初始化时直接创建了一个MessageQueue集合,并赋值给成员变量mQueue。因此MessageQueue对象被Looper对象所持有。
现在Looper和MessageQueue对象已经创建完成了。我们再回到prepareMainLooper方法中。在通过prepare方法创建完Looper对象和MessageQueue对象后,系统又调用了Looper的myLooper方法,而myLooper方法返回的其实是刚才创建的该线程所独有的Looper对象,这里即是主线程所对应的Looper对象。系统将这个对象赋值给了一个全局变量sMainLooper,方便之后使用getMainLooper方法来直接拿取主线程的Looper对象。myLooper方法的代码如下:
public static @Nullable Looper myLooper() { return sThreadLocal.get(); }
至此准备工作都已经完成了,系统只需要再通过Looper.loop方法让消息系统运行起来即可,loop方法的源码如下:
public static void loop() { final Looper me = myLooper(); //获取looper对象 if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } final MessageQueue queue = me.mQueue; //获取MessageQueue对象 ... for (;;) { Message msg = queue.next(); // 从MessageQueue对象中获取一个消息 if (msg == null) { return; } ... try { msg.target.dispatchMessage(msg);//将这个消息分发给相应的Handler进行处理 end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis(); } finally { if (traceTag != 0) { Trace.traceEnd(traceTag); } } ... msg.recycleUnchecked(); } }
loop方法的代码较多,为了便于理解,省去了部分代码。首先通过myLooper方法获取当前线程对应的Looper对象,然后又通过me.mQueue拿取了looper对象内部的MessageQueue。之后开启了一个无限循环,在循环中,首先通过queue.next()取出MessageQueue中存储的一个消息,如果这个消息不为null,则通过msg.target.dispatchMessage(msg)分发给相应的Handler进行处理。msg.target其实就是发出该消息的Handler对象。Handler在发出一个消息时会将自身存储在Message内部的target变量中,之后在分析Handler时会讲到。我们先来看一下dispatchMessage方法的源码:
public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); //通过handleCallback来执行Message对象内部的Runnable } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); //将Message交给handleMessage方法进行处理 } }
首先会检查msg的callback对象是否为null,这个callback是一个Runnable类型的对象,我们知道Handler可以发出两种类型的消息,一种是通过sendMessage等方法直接发送一个Message消息对象,另一种是通过则会通过post方法发送一个Runnable对象。如果发送的是一个Runnable对象,Handler在内部也会将这个Runnable对象封装成一个Message对象,并将原来的Runnable对象赋值给Message的callback变量。如果msg.callback不为null,说明该消息原本是通过Handler的post方法发出的一个Runnable,那么会通过handleCallback方法直接执行这个Runnable。如果msg.callback对象为null,那么就将这个msg交给Handler的handleMessage方法进行处理。我们在创建Handler对象时通常会重写handleMessage方法来实现我们想要的逻辑。
由于loop方法内部其实是一个无限循环,因此Looper对象会不断的从MessageQueue对象中拿取消息并分发给对应的Handler进行处理。需要注意的是,如果我们在子线程中调用了Looper.loop方法,那么Looper中的无限循环会导致子线程阻塞,因此当我们在子线程中使用了Looper后,应该在适当的时机调用looper对象的quit或quitSafely方法来退出这个Looper。
至此整个主线程的消息系统已经创建完成并且开始工作了,接下来我们看一下Handler是如何将一个消息提交给相应的MessageQueue的。
消息的发送过程
Handler对象负责消息的发送和处理。我们先来看一下Handler对象的构造方法:
public Handler(Callback callback, boolean async) { ... mLooper = Looper.myLooper();//与Looper进行了绑定 if (mLooper == null) { throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare()"); } mQueue = mLooper.mQueue;//与MessageQueue绑定 mCallback = callback; mAsynchronous = async; }
Handler对象有许多重载的构造方法,但这些构造方法最终都是调用的Hanler(Callback callback, boolean async)这个构造方法。在这个构造方法中,首先通过Looper.myLooper获取到了一个Looper对象并赋值给了自己的一个成员变量,前面我们说过,myLooper对象返回的是当前线程所独有的Looper对象,这样一来Handler,Looper和线程之间就一一对应起来了。因此,无论handler在哪个线程发出消息,这个消息最终都会在handler初始化时所绑定的Looper所对应的线程中进行处理。
前面我们说过,Handler可以发出两种类型的消息,一种是通过sendMessage方法发送一个Message对象,另一种是通过post方法发送一个Runnable。我们先来看一下sendMessage方法和post方法的源码:
public final boolean post(Runnable r) { return sendMessageDelayed(getPostMessage(r), 0); } public final boolean sendMessage(Message msg) { return sendMessageDelayed(msg, 0); }
可以看到无论是post方法还是sendMessage方法最终都是调用的sendMessageDelayed方法,不同的是在post方法中先调用了getPostMessage方法来对Runnable对象进行了一些处理,我们来看一下getPostMessage方法:
private static Message getPostMessage(Runnable r) { Message m = Message.obtain(); m.callback = r; return m; }
正如我们前面所说的,Handler将通过post方法提交的Runnable封装在了一个Message对象内的callback变量里。接下来我们看一下sendMessageDelayed方法:
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); }
可见在sendMessageDelayed方法中又调用了sendMessageAtTime方法。而在sendMessageAtTime方法中,先拿取了初始化时绑定的MessageQueue对象,然后将这个MessageQueue和Message对象一起传给了enqueueMessage方法:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis); }
在enqueueMessage方法中,Handler将自身赋值给了Message的target变量,前面在讲loop方法的时候也说过,Message最终会通过这个target变量来获取对应的Handler,因此,Message最终会被发出该消息的Handler所处理。之后又调用了MessageQueue的enqueueMessage方法,最终将这个Message提交给了对应的MessageQueue对象。MessageQueue实际上是一个单链表型的数据结构,链表中的前一个元素都会持有下一个元素的引用,而MessageQueue只需要持有第一个元素的引用即可。看一下MessageQueue的enqueueMessage方法:
boolean enqueueMessage(Message msg, long when) { ... msg.when = when; Message p = mMessages;//当前链表中的首个元素 boolean needWake; if (p == null || when == 0 || when < p.when) {//如果链表中没有元素或者要插入的message的执行时间早于队列中的首个元素 msg.next = p; mMessages = msg; needWake = mBlocked; } else { needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; for (;;) { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; // prev.next = msg; } ... } return true; }
当插入一个新的Message时,MessageQueue首先会判断当前链表中是否存在元素,如果集合中的首个元素为null,那么就说明这个集合现在也是空的。如果集合中不存在元素,或新插入的Message不需要延时执行,或者要插入的Message的执行时间要早于集合中的首个元素的话,那么直接将链表中的首个元素设置为新插入的Message的下个元素,并将新插入的元素设置为队列中的首个元素。如果不满足上述条件的话,那么会从头开始遍历集合,根据Message的执行时间来将Message插入到集合中的相应位置。可见MessageQueue虽然名字中带有Queue,但并不是一个标准的队列,因为队列只允许在表的后端插入元素。
至此,一个Message就成功被Handler提交到了Message中了。
由于Android系统的消息机制比较复杂,本人技术水平非常有限,本文中难免会出现错误或者表达不准确的地方,希望大家能够帮忙指出,谢谢!
- Android中的消息系统————Handler,MessageQueue与Looper
- Android消息机制 — Handler-Looper-MessageQueue
- Android消息处理机制——Looper,Handler,Message,MessageQueue
- Android Handler消息机制源码分析——第一部分:Looper与MessageQueue
- Android线程—Handler、Looper、Message、MessageQueue
- Android学习札记26:深入理解Android中的消息处理机制——Thread、Looper、MessageQueue和Handler(1)
- Android学习札记28:深入理解Android中的消息处理机制——Thread、Looper、MessageQueue和Handler(2)
- Android进阶——Android消息机制之Looper、Handler、MessageQueue
- Android开发之漫漫长途 VII——Android消息机制(Looper Handler MessageQueue Message)
- 解析Android消息处理机制 ——Handler/Thread/Looper & MessageQueue
- Android消息处理机制——Looper,Handler,Message,MessageQueue,Thread
- android学习之——Handler、Looper、MessageQueue
- Android异步处理——Handler、Looper、Message、MessageQueue
- Android开发之多线程 ——Handler message messageQueue Looper
- Android消息处理系统——Looper、Handler、Thread
- Android消息处理系统——Looper、Handler、Thread
- android中的Handler,Looper,MessageQueue
- android 消息系统Handler、MessageQueue、Looper源码学习
- 基数排序
- 解决64位2013word无法安装32位Visio的问题
- ubuntu虚拟机安装lamp遇到的问题 configure: error: libXpm.(a|so) not found.
- Ubuntu 16.04 安装程序的三种方式
- 使用 Builder 模式构造 JavaBean 的好处
- Android中的消息系统————Handler,MessageQueue与Looper
- 《科研有方——科研需要“想好”再“做”》笔记 Chapter2:如何做科研
- stm32_010_stm32IO操作例子
- 一个码农吊轨的工作经历和成长感悟
- 欢迎使用CSDN-markdown编辑器
- HDU
- 三个线程轮流执行顺序打印ABC(二):使用Lock+Condition实现
- 跳表
- MYSQL中的limit的用法