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, 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)

其中sendMessageAtTime和postAtTime需求注意，他们接受的参数 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问题

为什么主线程不会由于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<Activity> 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消息机制Handler原理分析

启动Looper

Looper.prepare();

Looper.prepare()

音讯的发送与刺进

音讯分发

音讯的处理

面试中遇到的Handler问题

相关文章

iOS八股文（三）类对象的结构（上）

Kotlin 高阶函数大全（Lambdas）— —高端用法

谈JVM xmx, xms等内存相关参数合理性设置

再见收费的Navicat！操作所有数据库就靠它了！

作者信息