Android消息机制浅析——原理探究

一、概述

在Android消息机制浅析——基本使用一文中,我们对Android消息机制中的Handler和Message有了一个基本的了解,能够进行线程之间的通信。如果我们稍加注意,会注意到Hanlder的多个构造函数中会提到一个Looper的类。所以,在这次源码探究中,我们会涉及到Looper、Handler、Message、MessageQueue几个概念。

  • Message:消息体对象,可用于存储我们要传送的数据。
  • MessageQueue:消息体队列,用于管理Handler发送的Message对象。
  • Looper:循环控制器,用于控制我们的消息管理,消息的取出与使用。
  • Handler:消息的处理器,用于消息的发送与处理。

它们各司其职,就完成了Android整个消息的流通。

二、源码探究

1、Message对象

Message在整个Android的消息机制中充当着消息体的角色,它用于包装存储我们的数据在消息之间进行传递。如何创建一个Message对象呢?

    /** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
    */
    public Message() {
    }

我们可以看到它有一个无参的构造函数,但是系统并不建议我们使用它的构造函数来创建Message对象,而是建议我们使用obtain()方法来创建Message对象,显然这个方法肯定是个静态方法。

     public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

先判断sPool这个Message对象是否为空,如果不为空,就将这个Message对象进行复用,同时对这个Message的标识信息进行初始化,去除标记,然后将sPoolSize减1.如果为null,则通过构造函数进行创建一个新对象。通过对比构造函数,我们发现通过obtain方法进行创建对象,提供了效率,减少了不必要的Message对象创建。

我们在Android消息机制浅析——基本使用中简单介绍了Message对象,我们知道它有许多成员变量用于帮助我们存储数据。我们从源码中简单的摘要出来。

    public final class Message implements Parcelable {
        /**
         * 用户定义的区别标识
         * with other handlers.
         */
        public int what;

        /**
         * 用于存储一些简单的int值
         */
        public int arg1; 
        public int arg2;
        //存储Object对象
        public Object obj;
        //存储Bundle数据
        Bundle data;
        //存储Hanlder对象,与发送它的Hanlder进行绑定关系
        Handler target;
        //Message的标识,正在使用
        static final int FLAG_IN_USE = 1 << 0;
        static final int FLAG_ASYNCHRONOUS = 1 << 1;
        static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
        //Message的标识
        int flags;
        //有时为了保存一些信息,用于设置next
        Message next;
        //存储Runnable
        Runnable callback;
        .....
    }

在源码中我们同样可以发现obtain()方法的几个重载函数。

  • public static Message obtain(Message orig)
  • public static Message obtain(Handler h)
  • public static Message obtain(Handler h, Runnable callback)
  • public static Message obtain(Handler h, int what)
  • public static Message obtain(Handler h, int what, int arg1, int arg2)
  • public static Message obtain(Handler h, int what, 
    int arg1, int arg2, Object obj)

在这几个重载函数中,我们可以在obtain函数进行一些变量的初始化,完成Message的创建。我们从中摘取public static Message obtain(Handler h, int what, 
int arg1, int arg2, Object obj) 给大家示例。

    public static Message obtain(Handler h, int what, 
            int arg1, int arg2, Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.arg1 = arg1;
        m.arg2 = arg2;
        m.obj = obj;

        return m;
    }

在这个构造方法中,我们要着重注意一点:Message与Hanlder的绑定,Message通过target存储handler就行关系的绑定。

当一个消息体完成它的使命后,它就该被销毁回收,所以这里Message通过recycle()方法用于销毁Message对象。

    public void recycle() {
        if (isInUse()) {
            if (gCheckRecycle) {
                throw new IllegalStateException("This message cannot be recycled because it "
                        + "is still in use.");
            }
            return;
        }
        recycleUnchecked();
    }

在Message进行回收的时候,首先判断该Message对象是否正在使用,如果正在使用,判断gCheckRecycle变量是否为真如果为true,则抛出异常并返回,为false则直接返回。补充下gCheckRecycle这个成员变量。

private static boolean gCheckRecycle = true;

这个对象初始值为true,通过方法updateCheckRecycle进行更改:

    public static void updateCheckRecycle(int targetSdkVersion) {
        if (targetSdkVersion < Build.VERSION_CODES.LOLLIPOP) {
            gCheckRecycle = false;
        }
    }

如果系统版本小于21,则为false。(深入原因估计是系统源码又改了)。 
当一个Message不处于正在使用的时候,系统通过recycleUnchecked()方法进行回收。

    /**
     * Recycles a Message that may be in-use.
     * Used internally by the MessageQueue and Looper when disposing of queued Messages.
     */
    void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

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

回收所做的工作就是清除一个Message对象的细节属性,置空初始化。 
小结: 
Message作为消息体在消息机制中存在,系统建议我们使用Message.obtain()方法进行创建一个Message对象,目的是为了提高使用率。同时对于一个正在使用中的Message对象是无法进行回收的,系统报出异常“This message cannot be recycled because it is still in use.”

2、MessageQueue对象

消息队列,在消息机制中充当仓库的作用,用于存储Message对象。它持有的Message对象通过Looper进行分发,同时Message对象不是直接通过MessageQueue对象的方法进行添加,而是通过Handler进行添加。

既然作为一个消息体的“仓库”,我们只重点关心它的添加、删除、遍历即可。

  • boolean enqueueMessage(Message msg, long when):添加Message
  • void removeMessages():删除指定的message
  • Message next():遍历Message对象

(1)、boolean enqueueMessage(Message msg, long when) 
用于添加我们的Message。

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

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

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                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;
    }

enqueueMessage的整体流程: 
首先判断Message对象的target是否为null(所附属的Handler,说白了就是发送源是否为null),如果为null,抛出异常“Message must have a target”。接着判断该Message是否正在使用,如果是,抛出异常“ This message is already in use.”。当上面条件不符合,则该Message是合法的,才开始添加到MessageQueue中。接着判断mQuitting是否为true,如果为true,抛出异常“sending message to a Handler on a dead thread”,说明依附的Hanlder所在的线程已死。所有的检查都不符合,则开始进行添加,首先通过markInUse()方法设置Message的flags |= FLAG_IN_USE;接着设置when参数,最后插入到链表中。下面我们就开始分析这个Message的插入流程顺序: 
enqueue

(2)、void removeMessages() 
用于删除我们指定的Message。它有两个重载函数:

  • void removeMessages(Handler h, int what, Object object)
  • void removeMessages(Handler h, Runnable r, Object object)

原理都相同,挑一个研究下。

    void removeMessages(Handler h, int what, Object object) {
        if (h == null) {
            return;
        }

        synchronized (this) {
            Message p = mMessages;

            // Remove all messages at front.
            while (p != null && p.target == h && p.what == what
                   && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();
                p = n;
            }

            // Remove all messages after front.
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && n.what == what
                        && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }
        }
    }

源码也不难,主体流程就是根绝链表节点遍历Message对象,然后比较我们指定的what、object,如果相同则删除,继续遍历下去,直到结束。

(3)、Message next()

    Message next() {
      ....
        Message prevMsg = null;
        Message msg = mMessages;
        if (msg != null && msg.target == null) {
            // Stalled by a barrier.  Find the next asynchronous message in the queue.
            do {
                prevMsg = msg;
                msg = msg.next;
            } while (msg != null && !msg.isAsynchronous());
        }
        if (msg != null) {
            if (now < msg.when) {
                // Next message is not ready.  Set a timeout to wake up when it is ready.
                nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
            } else {
                // Got a 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);
                return msg;
            }
        } else {
            // No more messages.
            nextPollTimeoutMillis = -1;
        }
        ...
    }

针对next()方法,我只挑出了里面的遍历部分,同样的逻辑根据链表头进行MessageQueue的遍历,返回msg。

3、Looper对象

我想把Looper对象比作“电机”、“发动机”一点不为过。我们知道Thread默认情况下是不具备消息循环的。为了使它们具备,我们需要在线程中调用prepare()方法,同时通过loop()方法获取Message。 例如:

class LooperThread extends Thread {
        public Handler mHandler;
        public void run() {
            //将当前线程初始化loop线程
            Looper.prepare();

            mHandler = new Handler() {
               public void handleMessage(Message msg) {
                    // process incoming messages here
                }
            };
            //开始循环消息队列
            Looper.loop();
        }
    }

下面就开始对Looper源码的探究吧!首先看下常见的方法

  • prepare()
  • loop()
  • myLooper()
  • myQueue()

(1)、Looper.prepare() 
这个方法用于将我们的线程转换为loop线程,它做了哪些工作?

public final class Looper {
        private static final String TAG = "Looper";

        // sThreadLocal.get() will return null unless you've called prepare().
        static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
        private static Looper sMainLooper;  // guarded by Looper.class

        final MessageQueue mQueue;
        final Thread mThread;

        private Printer mLogging;

         /** Initialize the current thread as a looper.
          * This gives you a chance to create handlers that then reference
          * this looper, before actually starting the loop. Be sure to call
          * {@link #loop()} after calling this method, and end it by calling
          * {@link #quit()}.
          */
        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));
        }
        //其它
    }

我们可以看到,prepare方法就是给当前Thread设置Looper对象,同时也可以知道每个Thread只能有一个Looper对象,核心就是讲线程依附的Looper对象转换为ThreadLocal类型。

(2)、Looper.loop() 
在loop方法里,进行Message的遍历获取。

  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
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);

            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();
        }
    }

    public static Looper myLooper() {
        return sThreadLocal.get();
    }

首先通过myLooper()方法获取Looper对象,如果Looper对象为null,则抛出异常“No Looper; Looper.prepare() wasn’t called on this thread.”。获取该Looper对象中的MessageQueue对象,进行遍历获取Message对象,同时将取出的Message进行销毁。这里我们着重注意msg.target.dispatchMessage(msg);这个方法就是调用我们的Handler的dispatchMessage方法,然后进行消息的处理。

(2)、MessageQueue myQueue() 
获取Looper对象中的MessageQueue。

    public static MessageQueue myQueue() {
        return myLooper().mQueue;
    }

小结:

  1. Looper中包含一个MessageQueue用于存储我们的Message消息队列。
  2. 每个线程只能有一个Looper对象,且该Looper对象为ThreadLocal类型
  3. 通过Looper.prepare()方法可以将线程变成Looper线程。

4、Handler对象

我们在上篇文章中也简要的领略了Handler的使用,它提供了多个方法供我们发送消息,同时进行消息的处理。它有多个重载构造方法。

  • public Handler()
  • public Handler(Callback callback)
  • public Handler(Looper looper)
  • public Handler(Looper looper, Callback callback)
  • public Handler(boolean async)
  • public Handler(Callback callback, boolean async)
  • public Handler(Looper looper, Callback callback, boolean async)

同时Handler内部对应着以下几个成员变量:

final MessageQueue mQueue;
    final Looper mLooper;
    final Callback mCallback;
    final boolean mAsynchronous;
    IMessenger mMessenger;

它里面包含一个Looper对象、MessageQueue对象。Handler的构造方法最后都归结到两个构造方法上。

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;
    }

在Handler中通过

mLooper = looper;
mQueue = looper.mQueue;

建立Looper、MessageQueue之间的关系。

我们看下Hanlder的消息发送、消息处理的方法。

  • sendXXXXMessage()
  • postXXXX()
  • handleMessage(Message msg):消息处理

(1)、sendXXXXMessage() 
用于发送Message消息序列,它们最后都是调用sendMessageAtTime()方法。

    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);
    }

将消息插入队列,同时在enqueueMessage方法进行Handler与msg的绑定。我们发送的消息,需要我们在handleMessage(Message msg)方法中进行处理:

  public interface Callback {
        public boolean handleMessage(Message msg);
    }

    /**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }

这是一个空方法,子类需要重写它进行业务逻辑的处理。这里我们就需要注意构造函数中的Callback接口,这个接口就是封装了我们的handleMessage,用于我们的消息回调。

(2)、postXXXX() 
用于发送Runnable的线程处理,可以在Runnable线程中直接操作UI。

   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;
    }

我们可以看到在post方法中,同样是调用sendMessageXX系列,同时通过getPostMessage()方法获取一个Message对应,该Meesage的callback接口绑定到Runnable上。后面就是Looper进行变通过dispatchMessage()方法,执行Runnable中的内容。这里补充一下dispatchMessage方法的介绍:

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

这个方法中首先判断msg.callback是否为null,这是针对我们使用post发送消息处理的,然后在进行mCallback是否为null,这是针对我们的sendXXMessage进行处理的。

至此,总体的流程中的各个部分,我们已经梳理完毕。下面就总结一下,借用引用CodingMyWorld的图:

codemyword

我就依照此图总结下: 
1、首先创建Message对象,Message对象用Hanlder target字段存储Hanlder,实现该Message与发送源Handler的关系绑定,因为一个Handler可以发送多个消息,同样一个Message也可以被多个Handler发送,确保最后调用正确的Handler来处理该消息的回调。用Runnable callback存储Runnable。 
2、创建Handler时,会指定Handler内部的Looper成员变量,同时制定成员变量mQueue = looper.mQueue; 
3、Handler通过sendXXMessage()方法发送消息,该系列方法的本质是调用sendMessageAtTime方法,该方法显示判断MessageQueue是否为null,然后调用enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)实现Message与Handler的绑定(msg.target = this),在调用MessageQueue的插入队列方法,形成MessageQueue消息组。该消息组就是Looper内部的mQueue。 
4、通过第3步,Looper内部的MessageQueue就建立了,Looper内部通过loop()方法进行遍历MessageQueue,通过msg.target.dispatchMessage(msg);调用Handler的分发事件实现消息回调的处理。

至此,整个流程就梳理通了。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值