Android 消息响应，Handler、Looper、Message关系

最新推荐文章于 2024-07-03 09:07:31 发布

牛杂君

最新推荐文章于 2024-07-03 09:07:31 发布

阅读量153

点赞数

文章标签： Android源码分析

本文链接：https://blog.csdn.net/weixin_40972376/article/details/81281102

版权

在使用线程创建Handler进行消息处理时，会使用如：

new Thread(){
            @Override
            public void run() {
                Looper.prepare();
                handlerthread = new myHandler() {
                    @Override
                    public void handleMessage(Message msg) {
                        System.out.println("thread handle : "+msg.obj);
                        ...
                    }
                };
                Looper.loop();
            }
        }.start();

使用

Looper.prepare();

处理handleMessage业务逻辑

Looper.loop();

的方式来处理数据、更新UI。

而为什么可以在线程处理Handler数据，Looper又是干什么的，在整个消息处理的流程是怎么样的？接下来我们来分析一下。

1.初始化

Looper.prepare()

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

分析ThreadLocal类在这篇文章中，介绍了ThreadLocal类的作用，这里不细说，简单就是存放了一个Looper对象，在该线程的某个时刻取出来使用。所以，一个线程只有一个Looper实例。

我们来看看new Looper()做的事情。

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

在这里，Looper的实例创建了MessageQueue对象，保存了当前的线程。

Looper.loop()

public static void loop() {
        final Looper me = myLooper();
        final MessageQueue queue = me.mQueue;
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            final long end;
            try {
                msg.target.dispatchMessage(msg);
            } finally {
            }
            msg.recycleUnchecked();
        }
    }

这里保留核心的逻辑。看一下myLooper()，就是获得前面prepare()方法里新创建的Looper对象。

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

再获取Looper里面的MessageQueue。接着for循环处理消息队列里面的消息。其中源码注释了might block没消息时会进行阻塞（涉及到Linux pipe/epoll机制，不细讲）。

处理数据能猜到，就是msg.target.dispatchMessage(msg)方法。

msg.target为Handler类型，所以实际是调用Handler.dispatchMessage方法

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

这里能看到，handleMessage就是我们一开始例子里面我们重写的Handler方法，就是我们要实现的业务逻辑。

到这一步我们可以整理一下Handler、Looper、Message的关系，如下图：

2.发送消息

那我们是怎么样把Message插入到MessageQueue里面呢？我们来看一下调用流程：

通常我们都是调用Handler实例.sendMessage() 、sendEmptyMessage() 、post()等方法，

实际都是调用MessageQueue.enqueueMessage()方法，源码如下：

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) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                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;
    }

for循环可以看出，找到消息队列的最后一个，把要处理的消息插入到队列最后。

我们来整理一下整个执行的流程。