Handler话剧第一场-从发送消息到接收消息中间发生了什么?

Handler话剧第一场-从发送消息到接收消息中间发生了什么?

Android小彩虹2021-07-15 22:27:53300A+A-

1.角色

陆续出场 Handler、Message、MessageQueue、Looper

2.开场白(Handler是什么)

其实只要弄明白了上面第二个问题,自然就会知道handler从发送消息到接收消息更新UI这个过程中发生了什么。不过为了理解更彻底一些,最好是先了解一下handler是什么?用来解决什么问题。 看一下官网对于Handler的描述:

A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Each Handler instance is associated with a single thread and that thread's message queue. When you create a new Handler it is bound to a Looper. It will deliver messages and runnables to that Looper's message queue and execute them on that Looper's thread. There are two main uses for a Handler: (1) to schedule messages and runnables to be executed at some point in the future; and (2) to enqueue an action to be performed on a different thread than your own.

这段话的大概意思是,handler是一个与线程和消息队列绑定的消息处理程序,可以通过它来发送和处理消息。有两种主要用途:(1)调度消息和运行项,以便在未来的某个时间点执行;(2)将要在不同线程上执行的操作加入消息队列。

上面提到的两个主要用途,可能理解起来比较困难,我们来看一个简单的例子: 比如现在有一个下载操作,要求下载完成之后Toast提示一下 下载成功。这里有两个动作,一个是下载,一个是Toast提示,下载是耗时操作,而Toast是更新UI。一般情况下,Android更新UI的操作是在主线程进行的,子线程是不能直接更新UI的,但是耗时操作如果放到主线程的话是会引发ANR阻塞的,所以可以把下载放到子线程,Toast提示放到主线程,那么主线程的Toast如何知道下载操作已经完成了呢?换句话说,子线程和主线程如何通信呢?使用Handler处理类似情况。

3.先发一条消息(Handler、Message出场)

刚刚提到的下载并Toast的例子用handler实现:

Handler handler = new Handler(Looper.myLooper(), msg -> {
            Toast.makeText(MainActivity.this,msg.obj.toString(),Toast.LENGTH_LONG).show();
            return false;
 });
 btn_click_b.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
               new Thread(() -> {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Message message = Message.obtain();
                    message.obj = "下载完成";
                    handler.sendMessage(message);
                }).start();

        }
});

在上面例子中,我们先让子线程阻塞了3s,然后构建了一条消息,调用handler.sendMessage()把构建的消息发送出去,发送到什么地方去了呢?看一下sendMessage(msg)方法的内部是怎么做的。

//handler.sendMessage(msg)的调用链
//handler.sendMessage->sendMessageDelayed->sendMessageAtTime->enqueueMessage->queue.enqueueMessage
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) {
        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(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
  }

4.消息发送到哪里去了(MessageQueue出场)

跟踪整个调用过程发现sendMessage方法经过各种曲折调用之后,最后调用到了MessageQueue类的enqueueMessage方法,其他send方法,包括post方法最后也都会调用到这个enqueueMessage方法。流程进行到这一步之后,核心处理逻辑就已经不在Handler.java这个类中了,而是转移到了MessageQueue类中。接下来看一下MessageQueue.enqueueMessage类的内部:

Message mMessages;
boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            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 == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                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 内部有一个其自身类型的变量next,所以Message可以理解成一个专门存放消息的链表结构。 上面代码的核心逻辑就是,通过一个死循环将收到的信息不断添加到这个链表中去。

5. 只进不出?(Looper出场)

整个过程走到这里,Handler处理机制中的两个关键类Handler、MessageQueue已经陆续登场了。Handler、MessageQueue完成了发送消息和消息入队的过程,我们的消息总不能只发送不接收吧,那么谁来负责取出消息呢?取出消息之后又是怎么处理的呢?轮到Looper上场了! 我们都知道Handler机制中Looper.loope()方法的作用就是从消息列表中不断获取消息,具体是怎么获取呢?看一下loop()方法的内部:

for (;;) {
            Message msg = queue.next(); // 调用MessageQueue.next从Message队列中取出消息
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            ......
            msg.target.dispatchMessage(msg);//取出消息之后向下分发
}

整个方法的全部代码比较长,没必要理解全部的逻辑,只需关注for循环就行,这个死循环里其实就做了两件事情,1 不断从Message队列取消息 2 每取出一条消息都将其分发出去。取消息的操作是在MessageQueue.next方法中进行的,核心代码如下:

for (;;) {
           ......
           synchronized (this) {
                // Try to retrieve the next message. Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                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.
                        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 {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
              
               ......
            }
            ......
           }

取消息的核心操作都是在一个死循环中进行的,逐条从Message队列中轮询获取每个Message对象然后将其返回给Looper。

6.兜兜转转回到原点

到这一步Looper就已经取出来了,那么接下来Looper又是怎么处理取到的消息对象的呢?它把消息又分发出去了!。在前面Looper.loope()方法的源码中有代码是msg.target.dispatchMessage(msg),通过字面意思就可以知道,这是一个分发消息的操作,消息分发到哪里去了呢?继续看dispatchMessage(msg)的内部:

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

是不是很熟悉?!dispatchMessage这个方法是Handler内部的一个方法,也就是说,我们通过Handler发出的消息兜兜转转又回到了Handler!接下来的事情大家都很清楚了,我们在Activity中调用了handleMessage回调,拿到了当初发送出去的消息,然后就开始处理其他逻辑了。至此,演出结束,众演员退场。

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1

联系我们