android Handler消息原理详情

Message对象

Message对象是需要被执行的对象，Message实例对象取得，通常使用Message类里的静态方法obtain(),该方法有多个重载版本，它创建并不一定创建一个新的Message实例，会有返回之前回收回来的对象。

Message Queue中存放着多个Message消息,是消息的管理者，每个线程。有且只有一个实例

Looper对象

每一个Looper对象和一个线程关联。通过调用Looper.myLooper()可以获得当前线程的Looper对象，创建一个Looper对象时，会同时创建一个MessageQueue对象。除了主线程有默认的Looper，会同时创建一个MessageQueue对象。除了主线程有默认的Looper，其它线程默认是没有MessageQueue对象的。所以不能接受Message。如需要接受，自己定义一个Looper对象，这样的该线程就有了自己的Looper对象和MessageQueue数据结构。
Looper从MessageQueue中取出Message然后，交由Handler的HandlerMessage进行处理。处理完成后，调用Message.recycle()将其放入MessagePool中。

Handler对象

消息处理者，handler负责将需要传递的信息封装成Message,通过调用ObtainMessage()来实现;
将消息传递给MessageQueue，然后通过转线程Looper通过MessageQueue获取Message消息，并将其通过dispatchMessage发送出去

创建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

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

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

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销毁对象

    void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

发送消息

Handler发送消息的方式有二种：

1. sendMessage
2. Post(Runnable)

sendMessage消息是在HandlerMessage方法中执行

Post消息是在message.callback.run();方法中执行

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;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

 线程消息执行

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

            final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            final long end;
            try {
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            msg.recycleUnchecked();
        }
    }

Handler执行线程

当Handler的mCallback有设置时优化执行，否则执行Handler的handleMessage函数

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

 

//Post消息执行
private static void handleCallback(Message message) {
        message.callback.run();
    }

 结论: