Android源码解读-Handler、Looper、MessageQueue

笔头 • 2023-01-02 • 云技术社区 • 474 阅读

一、是什么

在启动一个线程时，会创建一个Looper，同时在内部创建一个消息队列MessageQueue，此时线程会进入一个无限循环中，不断检查消息队列是否有消息。如果有就从消息队列里面取出来，通过Handler来处理消息，否则，线程进入睡眠状态，直到有新消息为止。（队列里消息是通过Handler发送的）

接下来我们就逐步学习他吧。

二、源码解析

Looper的创建

Android应用程序进程在启动的时候，会在线程中加载ActivityThread类，并且执行这个类的main函数，应用程序的消息循环过程就是在这个main函数里面实现的。

public static void main(String[] args) {
    ......
    Looper.prepareMainLooper();
    ......
    Looper.loop();
    ......
}

1.创建Looper

prepareMainLooper方法只能调用一次

public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

prepare方法：把Looper对象存放在当前线程即UI线程中，不重复存放。即一个线程对应一个Looper

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

我们来看看Looper创建实例

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

做了2件事，1.创建MessageQueue，也就是存放Message的队列。2.获得当前线程，这个线程主要用来判断Looper是不是属于当前线程。

myLooper方法，比较简单，直接从ThreadLocal取出。ThreadLocal可以参考这篇文章 ThreadLocal浅析

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

上面我们知道Looper的来源，创建Looper的时候同时创建了MessageQueue。接下来看下，Looper是如何无限循环遍历消息队列的。

loop源码

public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    ......
    final MessageQueue queue = me.mQueue;
    ......
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            return;
        }
        ......
        try {
            msg.target.dispatchMessage(msg);
        ......
        } 
        ......
    }
}

我们可以看到loop里面是通过for(;;)无限循环，通过queue.next()不断重消息队列MessageQueue获取消息，这MessageQueue是个阻塞式的队列。在没有消息时，当前线程在next中进入睡眠状态，否则通过msg.target.dispatchMessage(msg)把消息进行处理，这里的msg.target就是Handler，后面将会提到。

我们来看下next是如何运行的吧。

next源码

Message next() {
    final long ptr = mPtr;
    ...............
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
        nativePollOnce(ptr, nextPollTimeoutMillis);
        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            
            //-------------------1----------------------------
            if (msg != null && msg.target == null) {
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
            
                //-----------------------------2--------------------
                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;
            }

            .............
    }
}
展开

上面源码中，nextPollTimeoutMillis是一个重点，表示睡眠时间。

nativePollOnce(ptr, nextPollTimeoutMillis);【内部源码这里就先暂时不看了，有机会以后再看看】

当nextPollTimeoutMillis=-1时，表示没有消息，当前线程会进入无限睡眠状态。

当nextPollTimeoutMillis=0时，表示当前线程不会进入睡眠状态。

当nextPollTimeoutMillis>0时，当前线程会睡眠nextPollTimeoutMillis时间。

在代码1中，我们可以得知，如果头Message的target为null，则查找一个异步Message来进行下一步处理。

如果没有拿到数据，即msg==null，那nextPollTimeoutMillis=-1，那下次调用nativePollOnce时，当前线程会进入无限睡眠状态。

在代码2中，如果拿到数据了，接下来就是考虑延迟处理消息还是直接处理消息。

1.判断下他的when【系统开机截止到现在的时间+delay时间】和系统开机截止到现在的时间now比较，如果when大于now，那当前线程就会睡眠nextPollTimeoutMillis，也就阻塞nextPollTimeoutMillis

2.正常情况下prevMsg==null，我们直接拿当前正在处理的msg的next作为新的待处理mMessages，同时清除当前正在处理msg的next。

无限循环遍历MessageQueue过程就这些，上面讲了如何获取Message以及MessageQueue如何阻塞的。接下来是对遍历MessageQueue下来的Message进行处理。也就是执行msg.target.dispatchMessage(msg);

在看msg.target.dispatchMessage(msg);之前，我们先看下，Handler如何发送消息的吧。

enqueueMessage源码

Handler 发送消息最终是调用Handler.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);
}

嘿嘿，这里我们发现msg.target =this;target就是当前Handler这个queue是哪里来的？看下Handler的构造函数我们可以知道，此时的queue即MessageQueue是从当前线程Looper中取得的。这里就不贴代码了。

接下来看MessageQueue的enqueueMessage源码

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

看代码1，假如when==0或when小于当前正在处理msg的when或者队列为空，就把新添加的msg放到对头。这很好理解，when越小的越靠近对头，MessageQueue 是一个按照处理时间从小到大排序的队列，loop遍历MessageQueue是从对头开始获取数据。

代码2，这个情况是新添加的msg的when比当前正在处理的msg的when要大，那就遍历队列，直到找到when比新添加的msg的when大的msg，然后插入。

代码3，每次插入msg的时候，判断needWake，是否要唤醒当前线程，上面代码我们知道，当消息插入对头的时候，如果当前线程处于睡眠状态，needWake=true。当消息插入中间时，needWake=false。

MessageQueue的enqueueMessage相对容易理解，上面是添加Message的整个过程，接下来我们是时候看看Handler是如何处理消息的。

dispatchMessage源码

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

这里面主要有两个变量需要重点看看

1.msg.callback,这个是在什么时候定义的呢？

我们先看下handleCallback(msg)

private static void handleCallback(Message message) {
    message.callback.run();
}

这个callback执行了run方法，好像是个Runnable，我们搜索Handler源码看下，我们在调用post方法时会提供Runnable参数，

handler.post(new Runnable() {
    @Override
    public void run() {
    }
})

那我们知道，此时的callback就是个Runnable。

2.mCallback,这个变量什么时候定义的?看下Handler的构造函数，我们知道，这里的mCallback就是Handler里定义的Callback接口。

public interface Callback {
    boolean handleMessage(@NonNull Message msg);
}

就是如果你定义了Callback接口，那数据处理就在handleMessage里处理。

Handler handler=new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(@androidx.annotation.NonNull Message msg) {
        return false;
    }
});

这个时候，我们再回看第一节对Handler、Looper、MessageQueue的描述，是不是有更深刻的理解了。

三、相关设计模式

1.享元模式：

消息系统需要不断的产生Message、处理Message、销毁Message，这种重复大量的构建Message，recycleUnchecked方法并不是销毁Message，而是把Message里的各种成员变量置为null，下次有新的消息的时候，直接复用，而不是再去new Message，减少了内存碎片的出现，减少了内存抖动，提高了程序的性能。