android handler源码理解

第一步，生成Looper和MessageQueue。如果在子线程中需要先执行Looper.prepare()，生成Looper对象，储存在ThreadLocal中（实际上是储存在线程的一个成员变量 threadlocals中，主要作用是隔离变量），在Looper对象中生成MessageQueue对象。

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

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

第二步，生成Handler。获取Looper和messageQueue并赋值给mLooper和mQueue。

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

 

第三步，发送消息。不管是sendMessage(Message msg)还是post(Runnable r)方法最终调用的是

sendMessageAtTime方法，然后MessageQueue.enqueueMessage把消息放进消息队列。
post的方法通过getPostMessage(Runnable r)方法 生成一个Message，并把r赋值给Message.callback

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

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;//表示属于哪个handler，在后面的loop中把message发送到指定handler用到
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }表示属于哪个handler，在后面的loop中把message发送到指定handler用到
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

第四步，Looper.loop。通过 meaageQueue.next不断循环从messageQueue取message。并把message分发到指定的handler中（msg.target.dispatchMessage(msg)）。
 

 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;
            }
            msg.target.dispatchMessage(msg); //分发
            ..............省略
            msg.recycleUnchecked();
        }
    }

第五步，handler 处理消息。

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

总结：looper管理MessageQueue，创建MessageQueue，和从MessageQueue取数据，分发到指定的handler(调用dispatchMessage)。handler负责把数据存入MessageQueue。handler线程间的交互相当于handler.sendMessage()所在的线程和Looper(即handler.handleMessage())所在的线程交互，messageQueue是中间桥梁。

 

 

Handler异步消息

Handler中的Message可以分为两类：同步消息、异步消息。一般情况下这两种消息的处理方式没什么区别，只有在设置了同步屏障时才会出现差异。

同步屏障可以通过MessageQueue.postSyncBarrier函数来设置，同步屏障也是个message，只不过它是一个没有target的message，最终也加入messageQueue。

 

同步屏障的作用是： 设置了同步屏障之后，Handler只会处理异步消息。再换句话说，同步屏障为Handler消息机制增加了一种简单的优先级机制，异步消息的优先级要高于同步消息。同步屏障不取消不执行同步消息。


Android 中 MessageQueue 的 nativePollOnce :

https://www.cnblogs.com/jiy-for-you/archive/2019/10/20/11707356.html