Android消息机制源码解读

不要心急，一点一点的进步才是最靠谱的。

读完本文你将了解：

- 前言
- Message
  - 如何获取一个消息
  - Message.obtain()
  - 消息的回收利用
- MessageQueue
  - MessageQueue 的属性
  - 何时初始化
  - 消息入队的过程
  - 消息出队的过程
- Looper
  - 线程相关 ThreadLocal
  - 无限循环调度
  - 如何停止
- Handler
  - Handler 的属性
  - 发送消息
  - 处理消息
  - 移除消息
- 主线程消息机制
- 总结
- Thanks

前言

本来我以为自己很了解 Handler，在印象中 Android 消息机制无非就是：

Handler 给 MessageQueue 添加消息
然后 Looper 无限循环读取消息
再调用 Handler 处理消息

整体的流程有了，但是一直没有结合源码捋一捋。

直到有一天在使用 Handler 发送消息时遇到了一个问题：

This message is already in use.

这才去翻了翻源码，今天总结一下。

Android 消息机制主要涉及 4 个类：

Message
MessageQueue
Handler
Looper

我们依次结合源码分析一下。

Message

“消息机制”，其中要传递的就是 Message，官方对它的描述是：

包含任意类型的对象和描述信息，可以被发送给 Handler。

Message

的主要属性如下：

//用来标识一个消息，接收消息方可以根据它知道这个消息是做什么的
    public int what;

    //如果你的消息要传递的数据是整型的，可以直接使用 arg1 和 arg2，而不需要使用构造一个 Bundle
    public int arg1;
    public int arg2;

    //一个任意类型的对象，在使用 Messenger 跨进程传递消息时，通常使用它传递给接收者
    //在其他场景下我们一般使用 setData() 方法
    public Object obj;

    //负责回复消息的 Messenger，有的场景下（比如接受者、发送者模型）需要使用它
    public Messenger replyTo;

    //当前消息的标志，只在被 Messenger 传递消息时使用，其他情况下都是 -1
    public int sendingUid = -;

    //标识当前消息是否在被使用
    //当一个消息入队时这个标志会被改变，在被重新获取后重置
    //当一个消息已经在被使用时，二次入队或者回收会报错（这就是我前言中提到的错误原因）
    /*package*/static final int FLAG_IN_USE =  << ;

    //标识当前 消息是否是异步的
    /*package*/static final int FLAG_ASYNCHRONOUS =  << ;

    //在 copyFrom 方法中要清除的标志
    /*package*/static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
    /*package*/int flags;

    /*package*/long when;

    //很关键的数据部分
    /*package*/Bundle data;

    //发送和处理消息关联的 Handler
    /*package*/Handler target;

    //消息的回调
    /*package*/Runnable callback;

    //在有些场景下还会以链表的形式关联后一个消息
    /*package*/Message next;

    //消息池
    private static final Object sPoolSync = new Object();
    private static Message sPool;    //回收消息链表
    private static int sPoolSize = ;

    private static final int MAX_POOL_SIZE = ;

    private static boolean gCheckRecycle = true;
Pasted from: http://book2s.com/java/src/package/android/os/message.html#a940ebe121994bfb7f9629bca79beab6

可以看到，Message 中比较关键的属性有：

标识干什么的 what
两个简易的整型数据存储对象 arg1 arg2
存储复杂点的对象 Bundle
跨进程通信绑定数据的 object
与之关联的 Handler
还有一些标志位，和消息池什么的

如何获取一个消息

消息机制最开始肯定需要构建一个消息。

虽然 Message 的构造函数是

public

的，但是官方还是建议我们使用以下 2 种方式获取一个 Message 对象：

Message.obtain()
Handler.obtainMessage()

原因是这两个方法会从一个消息回收池里获取消息，而不是新建一个，这样可以节省内存。

Handler.obtainMessage()

也是调用的

Message.obtain()

：

public final Message obtainMessage() {
        return Message.obtain(this);
    }

去看一下

Message.obtain()

源码。

Message.obtain()

Message.obtain()

有 7 个重载方法，基本就是在获取一个 Message 对象的同时直接赋值：

我们选最复杂的一个看下源码：

public static Message obtain(Handler h, int what, int arg1, int arg2,
            Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.arg1 = arg1;
        m.arg2 = arg2;
        m.obj = obj;

        return m;
    }
Pasted from: http://book2s.com/java/src/package/android/os/message.html#50de1a696587dcd5ae3c91eb63985af2

的确就是在

obtainI()

的基础上加了一些赋值。

Message.obtain()

源码如下：

public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = ; // 获取一个复用的消息时，会重置标志位，之前它是 FLAG_IN_USE
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }
Pasted from: http://book2s.com/java/src/package/android/os/message.html#62dadbbac34056e7ad4fad36d757d6ef

可以看到，这个方法会获取前面提到的

private static Message sPool;

，如果

sPool

存在就从复用消息链表头部取一个消息，然后重置它的标志位；如果不存在复用消息链表就新建一个消息。

那什么时候往消息池中添加消息呢？

消息的回收利用

消息的回收在

Message.recyclerUnchecked()

方法：

void recycleUnchecked() {
        flags = FLAG_IN_USE;    //当前消息被回收时，会标志为 FLAG_IN_USE
        what = ;
        arg1 = ;
        arg2 = ;
        obj = null;
        replyTo = null;
        sendingUid = -;
        when = ;
        target = null;
        callback = null;
        data = null;

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

可以看到

recycleUnchecked

方法将当前 Message 标志为 FLAG_IN_USE，这样如果这个方法在被入队，就会报错。此外它还清除了其他数据，然后把这个消息加入了回收消息的链表中。

那

recycleUnchecked()

什么时候会被调用呢？

在

MessageQueue

和

Looper

中都有。

MessageQueue.removeMessages()

方法：

void removeMessages(Handler h, int what, Object object) {
        if (h == null) {
            return;
        }

        synchronized (this) {
            Message p = mMessages;

            // Remove all messages at front.
            while (p != null && p.target == h && p.what == what
                    && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();    //这里调用了
                p = n;
            }

            // Remove all messages after front.
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && n.what == what
                            && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();    //这里也调用了
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }
        }
    }
Pasted from: http://book2s.com/java/src/package/android/os/messagequeue.html#0dbba2b975383e8b440199e5d69c73de

Looper.loop()

方法：

public static void loop() {
        //...

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            //...

            msg.recycleUnchecked();
        }
    }
Pasted from: http://book2s.com/java/src/package/android/os/looper.html

至此我们可以看到，一个消息在被 Looper 处理时或者移出队列时会被标识为

FLAG_IN_USE

，然后会被加入回收的消息链表，这样我们调用

Message.obtain()

方法时就可以从回收的消息池中获取一个旧的消息，从而节约成本。

MessageQueue

MessageQueue

管理着一个

Message

的列表，

Handlers

为它添加消息，

Looper

从中取消息。

Android消息机制源码解读

`MessageQueue` 的属性

// 队列是否可以退出
    private final boolean mQuitAllowed;

    @SuppressWarnings("unused")
    private long mPtr; //底层使用的 code

    //消息链表的开头
    Message mMessages;
    private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
    private SparseArray<FileDescriptorRecord> mFileDescriptorRecords;
    private IdleHandler[] mPendingIdleHandlers;
    private boolean mQuitting;
    //指出获取下一个消息的方法 next() 是否阻塞
    private boolean mBlocked;

    // Barriers are indicated by messages with a null target whose arg1 field carries the token.
    //后一个屏障的 token 
    private int mNextBarrierToken;

可以看到，

MessageQueue

虽然叫“消息队列”，持有的其实是一个消息链表的节点。

何时初始化

MessageQueue

一般不直接访问，都是通过

Looper.myQueue()

方法获取一个消息队列。

消息队列在 Looper 的构造函数中初始化：

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

MessageQueue 的构造函数中传入一个是否允许中途退出的标志，然后调用 Native 方法初始化。

这篇文章暂不研究 Native 层源码。

消息入队的过程

消息入队的方法是

enqueueMessage()

方法：

boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {    //这里要求消息必须跟 Handler 关联
        throw new IllegalArgumentException("Message must have a target.");
    }
    if (msg.isInUse()) {    
        throw new IllegalStateException(msg + " This message is already in use.");
    }

    synchronized (this) {
        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;
        Message p = mMessages;
        boolean needWake;
        //添加消息到链表中
        if (p == null || when ==  || when < p.when) {    
            //之前是空链表的时候读取消息会阻塞，新添加消息后唤醒
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            //插入消息到队列时，只有在队列头部有个屏障并且当前消息是异步的时才需要唤醒队列
            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;
}

Message.enqueueMessage()

方法中会检查入队的消息是否在被使用，如果是的话会报错：

if (msg.isInUse()) {    
        throw new IllegalStateException(msg + " This message is already in use.");
    }

现在我们清楚了，文章开头我遇到的：

This message is already in use.

是因为我二次使用了已经在使用的消息，在入队时 MessageQueue 检查发现后报的错。

所以每次调用

Handler.sendMessage()

时，都必须是

obtain()

或者 new 一个新的 Message 对象才行。

此外，如果消息队列已经退出，还添加消息入队就会报错。

消息出队的过程

消息出队的方法是

MessageQueue.next()

方法：

Message next() {
    //如果消息的 looper 退出，就退出这个方法
    final long ptr = mPtr;
    if (ptr == ) {
        return null;
    }

    int pendingIdleHandlerCount = -; // -1 only during first iteration
    int nextPollTimeoutMillis = ;
    //也是一个循环，有合适的消息就返回，没有就阻塞
    for (;;) {
        if (nextPollTimeoutMillis != ) {    //如果有需要过段时间再处理的消息，先调用 Binder 的这个方法
            Binder.flushPendingCommands();
        }

        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            //获取下一个消息
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;    //当前链表的头结点
            if (msg != null && msg.target == null) {
                //如果消息没有 target，那它就是一个屏障，需要一直往后遍历找到第一个异步的消息
                                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
                if (now < msg.when) {    //如果这个消息还没到处理时间，就设置个时间过段时间再处理
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // 消息是正常的、可以立即处理的
                    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 = -;
            }

            //如果收到退出的消息，并且所有等待处理的消息都处理完时，调用 Native 方法销毁队列
                        if (mQuitting) {
                dispose();
                return null;
            }

            //有消息等待过段时间执行时，pendingIdleHandlerCount 增加
            if (pendingIdleHandlerCount < 
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= ) {
                mBlocked = true;
                continue;
            }

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

        for (int i = ; 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 = ;

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

可以看到，

MessageQueue.next()

方法里有一个循环，在这个循环中遍历消息链表，找到下一个可以处理的、target 不为空的消息并且执行时间不在未来的消息，就返回，否则就继续往后找。

如果有阻塞（没有消息了或者只有 Delay 的消息），会把 mBlocked这个变量标记为 true，在下一个 Message 进队时会判断这个message 的位置，如果在队首就会调用 nativeWake() 方法唤醒线程！

其中看到个

IdleHandler

是什么呢？

public static interface IdleHandler {

    //当消息队列没有消息时会回调这个方法，阻塞等待有消息进入
    //返回 true 的话表示唤醒阻塞的线程，false 表示移除
    //如果消息队列中有消息等待在将来执行，也会调用这个方法
    boolean queueIdle();
}

根据源码和注释我们可以知道

IdleHandler

是一个线程阻塞时回调的接口。

MessageQueue 中提供了监听阻塞回调的注册和移除接口：

public void addIdleHandler(@NonNull IdleHandler handler) {
    if (handler == null) {
        throw new NullPointerException("Can't add a null IdleHandler");
    }
    synchronized (this) {
        mIdleHandlers.add(handler);
    }
}

public void removeIdleHandler(@NonNull IdleHandler handler) {
    synchronized (this) {
        mIdleHandlers.remove(handler);
    }
}

当消息队列阻塞时，会回调这些监听阻塞的观察者，告诉他们：我有空了！来找我玩啊！

在

queueIdle()

中做的操作，它会在 handler 空闲时被调用，可以充分利用 handler，我们可以在代码里这样使用：

Handler handler = new Handler();
        try {
            Field field = Looper.class.getDeclaredField("mQueue");
            field.setAccessible(true);
            MessageQueue queue = (MessageQueue) field.get(handler.getLooper());
            queue.addIdleHandler(new MessageQueue.IdleHandler() {
                @Override
                public boolean queueIdle() {
                    //这里做一些操作
                    return true;
                }
            });
        } catch (Exception e) {

        }

这里只简单介绍了 Java 层的 MessageQueue，关于 Native 层的可以看这篇文章：http://blog.csdn.net/innost/article/details/47317823

Looper

前面介绍了 Android 消息机制中消息和消息队列，有了传递的消息和存储的队列，接下来我们结合源码了解下进行调度的 Looper。

Android消息机制源码解读

官方文档对 Looper 的介绍：

Looper 是用于运行一个线程中的消息的类。

Looper 的属性很简单：

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper;  // 主线程中的 Looepr

final MessageQueue mQueue;    //与之管理的消息队列
final Thread mThread;    //所在的线程

private Printer mLogging;
private long mTraceTag;

线程中默认没有 Looper，我们需要调用

Looper.prepare()

方法为当前线程创建一个 Looper，然后就可以调用

loop()

方法调度消息。

样例代码如下：

class LooperThread extends Thread {
      public Handler mHandler;

      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

线程相关 ThreadLocal

前面讲了在一个线程中需要调用

Looper.prepare()

方法创建一个 Looper：

public static void prepare() {
    prepare(true);
}

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。

创建一个或者或许当前线程的 Looper 都通过

ThreadLocal

，我们来了解下它的主要源码。

ThreadLocal.get()

和

ThreadLocal.set()

源码：

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

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

ThreadLocalMap

中持有一个

Entry

的数组：

private Entry[] table;
static class Entry extends WeakReference<ThreadLocal> {
    Object value;

    Entry(ThreadLocal k, Object v) {
        super(k);
        value = v;
    }
}

可以看到，

ThreadLocal

先通过当前线程获取

ThreadLocalMap

，然后在

ThreadLocalMap

中保存

ThreadLocal

和数据的关联。

也就是一个类似 Map

无限循环调度

在线程中创建一个

Looper

以后，就可以调用

Looper.loop()

循环处理消息了，看下它的源码：

/**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the loop.
 */
public static void loop() {
    final Looper me = myLooper();
    if (me == null) {    //当前线程必须创建 Looper 才可以执行
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;

    //底层对 IPC 标识的处理，不用关心 
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    for (;;) {    //无限循环模式
        Message msg = queue.next(); //从消息队列中读取消息，可能会阻塞
        if (msg == null) {    //当消息队列中没有消息时就会返回，不过这只发生在 queue 退出的时候
            return;
        }

        //...
        try {
            msg.target.dispatchMessage(msg);    //调用消息关联的 Handler 处理消息
        } finally {
            if (traceTag != ) {
                Trace.traceEnd(traceTag);
            }
        }
        //...
        msg.recycleUnchecked();    //标记这个消息被回收
    }
}

可以看到，

Looper.loop()

也很简单，就是调用

MessageQueue.next()

方法取消息，如果没有消息的话会阻塞，直到有新的消息进入或者消息队列退出。

拿到消息后调用消息关联的 Handler 处理消息。

可以看到，Looper 并没有执行消息，真正执行消息的还是添加消息到队列中的那个 Handler，真应了那句：解铃还须系铃人啊！

如何停止

loop()

源码中的注释就提醒我们，开启循环调度消息后不要忘记调用

quit()

方法结束循环。

Looper.quit() 和 quitSafely ()

源码:

public void quit() {
    mQueue.quit(false);
}

public void quitSafely() {
    mQueue.quit(true);
}

两种退出方式都调用的是

MessageQueue.quit(boolean)

方法：

void quit(boolean safe) {
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }

    synchronized (this) {
        if (mQuitting) {
            return;
        }
        mQuitting = true;

        if (safe) {
            removeAllFutureMessagesLocked();
        } else {
            removeAllMessagesLocked();
        }

        // We can assume mPtr != 0 because mQuitting was previously false.
        nativeWake(mPtr);
    }
}
private void removeAllFutureMessagesLocked() {
    final long now = SystemClock.uptimeMillis();
    Message p = mMessages;
    if (p != null) {
        if (p.when > now) {    //`如果链表头部的消息执行时间在将来（也就是一时半会儿没有任务可执行）
            removeAllMessagesLocked();    //就直接强硬的全部回收了
        } else {        
            Message n;
            for (;;) {            //否则找到那个执行时间大于现在的消息，把它后面的消息都回收了
                n = p.next;
                if (n == null) {
                    return;
                }
                if (n.when > now) {
                    break;
                }
                p = n;
            }
            p.next = null;
            do {
                p = n;
                n = p.next;
                p.recycleUnchecked();
            } while (n != null);
        }
    }
}
private void removeAllMessagesLocked() {
    Message p = mMessages;
    while (p != null) {    //挨个遍历链表，把消息都回收了
        Message n = p.next;
        p.recycleUnchecked();
        p = n;
    }
    mMessages = null;
}

可以看到 Looper 两种结束方式的区别：

quit() ：立即把消息链表中的所有消息都回收了，比较强硬
- 在停止后如果 Handler 还发送消息，会返回 false，表示入队失败
- 这个方法是不安全的，一般建议使用下面那个
quitSafely() ：比上面那个温柔一点
- 只会将还未执行的消息回收掉
- 在调用之后添加进入的消息不会被处理，Handler.sendMessage 也会返回 false

当消息队列被标记位退出状态时，它的

next()

方法会返回 null，于是

Looper.loop()

循环就结束了。

Handler

现在我们了解了消息队列和 Looper，接着就该介绍消息机制中最关键的角色 – Handler。

Android消息机制源码解读

每一个 Handler 都和一个线程的 Looper 以及这个线程中的消息队列关联。

Handler 所做的就是 “线程切换”：

在子线程将 Message 或者 Runnable 发送到 MessageQueue 中
然后等待 Looper 调度这个消息后，再召唤 Handler 来处理消息
这时消息已经在创建 Handler 的线程了

这个“线程切换” 是怎么实现的呢？我们一步步揭晓。

Handler 的属性

Handler 的属性如下：

final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;

可以看到 Handler 的属性很简单，其中 mCallback 可以作为构造函数的参数用于新建 Handler。

public Handler(Callback callback) {
    this(callback, false);
}
public interface Callback {
    public boolean handleMessage(Message msg);
}

我们平时创建 Handler 都是创建一个 Handler 的子类然后重写它的 handleMessage 方法，有了

Handler.Callback

接口我们可以用这种方式创建 Handler：

Handler mHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        //这里处理消息
        return false;
    }
});

最终效果和创建 Handler 子类一样，但是需要注意，这里创建了匿名内部类，还是会持有外部引用，导致内存泄漏。

发送消息

Handler 发送的主要有两种类型：

Message
Runnable

发送方法有

postXXX()

和

sendXXX()

两种，postXXX 发送的是 Runnable，调用的也是 sendXXX，而 Runnable 也会被转成 Message：

public final boolean post(Runnable r) {
        return sendMessageDelayed(getPostMessage(r), );
    }
    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

所以我们直接看 sendXXX 方法：

public final boolean sendMessage(Message msg){
    return sendMessageDelayed(msg, );
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
    if (delayMillis < ) {
        delayMillis = ;
    }
    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;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

可以看到 Handler 发送消息最后还是调用了消息队列的

enqueueMessage()

方法。

而我们常用的使用

Handler.sendMessageDelayed()

发送延迟消息，最后其实是在入队时指定这个 msg.when，在

MessageQueue.next()

方法中，会对 msg.when > now 的消息设置延迟处理，具体实现是在 Native 层。

消息入队后，Looper 如果启动了就可以从队列里循环取消息，然后调用

msg.target.dispatchMessage(msg)``` 也就是

Handler.dispatchMessage()“ 方法处理消息。

处理消息

/**
 * 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);
    }
}
private static void handleCallback(Message message) {
    message.callback.run();
}
public void handleMessage(Message msg) {
}

可以看到，Handler 在处理消息时，会有三种情况：

msg.callback 不为空
- 这在使用 Handler.postXXX(Runnable) 发送消息的时候会发生
- 这就直接调用 Runnable 的 run() 方法
mCallback 不为空
- 这在我们使用前面介绍的 Handler.Callback 为参数构造 Handler 时会发生
- 那就调用构造函数里传入的 handleMessage() 方法
- 如果返回 true，那就不往下走了
最后就调用 Handler.handleMessage() 方法
- 这是一个空实现，需要我们在 Handler 子类里重写
至此 Handler 发送和处理消息的源码我们就了解了。

移除消息

最后再看一下如果移除消息。

由于发送时可以发送 Callback 和 Message，所以取消也有两种：

removeCallbacks()
removeMessages()

看一下源码发现调用的其实就是消息队列的出队方法：

public final void removeCallbacks(Runnable r){
    mQueue.removeMessages(this, r, null);
}
public final void removeMessages(int what) {
    mQueue.removeMessages(this, what, null);
}

主线程消息机制

我们知道，在主线程中创建 Handler 时不用 papare Looper，这是因为在主线程中系统默认创建了 Looper，它在不停地调度分发消息，因此四大组件的调度、我们的输入事件、绘制请求才能得到处理。

ActivityThread 就是我们说的主线程，而它的

main()

方法就是当主线程的入口:

public static void main(String[] args) {
    /...
    Process.setArgV0("<pre-initialized>");

    Looper.prepareMainLooper();

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

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

    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }

    // End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    Looper.loop();

}

可以看到在主线程的

main()

方法中初始化了一个 Looper，然后调用了

Looper.loop()

方法开始调度消息。

发送和处理主线程中的消息的 Handler 叫做 H：

private class H extends Handler {
    public static final int LAUNCH_ACTIVITY         = ;
    public static final int PAUSE_ACTIVITY          = ;
    public static final int PAUSE_ACTIVITY_FINISHING= ;
    public static final int STOP_ACTIVITY_SHOW      = ;
    public static final int STOP_ACTIVITY_HIDE      = ;
    public static final int SHOW_WINDOW             = ;
    public static final int HIDE_WINDOW             = ;
    public static final int RESUME_ACTIVITY         = ;
    public static final int SEND_RESULT             = ;
    public static final int DESTROY_ACTIVITY        = ;
    public static final int BIND_APPLICATION        = ;
    public static final int EXIT_APPLICATION        = ;
    public static final int NEW_INTENT              = ;
    public static final int RECEIVER                = ;
    public static final int CREATE_SERVICE          = ;
    public static final int SERVICE_ARGS            = ;
    public static final int STOP_SERVICE            = ;
    //...
    public void handleMessage(Message msg) {
        if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
        switch (msg.what) {
            case LAUNCH_ACTIVITY: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                r.packageInfo = getPackageInfoNoCheck(
                        r.activityInfo.applicationInfo, r.compatInfo);
                handleLaunchActivity(r, null);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            case RELAUNCH_ACTIVITY: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
                ActivityClientRecord r = (ActivityClientRecord)msg.obj;
                handleRelaunchActivity(r);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            //...
        }
        if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
    }

H 的代码很多，我们只节选一部分。从上述代码可以看到，H 内部定义了消息类型，然后根据消息的类型进行不同的处理。

主线程的消息机制如下：

ActivityThread 通过 ApplicationThread 与 AMS 进行进程通信
AMS 以进程通信的方式完成 ActviityThread 的请求后回调 ApplicationThread 的 Binder
然后 ApplicationThread 向 H 发送消息，H 将消息切换到主线程，然后进行处理

总结

Android消息机制源码解读

这篇文章结合源码完整的看了一遍 Message MessageQueue Handler Looper，现在看着上面的图，可以自信地说我“熟悉 Android 消息机制”了哈哈。

结合 Android 性能优化：多线程理解会更深一些！

Thanks

《Android 开发艺术探索》

http://book2s.com/java/src/package/android/os/handler.html#d0bdd75e69340e6c9e876ee32501beae

http://book2s.com/java/src/package/android/os/looper.html

http://book2s.com/java/src/package/android/os/message.html

Android消息机制源码解读

前言

Message

如何获取一个消息

Message.obtain()

消息的回收利用

MessageQueue

`MessageQueue` 的属性

何时初始化

消息入队的过程

消息出队的过程

Looper

线程相关 ThreadLocal

无限循环调度

如何停止

Handler

Handler 的属性

发送消息

处理消息

移除消息

主线程消息机制

总结

Thanks

继续阅读

专访邓凡平：深入理解Android

与专家面对面：Android开发入门问与答

Android MVP架构MVCMVP

mvp初探

Android常用工具类简介目录

android常用工具类转载自：http://www.trinea.cn/android/android-common-utils/Android常用工具类

Android常用工具类ToastUtilsSizeUtilsLogUtilsRetrofitManagerAnimUtil

Android Studio 0.8.0解决 Failure [INSTALL_FAILED_OLDER_SDK] 问题

Android – ListView 中添加按钮，动态删除添加ItemView的操作

Kotlin的ListView与RecyclerView的简单应用

关于公司的那些坑：Android Studio篇

android SQLite事务和kotlin协程

无法正常编译错误Compilation failed to complete

关于Gradle配置的小结

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Android APK文件反编译Android APK文件反编译

Android消息机制源码解读

前言

Message

如何获取一个消息

Message.obtain()

消息的回收利用

MessageQueue

MessageQueue 的属性

何时初始化

消息入队的过程

消息出队的过程

Looper

线程相关 ThreadLocal

无限循环调度

如何停止

Handler

Handler 的属性

发送消息

处理消息

移除消息

主线程消息机制

总结

Thanks

继续阅读

`MessageQueue` 的属性