Android 消息机制详解

作者: 张旭的博客 | 来源:发表于2021-02-06 17:55 被阅读0次

消息机制简介

Handler、Message、MessageQueue、Looper一起实现了android的消息机制。那，什么是消息机制，上述四个类是干什么？又是怎么实现了线程间的消息传递的？我们先来概括一下。

消息机制主要解决线程间的数据传递问题。

Handler负责发送和处理消息。Message封装了线程间传递的数据，Message内部有一个Message next的对象，指向下一个消息，这样可以通过第一个Message来遍历所有的消息了。MessageQueue是一个消息队列，里面保存Message对象m，通过m就可以遍历所有的消息了。Looper则是消息循环，在当前线程中死循环运行。

如何实现线程间的消息传递？很简单，在线程T1中创建Handler对象A。此时A会创建Looper消息循环对象，Looper的构造方法中又创建了消息队列MQ。Looper将自己保存在ThreadLocal中。这样，就相当于将Looper，MQ对象绑定到了当前线程的ThreadLocal。

我们在线程T2中发送消息（handler.postMessage）。其实都是将消息对象M1插入到A的MQ中。因为A的Looper对象是在T1中运行的。这样就实现了消息从T2向T1的传递。

接下来，我们通过一个简单的Demo，从源码的角度来捋一下消息机制。

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
            final Handler  h = new Handler(){
            @Override
            public void handleMessage(@NonNull Message msg) {
                // 主线程接受消息
                super.handleMessage(msg);
                long id = Thread.currentThread().getId();
            }
        };

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 子线程消息发送       
                long id = Thread.currentThread().getId();
                Message message = new Message();
                message.arg1 = 100;
                message.what = 102;
                h.sendMessage(message);
            }
        }).start();
    }
}

子线程中消息循环

public class MyThread extends Thread {
    public static final String TAG = "Zhang";
    public Handler mHandler = null;

    @Override
    public void run() {
        Log.d(TAG, "进入Thread的run");
        // 子线程中需要调用prepare方法初始化
        Looper.prepare();
        mHandler = new Handler(Looper.myLooper()){
            @Override
            public void handleMessage(Message msg){
                Log.d(TAG, "获得了message");
                super.handleMessage(msg);
            }
        };
        // 开启消息循环
        Looper.loop();
    }
}

消息发送

以下4个api都是用来发送消息，but前面三个最终还是调用第四个API。

Handler.post();
Handler.postDelayed();
Handler.postAtTime();
Handler.sendMessageAtTime();

frameworks/base/core/java/android/os/Handler.java

public final boolean postDelayed(Runnable r, long delayMillis)
{
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}</pre>

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

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

sendMessageAtTime调用enqueueMessage(),将消息插入消息队列。

<pre>private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

enqueueMessage又调用了MessageQueue的enqueueMessage。

frameworks/base/core/java/android/os/MessageQueue.java

boolean enqueueMessage(Message msg, long when) {
    ...
    synchronized (this) {
       ...
        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || 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;
        }
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;

消息处理
Looper初始化

主线程中已经默认初始化，子线程的消息传递需要自己调用Looper.prepare。否则会crash

frameworks/base/core/java/android/os/Looper.java

public static void prepare() {
    // 子线程中，消息循环是可以退出的，quitAllowed为true
    prepare(true);
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }

    // 将一个Looper对象设置给ThreadLocal
    sThreadLocal.set(new Looper(quitAllowed));
}

private Looper(boolean quitAllowed) {
    // 创建了一个消息队列MessageQueue
    mQueue = new MessageQueue(quitAllowed);
    // 获取当前线程对象
    mThread = Thread.currentThread();

Looper消息循环

frameworks/base/core/java/android/os/Looper.java

Looper.loop();

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.");
    }
    // 获取Looper的消息队列
    final MessageQueue queue = me.mQueue;
    ....
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            return;
        }

        /**
        特别注意：可以通过setMessageLogging(@Nullable Printer printer)方，           
         将自己实现的Printer对象传给mLogging。这样logging就不为空了。分别记录
         L23和L33的时间，来计算消息处理所消耗的时间，从而且判断是否存在ANR。so，
         简单的说，这个可以做性能分析
        */ 
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target  +
            msg.callback + ": " + msg.what);
        }
        ...
        try {
            // msg.target就是T1线程的handler.通过dispathcmessage方法将消息发送到消息队列。
            msg.target.dispatchMessage(msg);
          ....

        if (logging != null) {
           logging.println("<<<<< Finished to " + msg.target        
           +msg.callback);
        }
        msg.recycleUnchecked();
    }
}

android.os handler.java

/**
 * Handle system messages here.
 */
public void dispatchMessage(@NonNull Message msg) {
    // 如果消息本身有callback，就调用消息的callback处理
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
    // 如果handler在构造的时候有callback，就调用handler的callback
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 否则调用重载的handlermessage方法处理消息
        handleMessage(msg);
    }
}

IdleHandler

IdleHandler是指那些优先级比较低的事务。在处理完所有的Message之后才处理IdleHandler

用法

Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
    @Override
    public boolean queueIdle() {
        ...
    }
});

MessageQueue.java

public void addIdleHandler(@NonNull IdleHandler handler) {
    if (handler == null) {
        throw new NullPointerException("Can't add a null IdleHandler");
    }
    synchronized (this) {
        // 将IdleHanlder插入mIdlehandler队列中
        mIdleHandlers.add(handler);
    }
}

Looper.myQueue().addIdleHandler方法将IdelHandler对象添加到mIdleHandler队列中。然后在消息循环中，从该队列拿出去，调用IdelHandler的queueIdel方法。具体如下代码：

Message next() {
...
    for (;;) {
        ...

        synchronized (this) {
            ...
            //前面的消息处理完后，再来处理IdelHandler事务
           if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            // 如果不存在IdleHandler退出当前循环。
            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);
        }
        // 轮训，并调用IdleHandler类的queueIdle方法。
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; 

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

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }
        pendingIdleHandlerCount = 0;
        nextPollTimeoutMillis = 0;

Message复用

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

异步与同步屏障
同步屏障就是阻碍同步，只让异步消息通过。调用postSyncBarrier方法执行同步屏障

    return postSyncBarrier(SystemClock.uptimeMillis());
}

同步屏障就是将一个没有target的msg插入到消息队列中对应的位置。


    synchronized (this) {
        final int token = mNextBarrierToken++;
        final Message msg = Message.obtain();
        msg.markInUse();
        msg.when = when;
        msg.arg1 = token;
         //就是这里！！！初始化Message对象的时候，并没有给target赋值，因此 target==null
        Message prev = null;
        Message p = mMessages;
        if (when != 0) {
            while (p != null && p.when <= when) {
                  //如果开启同步屏障的时间（假设记为T）T不为0，且当前的同步消息里有时间小于T，则prev也不为null
                prev = p;
                p = p.next;
            }
        }
         /根据prev是不是为null，将 msg 按照时间顺序插入到 消息队列（链表）的合适位置
        if (prev != null) { // invariant: p == prev.next
            msg.next = p;
            prev.next = msg;
        } else {
            msg.next = p;
            mMessages = msg;
        }
        return token;
    }
}

再来到消息队列

    ...
        synchronized (this) {
          ...
          // 如果当前msg是同步屏障，就去 找下一个异步消息
            if (msg != null && msg.target == null) {
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
            //  是否到钟？ 返回异步消息 - 当前msg就是异步消息
                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;
                }
            } 
            ...
}

移除同步屏障

public void removeSyncBarrier(int token) {
  
    synchronized (this) {
        Message prev = null;
        Message p = mMessages;
        while (p != null && (p.target != null || p.arg1 != token)) {
            prev = p;
            p = p.next;
        }
        if (p == null) {
            throw new IllegalStateException("The specified message queue synchronization "
                    + " barrier token has not been posted or has already been removed.");
        }
        final boolean needWake;
        if (prev != null) {
            prev.next = p.next;
            needWake = false;
        } else {
            mMessages = p.next;
            needWake = mMessages == null || mMessages.target != null;
        }
        p.recycleUnchecked();

        // If the loop is quitting then it is already awake.
        // We can assume mPtr != 0 when mQuitting is false.
        if (needWake && !mQuitting) {
            nativeWake(mPtr);
        }
    }
}

同步屏障总结：

1、MessageQueue.postSyncBarrier方法插入同步屏障到MQ的合适的位置（按照触发时间排序）。

2、MessageQueue.next方法依次取msg。如果当前msg是同步屏障（下图红色），就会找下一个异步消息（msg2）。并将异步消息返回。

3、只要同步屏障存在，且异步消息也存在，同步消息就永无天日。

4、MessageQueue.removeSyncBarrier方法调用后，异步消息失效。异步消息永无天日

image

参考文献

[1]这篇博客将同步屏障讲的非常清楚了，本文引用了该博客的部分图片

https://juejin.cn/post/6844903910113705998

Android 消息机制详解

消息机制简介

消息发送

消息处理

Looper初始化

Looper消息循环

IdleHandler

Message复用

异步与同步屏障

移除同步屏障

同步屏障总结：

参考文献

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读