Handler消息处理机制---从源码分析

前言

android应用在启动时，默认会有一个主线程（ui线程），这个线程会关联一个消息队列，所有的操作都会被封装成消息进入消息队列交给主线程来处理，获取到的消息会放入一个死循环中，因此保证程序不会退出。那么handler和looper还有messageQueen和线程到底有什么关系呢？带着这种疑问，我们从handler的源码开始入手分析。

UI线程消息循环

ui线程的消息循环是在ActivityThread中的main方法里创建的，源码如下：

 public static void main(String[] args) {
        //...代码省略
        Looper.prepareMainLooper();//创建主线程消息循环looper

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        AsyncTask.init();

        Looper.loop();
        throw new RuntimeException("Main thread loop uexpectedly exited");
    }

我们可以看到，先调用了looper.prepareMainLooper()方法用来创建主线程的消息循环器，然后初始化主线程的handler，最后调用Looper.loop 方法开启循环，如果跳出循环则抛出异常。

Handler与Looper和消息队列的关系

我们平时在子线程执行玩耗时任务后经常用更新ui，必须在handler中执行。其实每个handler都会关联一个looper和looper中封装的消息队列，而每个looper又都会通过ThreadLocal关联一个线程，其实就相当于每个消息队列和一个线程关联，每个handler也关联一个线程。handler相当于一个消息处理器，将消息分发到消息队列，再由对应的线程从消息队列逐个取出消息来执行。那么handler是如何关联消息队列和线程的呢，我们看以下源代码：

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来获取Looper对象，同时关联了looper中的消息队列。

Looper与线程的关系

我们再看Looper中的源码：

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

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

 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的构造函数里创建了messageQueen,并通过native方法Thread.currentThread获取当前线程。在myLooper方法中通过sThreadLocal.get方法来获取looper对象，那么looper对象又是什么时候存储到sThreadLocal中的？可以看到prepare方法中，如果looper已经存在就会抛出异常，不存在就会创建一个新的looper对象，并将该对象保存在sThreadLocal中。

结合上面handler的源码，也就是说，每个handler对象的创建，必须保证预先有一个Looper对象，否则会抛出异常”Can’t create handler inside thread that has not called Looper.prepare()”。我们在主线程中之所以不需要创建looper的原因是因为系统在启动一个应用的时候通过Looper.prepareMainLooper()为我们创建了一个与主线程关联的Looper对象，并且开启了loop循环器，所以我们在handler中发送的消息能被接受并处理。而我们在子线程中如果要创建handler发送和处理消息，必须遵循如下写法：

new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                Handler handler = new Handler();
                Looper.loop();

            }
        }).start();

先通过Looper.prepare()方法初始化looper对象存入sThreadLocal方法中保证sThreadLocal.get不为null，这样初始化handler进入handler构造函数的时候就不会因为Looper.myLooper()方法调用sThreadLocal.get为空从而抛出异常了，最后调用Looper.loop开启循环。

那么我们在看看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;//1.获取消息队列
    //...代码省略 
        for (;;) {//2.消息循环
            Message msg = queue.next(); // 3.获取消息
            if (msg == null) {
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            //...代码省略
            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                msg.target.dispatchMessage(msg);//4.处理消息
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            msg.recycleUnchecked();//5.回收消息
        }
    }

可以看到，先通过Looper.myLooper方法获取looper对象和messageQueen对象，然后进入死循环不断地从消息队列取消息，最后处理消息的过程。

消息处理机制

我们从上面的代码中可以看到，通过msg.target.dispatchMessage(msg)来处理消息，那么msg.target又是什么呢？

public final class Message implements Parcelable {
/*package*/ Bundle data;

    /*package*/ Handler target;

    /*package*/ Runnable callback;

    // sometimes we store linked lists of these things
    /*package*/ Message next;
}

从源码可以看到，target也就是handler，实质是调用handler的dispatchMessage方法来分发消息。

我们继续看handler中的

public void handleMessage(Message msg) {
    }

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

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

可以看到，如果msg的callback线程不为空，则会调用handlerCallback,也就是调用msg中callback线程的run方法，如果为空则会交给handlerMessage来处理。那么什么时候callback为空什么时候不为空呢？我们继续往下看：

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

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 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);//将消息插入消息队列
    }


private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;//将handle引用赋给msg
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

 private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

可以看到，在调用handler.post(Runnable r)时，会将Runnable包装成Message的callback，最后将包装后的message对象插入消息队列中，并且将handler的引用传递给message，这样就能在Looper.loop()中调用handler的dispatchMessage方法来进行消息的下发处理了。

sendMessage也是同样的实现，只不过没有包装的Runnable对象，所以调用该方法msg.callback==null,故这边就是交给handlerMessage来进行处理。

结语

handler会将每一个消息追加到消息队列中，通过Looper不断从消息队列中获取消息，并且调用handler的dispatchMessage分发消息，分发的消息再通过回调进行处理，这样，android就可以流畅的运转了。