引言

    Android消息机制肯定是最被经常提起的一个概念，通过下面的文章希望大家可以理解Message、 Handler、Looper。

1 消息处理流程

   在子线程中更新UI，先使用Handler的sendMessage去发送Message对象，然后通过Handler的handleMessage()方法中获得刚才发送的Message对象，这就是一个消息处理流程，是常用的一种情况。

new Thread(new Runnable() {

    @Override

    public void run() {

            Message message = Message.obtain();

            mHandler.sendMessage(message);

        }

}).start();

mHandler =new Handler(new Handler.Callback() {

    @Override

    public boolean handleMessage(Message msg) {

        return false;

    }

});

2 Message

    Google官方建议实例化Message时使用obtain方法，而不是直接new Message。因为Message维护着一个对象池，使用obtain方法能够复用之前被回收的Message，下面代码 if 语句就是复用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();

}

    而Message的回收是调用了方法recycleUnchecked，可以看出来对象池有最大数量（MAX_POOL_SIZE）它的值是50，并且对象池是一个单链表，单链表的优势就是方便插入、删除和节约内存。

private static final int MAX_POOL_SIZE = 50;

void recycleUnchecked() {

    省略掉部分初始化代码……

    synchronized (sPoolSync) {

        if (sPoolSize <  MAX_POOL_SIZE) {

            next =sPool;

            sPool =this;

            sPoolSize++;

            }

    }

}

3 Handler

    为了防止内存泄漏，将Handler声明为静态类。一般情况下，通过Handler的sendMessage方法发送Message，最后调用msg.dispatchMessage(msg)回调到handleMessage方法。

static class MyHandler extends Handler {

        WeakReference mWeakReference;

        public MyHandler(Activity activity){

            mWeakReference=new WeakReference(activity);

         }

        @Override

        public void handleMessage(Message msg) {

            final Activity activity=mWeakReference.get();

            if(activity!=null) {

                    //

                }

            }

        }

    }

3.1 Handler构造方法

   Handler有七个构造方法，不难看出①②③最后都会调用④。然后通过 Looper.myLooper()获取到Looper对象，再通过mLooper.mQueue获取到MessageQueue对象，最后我们会调用sendMessage方法发送Message对象到MessageQueue中。

  ①  public Handler() { this(null, false);}

  ②  public Handler(Callback callback) {this(callback, false);}

  ③  public Handler(boolean async) { this(null, async); }

  ④  public Handler(Callback callback, boolean async) {

        if (FIND_POTENTIAL_LEAKS) {

            final Class 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;

}

    查看myLooper的源码不难看出，myLooper是从sThreadLocal中获取到该线程下的Looper。

public static @Nullable Looper myLooper() {

    return sThreadLocal.get();

}

    构造方法⑤⑥最终会调用⑦，它们和前面四种构造方法不同之处在于可以指定Looper。

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

}

3.2 sendMessage方法

    创建完Handler对象之后，通过sendMessage发送对象，不难看出最后调用了sendMessageAtTime方法，通过MessageQueue queue = mQueue取得构造Handler时所获得的MessageQueue对象。

    源码中还有几个发送消息的方法就不一一讲解了。

public final boolean sendMessage(Message msg){

    return sendMessageDelayed(msg, 0);

}

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方法将Message加入MessageQueue 中，阅读源码发现Handler方法发送的Message最后都要到MessageQueue中。

    msg.target其实就是Handler自己，它的作用是用来调用自己的dispatchMessage方法，在Looper的loop方法中会说到。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

    msg.target =this;

    if (mAsynchronous) {

        msg.setAsynchronous(true);

    }

    return queue.enqueueMessage(msg, uptimeMillis);

}

3.3 dispatchMessage

    调用dispatchMessage方法时会判断msg是否有callback，而这个callback就是Runnable，通过对post的讲解你就会明白是怎么回事。

public void dispatchMessage(Message msg) {

    if (msg.callback !=null) {

        handleCallback(msg);

     }else {

        if (mCallback !=null) {

            if (mCallback.handleMessage(msg)) {

                return;

             }

        }

        handleMessage(msg);

    }

}

    我们经常会用到post，这个post并非真的创建新线程， 而是将Runnable封装到Message中。

mHandler.post(new Runnable() {

    @Override

    public void run() {

    }

});

public final boolean post(Runnable r, long delayMillis)

{

    return sendMessageDelayed(getPostMessage(r), delayMillis);

}

private static Message  getPostMessage(Runnable r) {

    Message m = Message.obtain();

    m.callback = r;

    return m;

}

    阅读dispatchMessage源码发现，如果callback不为null就调用handleCallback，callback为null则调用handleMessage。可以看在出来post中的Runnable最后会在handleCallback中执行它的run方法，并没有创建新的线程去执行run。

private static void handleCallback(Message message) 

    message.callback.run();

}

4 Looper

    有了Message和Handler，但是还有在一个问题，3.1中说到的从sThreadLocal中获取Looper，这个Looper是谁保存到sThreadLocal中的？其实就是Looper创建时保存的。

    在Looper这个类中有两个重要的方法，分别是prepare和loop方法。prepare负责创建Looper，loop负责无限循环读取消息。

4.1 prepare

    Looper的prepare方法可以去实例化一个Looper，通过sThreadLocal.set(new Looper(quitAllowed))这行代码可以看出来，prepare创建了一个Looper加入到sThreadLocal中。

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

}

    在实例化Looper时就会创建MessageQueue，所以MessageQueue并不需要我们手动创建。通过上面的 if 语句可以看出，一个线程里只能有一个Looper，否则会抛出"Only one Looper may be created per thread"，因此MessageQueue在一个线程中也只能有一个。

    通过下面的代码我们也可以得出另一个结论，在子线程中必须先调用looper.prepare才能使用handler，否则handler会无法发送消息，因为没有MessageQueue。

private Looper(boolean quitAllowed) {

    mQueue =new MessageQueue(quitAllowed);

    mThread = Thread.currentThread();

}

4.2 loop

    一般在子线程中是这么使用loop的。先使用Looper.prepare()创建Looper，然后发送消息，最后再使用Looper.loop()无限循环读取消息回调到handleMessage。

Looper.prepare();

Message message = Message.obtain();

mHandler.sendMessage(message);

Looper.loop();

    loop的源码比较长，只分析关键点，完整源码请自行查看。    

    首先通过myLooper获取到Looper对象。

    从下面的代码可以看出Looper不能为null不然会抛出"No Looper; Looper.prepare() wasn't called on this thread."，所以loop方法必须在Looper.prepare方法后使用。

final Looper me =myLooper();

    if (me ==null) {

        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");

    }

public static @Nullable Looper myLooper() {

    return sThreadLocal.get();

}

     loop方法是通过me.mQueue取得MessageQueue的。

final MessageQueue queue = me.mQueue;

    那么，loop是怎么实现无线循环的呢？关键就在于它的for循环。

    然后通过queue.next()去MessageQueue中获取消息，接着使用msg.target.dispatchMessage(msg)去分发消息（msg.target就是前面在讲Handler时说到的Handler本身），至此一个消息处理流程就分析完了。

for (;;) {

    Message msg = queue.next(); // might block

    if (msg ==null) {

        // No message indicates that the message queue is quitting.

        return;

     }

    try {

        msg.target.dispatchMessage(msg);

    }     

}

五 整体流程总结

图5-1 流程图

    首先由Looper.prepare创建Looper，Looper会创建MessageQueue，因为一个线程只有一个Looper，所以一个线程只有一个MessageQueue。

    接着创建Message，创建Message对象使用obtain方法，而不是直接new出来，因为Message内部维护这一个对象池，可以复用之前已经使用过的Message对象，如果线程池为null会创建一个新的Message（new Message）。

    再接着创建一个Handler，调用sendMessage发送Message到MessageQueue（MessageQueue并非真正的队列，而是一个单链表）。

    最后调用Looper.loop循环读取消息，并调用Handler的dispatchMessage进行回调处理。回调完之后调用msg.recycleUnchecked方法将msg加入到Message维护的对象池中。