Android——消息机制

最近在看Android源码的东西，这几天在看Android中消息机制，然后就来整理一下自己所学的东西。

我们平时都有接触到Android消息机制，最常见的用法就是在一个子线程中进行耗时的操作，然后再返回到主线程中进行UI的更新，当然还有别的用法。我们一般使用消息机制大都是从Handler出发，所以可以说Android的消息机制讲的就是Handler的机制，既然说到Handler那也就离不开Looper、MessageQueue，接下来一一进行探讨。

Handler的初始化：

首先我们需要new一个Handler，有如下几种方法：

在new Handler（）时会对该线程中的Looper进行检查，如果没有Looper会报错

public Handler(Callback callback, boolean async) {        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.myLooper()中获取到mLooper，然后进行检查，那就先来看看Looper.myLooper()内部的实现：

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

sThreadLocal是Looper里面的一个ThreadLocal<Looper>

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

ThreadLocal的作用是在每一个线程中维护一个副本，里面包含一个 Looper的实例，可以从ThreadLocal的get()方法中看出：

 public T get() {        // Optimized for the fast path.        Thread currentThread = Thread.currentThread();        Values values = values(currentThread);        if (values != null) {            Object[] table = values.table;            int index = hash & values.mask;            if (this.reference == table[index]) {                return (T) table[index + 1];            }        } else {            values = initializeValues(currentThread);        }        return (T) values.getAfterMiss(this);    }

get()方法中首先是拿到当前的线程，然后通过values()拿到Thrad中的 localValues，localValues是ThreadLocal中子类Values中的实例，从ThreadLocal.Values的解释可以看到：

/**     * Per-thread map of ThreadLocal instances to values.     */

ThreadLocal.Values就像是一个Map一样对Thread中的信息进行封装，

Looper就是存储在reference所在下标的下一个下标所对应的值，这点也可以从TheadLocal.set()看出。

再回到Handler的创建，在一般的线程中我们使用Handler的过程是：

 new Thread(new Runnable() {            @Override            public void run() {                Looper.prepare();                Handler mHandler = new Handler();                mHandler.getLooper().loop();            }        }).start();

但是在主线程中我们不用对Looper进行操作，只用new Handler()就行，这是因为在Activity中的ActivityThread中的main方法：

public static void main(String[] args) {              Looper.prepareMainLooper();        ActivityThread thread = new ActivityThread();        thread.attach(false);        if (sMainThreadHandler == null) {            sMainThreadHandler = thread.getHandler();        }        if (false) {            Looper.myLooper().setMessageLogging(new                    LogPrinter(Log.DEBUG, "ActivityThread"));        }        Looper.loop();        throw new RuntimeException("Main thread loop unexpectedly exited");    }

可以看到Looper.prepareMainLooper()就是在主线程中维护一份Looper.

好啦，接下来就是消息的处理啦：

我们一般发送消息有两种方式：

1）handler.post(Runnable r);

2) handler.sendMessage(Message msg);

先看第一种 post 的源码：

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

把Runnable封装为一个Message

public final boolean sendMessageDelayed(Message msg, long delayMillis)    {        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }

再来看第二种方法：

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

可以看到，方法一最终也是调用啦sendMessageDelayed();

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

这里就要讲到MessageQueue，MeaageQueue其实就是一个单链表，插入的方式是尾插法，可以从MessageQueue的enqueueMessage()方法看出：

boolean enqueueMessage(Message msg, long when) {...Message p = mMessages;//记录的是上一个插入的Message//对Message进行尾插法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;            }      return true;    }

MessageQueue中取消息是利用next()方法来完成的：

Message next() {int pendingIdleHandlerCount = -1; // -1 only during first iteration        int nextPollTimeoutMillis = 0;        for (;;) {            if (nextPollTimeoutMillis != 0) {                Binder.flushPendingCommands();            }            nativePollOnce(ptr, nextPollTimeoutMillis);            synchronized (this) {                // Try to retrieve the next message.  Return if found.                final long now = SystemClock.uptimeMillis();                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中有消息就返回消息并且在该单链表中删除掉该消息，如果没有消息，next就会一直阻塞在那里

这时我们会想：到底消息是怎么被Handler处理的，Handler把消息插入到MessageQueue中，MessageQueue中又可以通过next来返回消息，那么返回的消息是怎么发回给Handler的，MessageQueue是在Looper中维护的，所以按理应该是Looper对返回的信息进行分发给Handler

Looper.loop()；就是不断的从MessageQueue中回去到Message，然后分发给Handler

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;for (;;) {            Message msg = queue.next(); // might block            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }msg.target.dispatchMessage(msg);msg.recycleUnchecked();        }    }

这里我只截了一部分，先从looper中获取到MessageQueue，然后也是在无限循环的从queue中获取Message，然后调用handler的dispatchMessage()，msg.target就是handler，能让loop跳出无线循环的情况是，queue返回啦一个空的msg，什么情况会返回一个null的msg，需要调用looper.quit（）

public void quit() {        mQueue.quit(false);    }

void quit(boolean safe) {        if (!mQuitAllowed) {            throw new IllegalStateException("Main thread not allowed to quit.");        }        synchronized (this) {            if (mQuitting) {                return;            }            mQuitting = true;            if (safe) {                removeAllFutureMessagesLocked();            } else {                removeAllMessagesLocked();            }            // We can assume mPtr != 0 because mQuitting was previously false.            nativeWake(mPtr);        }    }

可以看到会有一个标记 mQuitting = true, 在next方法中就会返回一个null的msg

可以在next方法中看出：

Message next() {    if (mQuitting) {                    dispose();                    return null;                }}

还有一种是quitSafely()，它与quit的区别在与，quit是直接退出，而quitSafely是在把所有的消息都处理完之后再退出

接下来就是看看looper分发Message的处理：

    /**     * Handle system messages here.     */    public void dispatchMessage(Message msg) {        if (msg.callback != null) {            handleCallback(msg);        } else {            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }

首先是对msg的类型进行处理：

还得我们在handler发送消息的时候有两种方式

1）handleCallback()；就是处理post的方式发送消息

private static void handleCallback(Message message) {        message.callback.run();    }

就是直接通过Runnable的Run方法进行处理

2）先判断mCallback是否为空，如果不为空就用mCallback.handleMessage()进行消息的处理，

mCallback其实就是一个借口

   /**     * Callback interface you can use when instantiating a Handler to avoid     * having to implement your own subclass of Handler.     *     * @param msg A {@link android.os.Message Message} object     * @return True if no further handling is desired     */    public interface Callback {        public boolean handleMessage(Message msg);    }

从注解可以很好的理解就是：这样可以不用派生Handler的子类，因为我们一般就是

private Handler mHandler = new Handler(new Handler.Callback() {        @Override        public boolean handleMessage(Message msg) {            return false;        }    });

所以这种就给我们有了一个不同的方式来处理message

到这里，我们对Android的消息机制有一个更深入的了解，谢谢大家的阅读。本人处于进阶征途，若有错误之处，望大家能及时提出，我们共同进步！

更多相关文章

随机推荐