android 消息系统Handler、MessageQueue、Looper源码学习

android消息系统

整体框架如图所示

在安卓的消息系统中,每个线程有一个Looper,Looper中有一个MessageQueue,Handler向这个队列中投递Message,Looper循环拿出Message再交由Handler处理。整体是一个生产者消费者模式,这四部分也就构成了android的消息系统。

先来看一个最简单的例子

        //这段代码在某个Activity的onCreate中
        Handler handler = new Handler(Looper.getMainLooper());
        Message msg = Message.obtain(handler, new Runnable() {
            @Override
            public void run() {
                Toast.makeText(getApplicationContext,"I am a message",Toast.LENGTH_SHORT).show();
            }
        });
        handler.sendMessage(msg);

效果就是,在当前窗口弹出I am a message,当然就其实现的效果而言完全多此一举。但是就分析android消息系统,却是很简单有效的例子。


源码分析

Message

Message中封装了我们常用的what、arg1、arg2、obj等参数,除此之外还有target:一个Handler类型,由前文可知一个Message最终还是交给一个Handler执行的,这个target存放的就是消息的目的地、callback,一个消息的回调,我们通过handler.post(new Runnable{…})发送的消息,这个Runnable即被存为callback。

首先来看消息的获取:

    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

    public static Message obtain(Handler h, Runnable callback) {
        Message m = obtain();
        m.target = h;
        m.callback = callback;

        return m;
    }

对照最开始的例子,Message.obtain(Handler h, Runnable callback)首先调用obtain获取了一个新的Message对象,然后为其设置了目的地Handler和回调函数callback,Message类中有很多不同的obtain函数,实际上只是为我们封装了一些赋值的操作。

再看Message.obtain()方法,sPoolSync是一个给静态方法用的静态锁,sPool是一个静态的Message变量,在消息的获取这里,android使用了享元模式,对于会被重复使用的Message消息,没有对每一次请求都新建一个对象,而是通过维护一个Message链表,在有空闲消息的时候从链表中拿Message,没有时才新建Message。

可以看到obtain中只有从链表中去Message和新建Message,而没有向链表中存储的过程。存储这部分就要看Message.recycle()了:

    public void recycle() {
        clearForRecycle();

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

回收过程,首先把原链表的头指向当前被回收消息的下一个节点,然后再把链表头指针知道当前节点即可。整个操作也就是将Message添加到链表的首位。


MessageQueue 消息队列

MessageQueue是在Looper中的,这点从Looper的构造函数可以看出来:

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

对于每个MessageQueue,是链表实现的消息队列。首先是入队操作:

boolean enqueueMessage(Message msg, long when) {
        if (msg.isInUse()) {
            throw new AndroidRuntimeException(msg + " This message is already in use.");
        }
        if (msg.target == null) {
            throw new AndroidRuntimeException("Message must have a target.");
        }

        synchronized (this) {
            if (mQuitting) {
                RuntimeException e = new RuntimeException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w("MessageQueue", e.getMessage(), e);
                return false;
            }

            msg.when = when;
            //mMessages是链表的头指针
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // 将消息插入到队列的首位
                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; // invariant: p == prev.next
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

next操作,包含取出和删除一条消息。

Message next() {
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            //从native层消息队列取出消息
            nativePollOnce(mPtr, nextPollTimeoutMillis);

            synchronized (this) {
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // 找到非异步的Message或者消息队列尾部的Message取出
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // 消息尚未到执行时间,下次循环挂起线程一段时间
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // 获取一个Message
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (false) Log.v("MessageQueue", "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }

                // 检查退出标志位
                if (mQuitting) {
                    dispose();
                    return null;
                }

                ...
        }
    }

Handler

Handler的作用是放入消息和处理消息,承担了生产者的工作和部分消费者的工作。

首先通过Handler发送一条消息:


public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

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);
    }
    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

通过一层一层嵌套,真正的逻辑在sendMessageAtTime,可以看到仅仅是执行了一下入队操作。作为生产者的工作也就执行完成,消费者部分后面要结合Looper分析。

除了sendMessage方法,常用的handler.post方法也是封装为Message,主要过程和上面相似。

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

Looper

Looper类中,Looper的实例获取是通过ThreadLocal的,ThreadLocal会为每一个线程提供一个副本,通过set和get方法每个线程获取作用域仅属于该线程的变量值。对于UI线程而言,会执行Looper.prepareMainLooper()来完成Looper的初始化:


public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
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));
    }

Looper.prepare()方法将当前线程的ThreadLocal设置了一个新的Looper对象,prepareMainLooper则是把当前线程的Looper对象赋值给类变量sMainLooper ,该方法在ActivityThread中调用,设置了一个全局的给UI线程使用的Looper。

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;

        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        //从Looper中获取MessageQueue,循环取出消息
        for (;;) {
            Message msg = queue.next();

            ...

            //将消息发送给目标处理。
            msg.target.dispatchMessage(msg);

            ...

            //回收消息,把消息放在消息池中
            msg.recycle();
        }
    }

主要逻辑很清晰,前面分析过msg.target是一个Handler,表示处理消息的目标,通过命令模式将消息交给对应Handler处理。下面是Handler中处理消息的方法:

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
private static void handleCallback(Message message) {
        message.callback.run();
    }
public void handleMessage(Message msg) {
    }

如果我们是通过handler.post的方法发送一条消息,那么直接执行callback中的逻辑。否则通过实现Callback接口回调,或者执行handleMessage,handleMessage也就是我们子类覆写的方法。可以看到,虽然逻辑部分是我们在Handler中实现的,但是调用的地方却是Looper的线程。因为一个Looper绑定一个线程,我们也可以通过比较Looper来比较线程。


总结

通过分析源码,可以知道android中可以通过Looper为每一个线程创建一个消息队里,UI线程的Looper在Activity启动前就已经初始化。那么对于我们自定义的线程,很明显也可以绑定Looper。

自定义线程绑定Looper,最明显的好处就是可以实现线程间通信了,同时由于借助了消息队列,也将并行转为串行实现了线程安全。看一个简单的例子:

        new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                handlerA = new Handler(Looper.myLooper()){
                    @Override
                    public void handleMessage(Message msg) {
                        Log.d("TAG", msg.obj.toString());
                    }
                };
                Looper.loop();
            }
        }).start();

上述在线程中创建绑定了一个Looper,然后新建一个和当前Looper绑定的Handler,这样可以通过该Handler向Looper的MessageQueue中添加消息,然后由Looper.loop取出消息并执行。

        Message msg = new Message();
        msg.obj = "i am main thread";
        handlerA.sendMessage(msg);

在主线程或者其它线程中获取handler然后发送消息,最终可以看到消息被线程接收并处理。这里msg的target也就是handlerA。注意如果线程工作结束,需要调用Looper.quit(),不然会因为Looper一直循环而导致线程无法结束。

最后经过上面的分析,流程图可以画的更为细致:

时间: 08-24

android 消息系统Handler、MessageQueue、Looper源码学习的相关文章

Android消息机制Handler解析(源码+Demo)

Handler是开发人员在面试过程中最常见的问题之一了,这篇文章将较为全面地对Handler进行解读,包括源码层,以及使用方法. 如果看完文章有疑问,欢迎在评论中一起探讨 基本内容包括: 看完文章之后,可以用这个图片进行复习. 一.什么是Handler Handler是Android提供用来更新UI的一套机制,也是一套消息处理机制,可以用它来发送消息,也可以用它来接收消息. 二.为什么使用Handler Android在设计之时,就封装了一套消息的创建.传递.处理机制,若不遵循这样的处理机制,就

Android的Handler,Looper源码剖析

之前了解android的消息处理机制,但是源码看的少,现在把Looper,Handler,Message这几个类的源码分析一哈 android的消息处理有三个核心类:Looper,Handler和Message.其实还有一个Message Queue(消息队列),但是MQ被封装到Looper里面了,我们不会直接与MQ打交道,因此我没将其作为核心类 Looper源码: Looper的字面意思是"循环者",它被设计用来使一个普通线程变成Looper线程.所谓Looper线程就是循环工作的线

Android开发之Handler和Looper的关系

关于Handler的总结. Message:消息,其中包含了消息ID,消息处理对象以及处理的数据等,由MessageQueue统一列队,终由Handler处理. Handler:处理者,负责Message的发送及处理.使用Handler时,需要实现handleMessage(Message msg)方法来对特定的Message进行处理,例如更新UI等. MessageQueue:消息队列,用来存放Handler发送过来的消息,并按照FIFO规则执行.当然,存放Message并非实际意义的保存,而

Android的软件包管理服务PackageManagerService源码分析

Android系统下的apk程序都是通过名为PackageManagerService的包管理服务来管理的.PacketManagerService是安卓系统的一个重要服务,由SystemServer启动,主要实现apk程序包的解析,安装,更新,移动,卸载等服务.不管是系统apk(/system/app),还是我们手工安装上去的,系统所有的apk都是由其管理的. 以android 4.0.4的源码为例,android4.0.4/frameworks/base/services/java/com/

Android应用程序启动过程——Launcher源码分析

当我们在Launcher界面单击一个应用程序图标时就会启动一个程序,那这一个过程究竟发生了些哪样呢?让我们跟踪Launcher源码来分析一下吧. 先上流程图: step1.追踪Launcher  从源码中我们可以发现Launcher其实也是一个程序,它继承于Activity.找到该文件中的onCreate()方法,代码片段如下: protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceSta

【从零之六&amp;完结】android口语对话系统(含全部源码)

做了一个半月终于完成了,下面这个就是我参考Olympus/RavenClaw系统编写的对话管理系统,目前实现了一个简单的航班查询,部分截图 目前能实现的功能: 1.航班查询,具体的航班信息是我自己编的,下一步可以写个爬虫把真实的数据爬下来.编的数据放到了res/raw/flightinfo.txt中.航班查询就设定了三个要素,时间,起始地和目的地,想更全面的话可以增加任务树的agent即可. 2.在MainActivity中可以语音打开已安装的应用程序,这在前一篇博文也介绍过了. 3.别的功能就

50个Android开发人员必备UI效果源码[转载]

50个Android开发人员必备UI效果源码[转载] http://blog.csdn.net/qq1059458376/article/details/8145497 Android 仿微信之主页面实现篇Android 仿微信之界面导航篇Android 高仿QQ 好友分组列表Android 高仿QQ 界面滑动效果Android 高仿QQ 登陆界面Android 对Path的旋转效果的拓展Android高仿360安全卫士布局源码Android SlidingDrawer 滑动抽屉效果Androi

[Android阅读代码]android-async-http源码学习一

android-async-http 下载地址 一个比较常用的Http请求库,基于org.apache.http对http操作进行封装. 特点: 1.每一个HTTP请求发生在UI线程之外,Client通过回调处理HTTP请求的结果,使得Client代码逻辑清晰 2.每一个请求使用线程池管理执行 3.支持gzip , cookie等功能 4.支持自动重试连接功能 [Android阅读代码]android-async-http源码学习一,布布扣,bubuko.com

android猜猜红桃A游戏源码

一个简单的猜扑克游戏,很适合初学者,点击TextView扑克由反面变为正面,未点击的TextView有透明效果,点击再玩一次按钮,运行洗牌程序undefined <ignore_js_op><ignore_js_op> 详细说明:http://android.662p.com/thread-876-1-1.html android猜猜红桃A游戏源码,布布扣,bubuko.com