在Android中，有两个东西是最重要的，一个是Handler，一个是Binder。

Handler是跨线程通信机制

Binder是跨进程通信机制

这次我们先来聊一聊Handler。

Handler分了两部分来分析

前言

Handler 是子线程与主线程之间的沟通中介，用于传递处理消息。 在Android中，为保证处理UI 工作的线程稳定安全，规定只有主线程才能更新处理UI工作。所以当子线程想处理UI工作时，就需要通过Handler来通知主线程作出相应的UI处理工作。

系统为什么不允许在子线程中访问UI？ 因为Android的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI控件处于不可预期的状态。 为什么系统不对UI控件的访问加上锁机制呢？ 加上锁机制会让UI访问的逻辑变得复杂 锁机制会降低UI访问的效率，因为锁机制会阻塞某些线程的执行。 鉴于这两个缺点，最简单且高效的方法就是采用单线程模型来处理UI操作。

用法

首先看一下Handler的简单用法

public class HandlerActivity extends AppCompatActivity {
    private Handler mHandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler);

        mHandler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                    case 1:
                        Log.e("HandlerActivity", "case 1")
                        break;
                    case 2:
                        Log.e("HandlerActivity", "case 2")
                        break;
                    default:
                        break;
                }
            }
        };

        Button clickBtn = findViewById(R.id.click_btn);
        clickBtn.setOnClickListener(v -> {
            new CustomThread().start();
        });

    }

    public class CustomThread extends Thread {

        @Override
        public void run() {

            // 更新UI
            Message childMessage = new Message();
            childMessage.what = 1;
            // Handler.sendMessage(Message)
            mHandler.sendMessage(childMessage);

            // Handler.post(Runnable)
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    Log.e("HandlerActivity", "case 3");
                }
            });

            // Handler.obtainMessage(what).sendToTarget();
            mHandler.obtainMessage(2).sendToTarget();
        }
    }
}

上边的代码，我们列了三种方法：

• Handler.sendMessage(Message)
• Handler.post(Runnable)
• Handler.obtainMessage(what).sendToTarget();

需要注意的是，如果在子线程里创建Handler，在使用的时候，需要先调用 Looper.prepare() 方法，然后创建Handler，再调用 Looper.loop()。

相关概念

Handler机制主要是由五部分组成：Handler、Thread(ThreadLocal)、Looper、MessageQueue、Message

Thread(ThreadLocal)

我们要知道，Handler是用来做线程通信的，所以Handler机制与Thread是紧密相关的。 Handler必须要绑定一个对应的Looper，而Looper的创建和保存是与Thread一一对应的，也就是说 每个线程都可以创建唯一一个且互不相关的Looper，这个是通过 ThreadLocal 来实现的。

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

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

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

ThreadLocal

ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其他线程来说则无法获取到数据。 一般来说，当某些数据是以线程为作用域并且不同线程具有 不同的数据副本的时候，就可以考虑采用ThreadLocal。

Handler

主要负责Message的发送和处理

Handler的创建方式

Handler()
Handler(Callback callback)
Handler(Looper looper)
Handler(Looper looper, Callback callback)
Handler(boolean async)
Handler(Callback callback, boolean async)
Handler(Looper looper, Callback callback, boolean async)

一般有两种创建方式

• 不传Looper，这种需要在创建Handler之前，先调用 Looper.prepare来创建当前线程的Looper，否则会报错
• 传入Looper，这种就是将Handler 与指定的 Looper 进行绑定，也就是说 Handler 是可以与任意线程进行绑定的，不仅限于创建Handler所在的线程里。

Callback

这个回调参数是消息被分发后的一种回调，在 msg调用 handler的 dispatchMessage的时候，根据情况回调

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

async

这个参数表明通过这个Handler发送的消息全都是异步消息，因为在把消息压入队列的时候，会把这个标志设置到message里.这个标志是全局的，也就是说通过构造Handler函数传入的async参数，就确定了通过这个Handler发送的消息都是异步消息，默认是false，即都是同步消息。 异步消息和同步消息的区别后续再说。

Message

消息，被传递和处理的数据。其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。

MessageQueue

消息队列，本质是一个单链表，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message串联起来，等待Looper的抽取。

Looper

用于为线程运行消息循环的类。默认线程没有与它们相关联的Looper；所以要在运行循环的线程中调用prepare()，然后调用loop()让它循环处理消息，直到循环停止。

工作流程

• Handler通过sendMessage()发送Message时，Looper的成员变量MessageQueue会通过enqueueMessage()向MessageQueue中添加一条消息。

此时Message会将Handler对象赋值给Message对象的target参数。

• Looper通过loop()方法开启循环后，不断轮询调用MessageQueue的next()方法来获取Message。
• 通过调用Messag目标Handler的dispatchMessage()方法去传递消息，目标Handler收到消息后调用handleMessage()方法处理消息 简单来说，Handler通过sendMessage()方法将Message发送到Looper的成员变量MessageQueue中，之后Looper通过loop()方法不断循环遍历MessageQueue从中读取Message，最终回调给Handler处理。

消息机制分析

Looper.prepare()

首先我们要知道 一个Handler的创建 需要关联一个Looper，所以在Handler创建前，需要调用 Looper.prepare() 方法。 但是我们会发现在我们平时用的时候，基本上都是直接去 new Handler，而没有调用 prepare 这个方法。这是因为，我们平时用的时候，基本上都是在主线程里使用，而主线程的 Looper 在 ActivityThread类中的 main() 方法里已经帮我们做了这件事情。 ActivityThread.java

Looper.prepareMainLooper();

Looper.java

public static void prepareMainLooper() {
    // 调用 prepare 方法， 如果当前线程没有 Looper 对象，就新创建一个
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        // 放回当前线程所关联的 Looper 对象
        sMainLooper = myLooper();
    }
}

public static Looper getMainLooper() {
    // 返回sMainLooper
    synchronized (Looper.class) {
        return sMainLooper;
    }
}

private static void prepare(boolean quitAllowed) {
    // sThreadLocal.get() 返回 Looper 或者 null， 
    // 如果返回 Looper 对象，则表示该线程已经创建了 Looper 对象 并抛出异常
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    // 如果是null，调用 new Looper() 方法新建一个Looper 对象，并放入 sThreadLocal中。
    sThreadLocal.set(new Looper(quitAllowed));
}

private Looper(boolean quitAllowed) {
    // 新建一个 MessageQueue
    mQueue = new MessageQueue(quitAllowed);
    // mThread 为当前线程
    mThread = Thread.currentThread();
}

/**
* 返回当前线程所关联的 Looper 对象，如果所调用的线程没有，就返回null
*/
public static @Nullable Looper myLooper() {
    // 获取的Looper 对象，在 prepare 方法中 通过 sThreadLocal.set(new Looper(quitAllowed)) 创建的
    return sThreadLocal.get();
}

Handler 创建

通过查看 Handler 的构造方法，我们可以看到，核心的一共有两个构造方法，一个是带有 Looper 参数的，一个是不带Looper参数的。 带Looper参数的：

public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

这个方法很简单，就是给 Handler 对象的各种参数赋值。 不带Looper 参数的：

public Handler(@Nullable 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());
        }
    }
    // 返回与当前线程关联的Looper对象。
    mLooper = Looper.myLooper();
    // 如果Looper 对象为空，则抛出异常
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread " + Thread.currentThread()
            + " that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

通过上边的代码，我们可以看出，如果没有传入 looper参数， 那么就需要通过 Looper.myLooper()方法来获取当前线程的Looper，如果没有则抛出异常。 从这里我们也可以明白为什么在创建 Handler之前必须要先调用 Looper.prepare()方法。

创建Message对象

创建Message对象有两种方法：

1. Message msg = new Message();
2. Message msg = Message.obtain();

第一种就不用说了，就是最简单的 new一个对象 来说一下第二种

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

这种就是从一个消息池里获取一个消息实例，这样可以让我们在许多的情况下避免去new一个新的对象。关于这个消息池的详细解析我们后边再展开。

发送消息

创建了消息，就要进行发送消息的环节了 调用 handler 的sendMessage方法 Handler.java

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

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
    // 获取当前 Looper 对象的消息队列
    MessageQueue queue = mQueue;
    // 如果当前 Looper 没有消息队列，则抛出异常
    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(@NonNull MessageQueue queue, @NonNull Message msg,
                               long uptimeMillis) {
    // 对消息的 target 赋值为 当前的 handler对象，这个值在后边要用到
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    // 执行 messageQueue 的 enqueueMessage方法
    return queue.enqueueMessage(msg, uptimeMillis);
}

MessageQueue.java

boolean enqueueMessage(Message msg, long when) {
    // 获取当前的Handler 对象，如果为null，则抛出异常
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    
    synchronized (this) {
        // 如果消息已经被使用，则抛出异常
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        // 如果Looper 退出了，则抛出异常，并且msg被回收
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }

        msg.markInUse();
        msg.when = when;
        // 将消息队列赋值给 p
        Message p = mMessages;
        boolean needWake;
        // 如果当前的消息队列没有消息，即p=0
        // 或者是新消息的处理时间排在最前，即 when == 0，或者是 when 小于当前p中的首个消息的when
        if (p == null || when == 0 || when < p.when) {
            // 新的队列头部，如果队列是 blocked 的状态则需要唤醒该事件队列。
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            // 根据when将消息插入队列中间。
            // 通常，我们不必唤醒事件队列，除非队列的顶部有屏障，并且该消息是队列中最早的异步消息。
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

看到这里我们就明白了，handler发送消息时，是根据消息的处理时间放入到messageQueue中，然后等待消息的执行。

消息执行

消息已经放入了消息队列，那么接下来就是执行这个消息。也就到了 Looper.loop()方法。 Looper.java

public static void loop() {
    // 获取当前线程的 looper
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    if (me.mInLoop) {
        Slog.w(TAG, "Loop again would have the queued messages be executed"
                   + " before this one completed.");
    }

    me.mInLoop = true;

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

    // Allow overriding a threshold with a system prop. e.g.
    // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
    final int thresholdOverride =
    SystemProperties.getInt("log.looper."
                                        + Process.myUid() + "."
                                        + Thread.currentThread().getName()
                                        + ".slow", 0);

    me.mSlowDeliveryDetected = false;

    // 死循环，调用 loopOnce 方法
    for (;;) {
        if (!loopOnce(me, ident, thresholdOverride)) {
            return;
        }
    }
}

private static boolean loopOnce(final Looper me,
                                final long ident, final int thresholdOverride) {
    // 调用 MessageQueue 的next 方法取消息
    Message msg = me.mQueue.next(); // might block
    if (msg == null) {
        // 如果消息为空 ，则退出消息队列，死循环也会退出
        // No message indicates that the message queue is quitting.
        return false;
    }

    // This must be in a local variable, in case a UI event sets the logger
    final Printer logging = me.mLogging;
    if (logging != null) {
        logging.println(">>>>> Dispatching to " + msg.target + " "
                        + msg.callback + ": " + msg.what);
    }

    ...省略代码...
    
    try {
        // 这个 msg.target 就是绑定的 handler
        // 执行 dispatchMessage()方法
        msg.target.dispatchMessage(msg);
        if (observer != null) {
            observer.messageDispatched(token, msg);
        }
        dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
    } catch (Exception exception) {
        if (observer != null) {
            observer.dispatchingThrewException(token, msg, exception);
        }
        throw exception;
    } finally {
        ThreadLocalWorkSource.restore(origWorkSource);
        if (traceTag != 0) {
            Trace.traceEnd(traceTag);
        }
    }

    ...省略代码...
    
    // 回收消息
    msg.recycleUnchecked();

    return true;
}

再来看 MessageQueue的 next方法

Message next() {
    // Return here if the message loop has already quit and been disposed.
    // This can happen if the application tries to restart a looper after quit
    // which is not supported.
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    // 该参数用于确定消息队列中是否还有消息
    // 从而决定消息队列应处于 出队消息状态 或者 等待状态
    // nextPollTimeoutMillis = -1 一直阻塞不会超时
    // nextPollTimeoutMillis = 0 不会阻塞，立刻返回
    // nextPollTimeoutMillis > 0 最长阻塞nextPollTimeoutMillis
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }

        // nativePoolOnce 方法在 native层
        // 如果 nextPollTimeoutMillis 为 -1，此时消息队列处于等待状态
        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            // 获取系统开机到现在的时间
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            // 获取当前消息链的头结点
            Message msg = mMessages;
            // 如果msg为屏障消息，即 msg.target为空，则去寻找队列中的异步消息
            if (msg != null && msg.target == null) {
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            // 如果队列头部消息不是屏障消息，就会直接处理
            // 如果是，且获取异步消息，则处理异步消息
            if (msg != null) {
                if (now < msg.when) {
                    // 当前时间小于消息的时间，设置进入下次循环后的等待时间
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    // 一个标记，表示 next 循环是否还在被阻塞着。
                    mBlocked = false;
                    // 移除消息
                    if (prevMsg != null) {
                        // 移除异步消息
                        prevMsg.next = msg.next;
                    } else {
                        // 移除同步消息
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    // 标记为正在使用
                    msg.markInUse();
                    return msg;
                }
            } else {
                // 如果没有获取到消息，则把nextPollTimeoutMillis 设置为-1，nativePollOnce方法将会一直阻塞
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            if (mQuitting) {
                dispose();
                return null;
            }

            // If first time idle, then get the number of idlers to run.
            // Idle handles only run if the queue is empty or if the first message
            // in the queue (possibly a barrier) is due to be handled in the future.
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true;
                continue;
            }

            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }

        // Run the idle handlers.
        // We only ever reach this code block during the first iteration.
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler

            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }

        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;

        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        nextPollTimeoutMillis = 0;
    }
}

从上边的方法我们可以明白， 通过 next 方法 我们获取到一个消息后，会调用 Handler 的dispatchMessage 去处理消息

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

这个方法就会调用 handleMessage 或者 Message 的callback。

以上就是Handler的最简单的同步消息的发送处理流程。

此外还有 同步屏障、异步消息 和 IdeleHandler 我们下一篇再来分析