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就可以流畅的运转了。