Android消息机制Handler原理分析

  • 一个线程至多有一个looper;一个looper有一个MessageQueue;一个MessageQueue对应多个message;一个MessageQueue对应多个Handler。
  • 消息类型有同步(Message),异步(Async Message),同步屏障(BarrierMessage)消息。
  • 消息分发的优先级

1.Message的回调方法:message.callback.run(),优先级最高

2.Handler的回调方法 Handler.mCallBack.handleMessage(msg)

3.Handler的默认方法:Handler.handleMessage(msg)
Android消息机制Handler原理分析_第1张图片

上图是Android消息机制的图解

图中分为四个部分,Handler, Looper, MessageQueue, Message
Hander主要是将消息发送到MessageQueue中,和处理接收到消息后执行的代码。

Looper主要是不断的循环遍历MessageQueue中的Message,从而找到合适的Message进行处理

MessageQueue是一个单向链表结构,用来存储消息

Message是消息实体

启动Looper

class LooperThread extends Thread {
    public Handler mHandler;
    public void run() {
        Looper.prepare();
        mHandler = new Handler(Looper.myLooper()) {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };
        Looper.loop();
    }
}

需要使用Handler,首先要启动Looper。而主线程中,ActivityThread中已经帮我们启动了Looper,所以我们可以直接使用Handler。
启动Looper需要调用Looper的两个方法

Looper.prepare();

Looper.prepare();创建了Looper的实例,并将Looper的实例放入ThreadLocal中。这样你在Looper myLooper()中就能获取 当前线程的Looper

Looper.prepare()

Looper.loop();开始遍历MessageQueue

消息的发送与插入

Message中主要的字段有

Long when标志这个消息将在什么时候被触发,MessageQueue中消息的排序也是依赖when

Handler target标志这个消息由哪个Handler发送,会由哪个Handler来处理。target = null时该消息为同步屏障消息

Runable callback所有通过Handler.post发送的Runable对象都将被绑定到这个字段上。

Message next指向下一个MessageQueue中的下一个Message

Object objMessage中存储数据的变量

handler主要负责添加消息的MessageQueue中。
Handler发送消息的方法有

public final boolean sendEmptyMessage(int what)
public final boolean sendMessage(@NonNull Message msg)
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis)
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis)
public final boolean sendEmptyMessageDelayed(int what, long delayMillis)
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis)
public final boolean postDelayed(@NonNull Runnable r, @Nullable Object token, long delayMillis)
public final boolean post(@NonNull Runnable r)
public final boolean postAtTime(@NonNull Runnable r, long uptimeMillis)

其中sendMessageAtTimepostAtTime需要注意,他们接受的参数long uptimeMillis是绝对时间,比如说你想让传入的消息或回调延迟300ms触发,则时间参数需要这样写SystemClock#uptimeMillis + 300因为Handler所有的时间都是以SystemClock#uptimeMillis为基础来计算的,该方法是记录从开机运行到现在的时间戳,设备在深度睡眠的情况下该时间戳不累加

handler中所有send开头和post开头的方法最终都会调用
private boolean enqueueMessage方法,

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

在enqueueMessage方法中首先将msg中的target赋值为当前的Handler,并且判断该Handler是否是异步消息(该种类型消息一般为系统创建),之后将消息通过queue.enqueueMessage加入到队列中

boolean enqueueMessage(Message msg, long when) {
    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是否已经退出
        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;
        //mMessage 始终标记的是MessageQueue链表的头
        Message p = mMessages;
        //线程是否需要唤醒
        boolean needWake;
        //如果p为null则表示MessageQueue为空,when = 0 表示该Message需要立即处理,
        //when < p.when这个message的执行时间要小于MessageQueue中头的时间
        //上述情况需要吧该消息加入链表头
        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 {
            //判断looper是否需要唤醒 mBlock为true表示Looper被阻塞,target为空,表示小时时同步屏障消息, msg.isAsynchronous表示msg是否为异步消息
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            //循环寻找链表插入的合适位置
            for (;;) {
                prev = p;
                p = p.next;
                //新Message的位置依赖于when的大小,最先执行的Message在队列的前面。
                //该if语句是判断,循环是否已经到头,或者执行时间小于当前位置Message的时间,是便插入
                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;
}

queue.enqueueMessage中主要的代码就是插入msg的逻辑,分为两种情况,如果列表时空的则直接插到表头,否则就循环遍历链表,找到when的大小比当前位置小的链表项目,插入这个当前项的前面,如果找不到,插入到链表尾部

除此之外Handler还有两个插入消息的方法

public final boolean sendMessageAtFrontOfQueue(@NonNull Message msg)
public final boolean executeOrSendMessage(@NonNull Message msg)

sendMessageAtFrontOfQueue方法会发送一个when为0的消息,因为when为0,所以这个消息会直接插到队列同步,插队抢占别的消息执行的机会。
executeOrSendMessage方法会验证Handler调用的地方是否时自己的线程,如果是则直接执行消息,否则就把这个消息发送到对应的MessageQueue中,不过这个方法被@Hide修饰,没办法被调用

消息分发

消息的分发主要是Looper来进行,当调用Looper.looper()方法时,Looper开始遍历MessageQueue。

@SuppressWarnings("AndroidFrameworkBinderIdentity")
public static void loop() {
    //循环遍历Looper
    for (;;) {
        if (!loopOnce(me, ident, thresholdOverride)) {
            return;
        }
    }
}

上述方法最终调用MessageQueue中的next()方法

@UnsupportedAppUsage
Message next() {
    //在调用dispose()方法后mPtr变为0,该字段为0标志Looper已经被退出,并且不允许重启
    final long ptr = mPtr;
    if (ptr == 0) {
        return null;
    }

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
        //阻塞Looper进程,nextPollTimeoutMillis表示多长时间自动唤醒,
        //nextPollTimeoutMillis为-1的时候需要主动唤醒Looper
        //nextPollTimeoutMillis是最近可以运行的消息时间和开机时间戳的差值
        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            //获取当前开机运行时间戳(设备深度睡眠不累加)
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            //优先处理同步屏障消息,当消息是同步屏障消息,会将MessageQueue中的异步消息取出来处理
            if (msg != null && msg.target == null) {
                //将MessageQueue中的异步消息取出来
                //(msg != null && !msg.isAsynchronous())当msg不为空,且msg不为同步消息的时候继续循环,
                //直到找到MessageQueu中的异步消息
                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 {
                    // 获取到消息,返回msg
                    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 {
                //如果没有消息则让Looper阻塞并需要唤醒
                nextPollTimeoutMillis = -1;
            }
            if (mQuitting) {
                dispose();
                return null;
            }
            //代码走到这边表示没有要处理的消息,Looper进入空闲时起
            //查询是否有IdleHandler
            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);
        }

       
        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 {
                //运行idler
                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;

        //在调用空闲处理程序时,可能已经传递了一条新消息,因此无需等待即可返回并再次查找未决消息。
        nextPollTimeoutMillis = 0;
    }
}

在上述代码中我们有几个关键的地方需要了解

  • 如果消息中有同步屏障消息,那么Looper将会优先处理消息队列中的异步消息。
  • 如果没有消息需要处理,则会调用IdlerHandler,利用空闲片段处理空闲任务
  • 如果没有消息且没有IdlerHandler,Looper将会进入阻塞,释放CPU资源,并且需要主动唤醒

消息的处理

Looper在获取到需要处理的消息后,会调用msg.target.dispatchMessage(msg);来调用Handler中的dispatchMessage方法来处理消息

public void dispatchMessage(@NonNull Message msg) {
    //首先判断msg是否设置了callBack
    //Handler.post系列的方法,都是在msg中设置callback
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        //检测是Handler否设置了CallBack, 如果该回调返回true则不会继续调用handleMessage处理消息
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        //调用handleMessage
        handleMessage(msg);
    }
}

消息分发的优先级

1.Message的回调方法:message.callback.run(),优先级最高 (Handler.post系列的方法都是给msg设置了callBack)

2.Handler的回调方法 Handler.mCallBack.handleMessage(msg)

val handler = Handler(Looper.getMainLooper()
) {
    //返回true则表示拦截了消息,不会调用handleMessage来处理消息
    true
}

3.Handler的默认方法:Handler.handleMessage(msg)

面试中遇到的Handler问题

  1. 为什么主线程不会因为Looper.loop()里的死循环卡死

主线程确实是通过Looper.loop()进入循环状态,因为这样主线程才不会像我们创建的一般线程一样,当可执行的代码执行完毕后,线程生命周期就被终止了。

在主线程中MessageQueue中没有可处理的消息是,便阻塞在MessageQueue.next()中的nativePollOnce()方法里,此时主线程会释放CPU资源进入休眠状态,知道新消息达到,所以主线程大多时候都处于休眠状态,并不会消耗大量CPU资源

这里采用的是Linux的epoll机制, 是一种IO多路复用机制,可以同时监控多个文件描述符,当某个文件描述符就绪,则立刻通知相应程序进行读或写操作拿到最新的消息,进而唤醒等待的线程。

2.post和snedMessage两类发送消息的方法有什么区别?

post一类的方法发送的Runable对象,但是其最后还是会被封装成Message对象,将Runable对象赋值给Message对象中的callBack变量,然后交由sendMessageAtTime()方法发送出去,在处理消息时,会在dispatchMessage()方法里首先被handleCallback(msg)方法执行.实际上就是执行了Message对象里Runable对象的run方法。
而sendMessage一类的方法发送的直接是Message对象,处理消息是,在dispatchMessage()里优先级会低于handleCallback(msg)方法,是通过自己重写的handleMessage(msg)方法来处理的。

3.为什么要通过Message.obtain()方法获取Message对象?

obtain()方法可以从全局消息池中得到一个空的Message对象,这样可以有效的节省系统资源。同时通过obtain各种重载方法还能获得一些Message拷贝,或对Message对象进行初始化。

4.Handler实现发送延迟消息的原理是什么

我们常用的postDelayed与sendMessageDelayed来发送延迟消息,其实最终都是将延迟时间转为确定时间,然后通过sendMessageAtTime()->enqueueMessage->queue.enqueueMessage这一系列方法将消息插入MessageQueue中,所以并不是延迟发送消息,而是直接发送消息,在借助MessageQueue的设计来实现消息的延迟处理。

消息延迟处理的原理涉及MessageQueue的两个静态方法next()和enqueueMessage()通过native方法阻塞一段时间等到消息的执行时候在取出消息

5.同步屏障SyncBarrier是什么?有什么作用

在一般情况下,同步和异步消息处理没有什么不同,只有在设置了同步屏障消息后才会有差异,同步屏障消息的target为null,在messageQueue中如果当前消息是一个同步屏障消息,则会跳过后面所有同步消息,找到第一个异步消息来处理。但是开发者调用不了,在ViewRootImpl的UI测绘流程中有体现

6.IdleHandler是什么?有什么用?

当消息队列中没有需要处理的消息时调用(MessageQueue此时可能还有消息,但是不需要处理),会调用此方法,用以监听主线程空闲状态

7.为什么非静态类的Handler导致内存泄漏,如何解决

首先非静态类,匿名内部类,局部内部类都会隐式的持有外部类的引用,也就时说在Activity中创建的Handler会持有Activity引用。

当我们在主线程中使用Handler的时候,Handler会默认绑定这个线程的Looper对象,并关联其MessageQueue,Handler发出的消息都会加入到这个MessageQueue中,Looper对象的生命周期贯穿了整个主线程的生命周期,所以当Looper对象中的MessageQueue里还有未处理的Message时,因为每个Message都持有Handler的引用,所以Handler无法被回收,自然其持有引用的外部类Activity也无法回收,造成泄漏。

使用静态内部类 + 弱引用的方式

private static class StaticHandler extends Handler{
 private WeakReference mWeakReference;
    public StaticHandler(Activity activity){
        mWeakReference = new WeakReference<>(activity);
    }

    @Override
    public void handleMessage(@NonNull Message msg) {
        Activity activity = mWeakReference.get();
        if(activity == null) return;
        // todo 处理消息
    }
}

8.如何让在子线程中弹出Toast

调用Looper.prepare以及Looper.loop(),但是切记线程任务执行玩,需要手动调用Looper.quitSafely()否则线程不会结束

你可能感兴趣的:(Android基础,android,kotlin)