Android Java Looper 机制

阿豪元代码2023-10-20 16:06

本文摘自写给应用开发的 Android Framework 教程 ，完整教程请查阅 yuandaimaahao.gitee.io/androidfram... 更为详细的视频教程与答疑服务，请联系微信 zzh0838

本文基于 aosp android-12.0.0_r26 分支讲解

一个简单的 main 函数执行完毕后，整个进程也就结束了，为了让一个进程长时间的运行下去，就需要无限循环加事件通知的机制，这类机制的伪代码描述如下：

cpp 复制代码 
int main()
{
    while(true)
    {
        1. 线程进入休眠状态，等待通知；
        2. 其它地方给当前线程发送通知，线程从休眠中唤醒，读取通知，处理通知
        3. 进入下一个循环
    }

    return 0;
}

在上一节，我们已经了解了 Android Native 层的 Looper 机制，接下来我们接着学习 Android Java 层的 Looper 机制。

这里先给出 Android Java Looper 的整体框架图，接着我们再根据源码逐步分析：

Java Looper 的使用

首先我们从一个典型的 Looper 线程来看看 Looper 具体是怎么使用的：

java 复制代码 
// 典型的关于Handler/Looper的线程
class LooperThread extends Thread {

    public Handler mHandler;

    public void run() {
       
        Looper.prepare();   
        
        mHandler = new Handler() {  
            public void handleMessage(Message msg) {
                //定义消息处理逻辑. 
                Message msg = Message.obtain();
            }
        };

        Looper.loop();  
    }
}

// 其他线程
Message msg = Message.obtain();
msg.what = 2; 
msg.obj = "B"; 
// 向 looper 发送一个消息
looperThread.mHandler.sendMessage(msg);

使用上来说：

Looper 线程：

  • 调用 Looper.prepare() 初始化 Looper
  • 初始化一个 Handler 对象
  • Looper.loop() 进入循环休眠状态

其他线程：

  • 获取到 Looper 线程中的 Handler 对象
  • 构建一个 Message 对象
  • 调用 Handler 对象的 sendMessage 发送消息给 Looper

Looper.prepare() 实现分析

java 复制代码 
public static void prepare() {
    prepare(true);
}

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

prepare 中首先从线程本地数据区取 Looper，如果没有，就 new 一个 Looper，并存到线程本地数据区中。

接下来看看 new 一个 Looper 的过程：

java 复制代码 
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);  //创建MessageQueue对象
    mThread = Thread.currentThread();
}

构造函数中，new 了一个 MessageQueue，获取到了当前线程 Thread 对象。

接着看 MessageQueue 的初始化过程：

java 复制代码 
MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

private native static long nativeInit();

这里调用了 native 方法 nativeInit，对应的 JNI 函数是

android_os_MessageQueue_nativeInit：

cpp 复制代码 
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
    if (!nativeMessageQueue) {
        jniThrowRuntimeException(env, "Unable to allocate native queue");
        return 0;
    }

    nativeMessageQueue->incStrong(env);
    return reinterpret_cast<jlong>(nativeMessageQueue);
}

这里，核心内容就是初始化一个 NativeMessageQueue 对象，并将其地址返回给 Java 层。我们接着看 NativeMessageQueue 对象的初始化过程：

cpp 复制代码 
// NativeMessageQueue 构造函数
NativeMessageQueue::NativeMessageQueue() :
        mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
    // 初始化 Native 层的 looper
    mLooper = Looper::getForThread();
    if (mLooper == NULL) {
        mLooper = new Looper(false);
        Looper::setForThread(mLooper);
    }
}

NativeMessageQueue 的构造函数中，从本地线程区获取当前线程的 Looper 对象，没有的话，就初始化一个，并存在线程本地数据区中。

Native 层 Looper 对象的初始化，核心内容就三点：

  • 初始化一个 eventfd
  • 初始化一个 epoll
  • 把 eventfd 放到 epoll 池中

具体代码请参考Android Native Looper 机制的 Native Looper 源码分析 章节，这里不再重复。

Looper.loop()

初始化工作完成后，我们接着再来看看 loop 方法都执行了哪些操作：

java 复制代码 
    public static void loop() {
        // 获取 TLS 存储的 Looper 对象
        final Looper me = myLooper(); 
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        if (me.mInLoop) {
            Slog.w(TAG, "Loop again would have the queued messages be executed"
                    + " before this one completed.");
        }

        me.mInLoop = true;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        // Allow overriding a threshold with a system prop. e.g.
        // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
        final int thresholdOverride =
                SystemProperties.getInt("log.looper."
                        + Process.myUid() + "."
                        + Thread.currentThread().getName()
                        + ".slow", 0);

        me.mSlowDeliveryDetected = false;

        // 进入无限循环，调用 loopOnce 进入休眠状态
        for (;;) {
            if (!loopOnce(me, ident, thresholdOverride)) {
                return;
            }
        }
    }

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

代码很长，但是核心功能就两点：

  • 获取 TLS 存储的 Looper 对象
  • 进入无限循环，调用 loopOnce 进入休眠状态

接下来就来看看 loopOnce 到底是怎么工作的

java 复制代码 
    private static boolean loopOnce(final Looper me,
            final long ident, final int thresholdOverride) {
        
        // 获取 Message，可能阻塞
        Message msg = me.mQueue.next(); 
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return false;
        }

        // This must be in a local variable, in case a UI event sets the logger
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " "
                    + msg.callback + ": " + msg.what);
        }
        // Make sure the observer won't change while processing a transaction.
        final Observer observer = sObserver;

        final long traceTag = me.mTraceTag;
        long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
        long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
        if (thresholdOverride > 0) {
            slowDispatchThresholdMs = thresholdOverride;
            slowDeliveryThresholdMs = thresholdOverride;
        }
        final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
        final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);

        final boolean needStartTime = logSlowDelivery || logSlowDispatch;
        final boolean needEndTime = logSlowDispatch;

        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }

        final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
        final long dispatchEnd;
        Object token = null;
        if (observer != null) { 
            token = observer.messageDispatchStarting();
        }
        long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
        try {
            //分发消息，调用 handler 中的回调函数
            msg.target.dispatchMessage(msg); 
            if (observer != null) {
                observer.messageDispatched(token, msg); 
            }
            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
        } catch (Exception exception) {
            if (observer != null) {
                observer.dispatchingThrewException(token, msg, exception);
            }
            throw exception;
        } finally {
            ThreadLocalWorkSource.restore(origWorkSource);
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        if (logSlowDelivery) {
            if (me.mSlowDeliveryDetected) {
                if ((dispatchStart - msg.when) <= 10) {
                    Slog.w(TAG, "Drained");
                    me.mSlowDeliveryDetected = false;
                }
            } else {
                if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                        msg)) {
                    // Once we write a slow delivery log, suppress until the queue drains.
                    me.mSlowDeliveryDetected = true;
                }
            }
        }
        if (logSlowDispatch) {
            showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
        }

        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }

        // Make sure that during the course of dispatching the
        // identity of the thread wasn't corrupted.
        final long newIdent = Binder.clearCallingIdentity();
        if (ident != newIdent) {
            Log.wtf(TAG, "Thread identity changed from 0x"
                    + Long.toHexString(ident) + " to 0x"
                    + Long.toHexString(newIdent) + " while dispatching to "
                    + msg.target.getClass().getName() + " "
                    + msg.callback + " what=" + msg.what);
        }

        msg.recycleUnchecked();

        return true;
    }

代码很长，核心流程不多：

  • 通过 MessageQueue 的 next 方法拿到一个 Message，这里可能会阻塞休眠，具体为什么，后面马上说
  • 通过 dispatchMessage 调用 Handler 中的回调方法

接着就来看 mQueue.next() 的实现：

java 复制代码 
    Message next() {
        // Return here if the message loop has already quit and been disposed.
        // This can happen if the application tries to restart a looper after quit
        // which is not supported.
        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();
            }

            // 陷入 Native 层，进入休眠状态
            nativePollOnce(ptr, nextPollTimeoutMillis);

            //......
        }
    }

    private native void nativePollOnce(long ptr, int timeoutMillis);

这里调用 nativePollOnce 陷入 Native 层，进入休眠状态，nativePollOnce 是一个 Native 方法，对应的 JNI 函数如下：

cpp 复制代码 
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jlong ptr, jint timeoutMillis) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}

通过传入的指针，获取到 Native 层的 NativeMessageQueue 对象，接着调用 NativeMessageQueue 对象的 pollOnce 方法：

cpp 复制代码 
void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
    mPollEnv = env;
    mPollObj = pollObj;
    // 内部调用 epoll_wait 阻塞
    mLooper->pollOnce(timeoutMillis);
    mPollObj = NULL;
    mPollEnv = NULL;

    if (mExceptionObj) {
        env->Throw(mExceptionObj);
        env->DeleteLocalRef(mExceptionObj);
        mExceptionObj = NULL;
    }
}

这里会调用 Native 层 Looper 的 pollOnce 函数，pollOnce 内部主要是调用 epoll_wait 来进入休眠状态。pollOnce 的具体代码分析可以参考Android Native Looper 机制，这里不再重复。

至此，我们的线程就下 cpu，进入休眠状态。

接下里我们就来看看怎么把休眠中的线程唤醒。

发送消息

发送消息大致两步：

  • 初始化一个 Handler 对象，覆写 Handler 的 handleMessage 方法
  • 构建一个 Message 对象，通过 Handler 的 sendMessage 方法发送消息

Handler 初始化过程

在使用 Looper 的线程中通常会初始化一个 Handler 对象：

java 复制代码 
    // new 一个 Handler，覆写 handleMessage 方法
    mHandler = new Handler() {  
        public void handleMessage(Message msg) {
            //定义消息处理逻辑. 
        }
    };

Handler 的构造函数：

java 复制代码 
    public Handler() {
        this(null, false);
    }

    public Handler(@Nullable Callback callback, boolean async) {
        //......

        //拿到当前线程的 Looper 对象
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

初始化过程中，要对 Handler 中有两个重要变量进行赋值：

  • mLooper：当前线程中的 Looper 对象
  • mQueue：当前线程中的 Looper 对象的 MessageQueue 成员

做好以上的准备工作后，就可以向 Looper 发送消息了：

java 复制代码 
    // 构建一个 Message
    Message msg = Message.obtain();
    msg.what = 2; 
    msg.obj = "B"; 
    // 通过 Handler 的 sendMessage 方法发送消息
    mHandler.sendMessage(msg);

我们先看看 Message 的初始化过程：

java 复制代码 
    // frameworks/base/core/java/android/os/Message.java
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

从缓存 sPool 里面取 Message，如果没有的话就 new 一个 Message。

接着我们来看 sendMessage 的过程：

java 复制代码 
    // frameworks/base/core/java/android/os/Handler.java
    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) {

        // 注意这里，把 handler 赋值给了 msg 的 target 成员
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

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

sendMessage 内部把 handler 赋值给了 msg 的 target 成员，最终调用到 MessageQueue 的 enqueueMessage 方法：

java 复制代码 
    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.");
            }

            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;
            // 把传入的 Message 插入 mMessages 链表
            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;
            }

            // 唤醒 native 层的 epoll
            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);  
            }
        }
        return true;
    }

enqueueMessage 代码有点长，核心逻辑就两点：

  • 把传入的 Message 插入 mMessages 链表
  • 调用 native 方法 nativeWake 唤醒 native 层的 epoll

接下来我们看看 nativeWake 的具体实现：

java 复制代码 
private native static void nativeWake(long ptr);

// nativeWake 对应的 JNI 函数 
static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->wake();
}

void NativeMessageQueue::wake() {
    mLooper->wake();
}

// eventfd 写数据，唤醒 epoll
void Looper::wake() {
    uint64_t inc = 1;
    ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd.get(), &inc, sizeof(uint64_t)));
    if (nWrite != sizeof(uint64_t)) {
        if (errno != EAGAIN) {
            LOG_ALWAYS_FATAL("Could not write wake signal to fd %d (returned %zd): %s",
                             mWakeEventFd.get(), nWrite, strerror(errno));
        }
    }
}

nativeWake 最终就是调用 native 层 mLooper 的 wake 函数，在 wake 函数中向 eventfd 写入数据，唤醒与 eventfd 绑定的 epoll。接下来我们就来看看 epoll 唤醒以后得流程。

唤醒后的流程

cpp 复制代码 
void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
    mPollEnv = env;
    mPollObj = pollObj;
    // Looper 线程阻塞在 Native 层的这里
    mLooper->pollOnce(timeoutMillis);
    mPollObj = NULL;
    mPollEnv = NULL;

    if (mExceptionObj) {
        env->Throw(mExceptionObj);
        env->DeleteLocalRef(mExceptionObj);
        mExceptionObj = NULL;
    }
}

唤醒后，回到上层函数 android_os_MessageQueue_nativePollOnce：

cpp 复制代码 
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jlong ptr, jint timeoutMillis) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}

接着，再回到更上一层 Java 层的 next 方法中：

Java 复制代码 
    Message next() {
        // Return here if the message loop has already quit and been disposed.
        // This can happen if the application tries to restart a looper after quit
        // which is not supported.
        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();
            }

            //从这个位置唤醒
            nativePollOnce(ptr, nextPollTimeoutMillis);


            // 从 mMessages 链表中选取一个合适的 message 返回
            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;
                }

                // Process the quit message now that all pending messages have been handled.
                if (mQuitting) {
                    dispose();
                    return null;
                }

                // If first time idle, then get the number of idlers to run.
                // Idle handles only run if the queue is empty or if the first message
                // in the queue (possibly a barrier) is due to be handled in the future.
                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);
            }

            // Run the idle handlers.
            // We only ever reach this code block during the first iteration.
            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 {
                    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;

            // While calling an idle handler, a new message could have been delivered
            // so go back and look again for a pending message without waiting.
            nextPollTimeoutMillis = 0;
        }
    }

唤醒后，一般的流程就是从 mMessages 中找个合适的 message 返回，返回后进入上一层：

java 复制代码 
    private static boolean loopOnce(final Looper me,
            final long ident, final int thresholdOverride) {
        
        // 从这里返回
        Message msg = me.mQueue.next(); 
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return false;
        }

        // This must be in a local variable, in case a UI event sets the logger
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " "
                    + msg.callback + ": " + msg.what);
        }
        // Make sure the observer won't change while processing a transaction.
        final Observer observer = sObserver;

        final long traceTag = me.mTraceTag;
        long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
        long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
        if (thresholdOverride > 0) {
            slowDispatchThresholdMs = thresholdOverride;
            slowDeliveryThresholdMs = thresholdOverride;
        }
        final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
        final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);

        final boolean needStartTime = logSlowDelivery || logSlowDispatch;
        final boolean needEndTime = logSlowDispatch;

        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }

        final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
        final long dispatchEnd;
        Object token = null;
        if (observer != null) { 
            token = observer.messageDispatchStarting();
        }
        long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
        try {
            //分发消息，调用 handler 中的回调函数
            msg.target.dispatchMessage(msg); 
            if (observer != null) {
                observer.messageDispatched(token, msg); 
            }
            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
        } catch (Exception exception) {
            if (observer != null) {
                observer.dispatchingThrewException(token, msg, exception);
            }
            throw exception;
        } finally {
            ThreadLocalWorkSource.restore(origWorkSource);
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        if (logSlowDelivery) {
            if (me.mSlowDeliveryDetected) {
                if ((dispatchStart - msg.when) <= 10) {
                    Slog.w(TAG, "Drained");
                    me.mSlowDeliveryDetected = false;
                }
            } else {
                if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                        msg)) {
                    // Once we write a slow delivery log, suppress until the queue drains.
                    me.mSlowDeliveryDetected = true;
                }
            }
        }
        if (logSlowDispatch) {
            showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
        }

        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }

        // Make sure that during the course of dispatching the
        // identity of the thread wasn't corrupted.
        final long newIdent = Binder.clearCallingIdentity();
        if (ident != newIdent) {
            Log.wtf(TAG, "Thread identity changed from 0x"
                    + Long.toHexString(ident) + " to 0x"
                    + Long.toHexString(newIdent) + " while dispatching to "
                    + msg.target.getClass().getName() + " "
                    + msg.callback + " what=" + msg.what);
        }

        msg.recycleUnchecked();

        return true;
    }

代码很多，核心的流程只有两点：

  • next() 处返回一个合适的 message
  • 通过 msg.target.dispatchMessage(msg) 调用 handler 中的回调

至此，整个 Looper 流程就走完了。

参考资料

关于

我叫阿豪，2015 年本科毕业于国防科学技术大学指挥信息系统专业，毕业后从事信息化装备的研发工作，主要研究方向是 Android Framework 与 Linux Kernel。

如果你对 Android Framework 感兴趣或者正在学习 Android Framework，可以关注我的微信公众号和抖音，我会持续分享我的学习经验，帮助正在学习的你少走一些弯路。学习过程中如果你有疑问或者你的经验想要分享给大家可以添加我的微信，我拉你进技术交流群。

相关推荐
小雨cc5566ru3 小时前
uniapp+Android面向网络学习的时间管理工具软件 微信小程序
android·微信小程序·uni-app
bianshaopeng4 小时前
android 原生加载pdf
android·pdf
hhzz4 小时前
Linux Shell编程快速入门以及案例（Linux一键批量启动、停止、重启Jar包Shell脚本）
android·linux·jar
火红的小辣椒5 小时前
XSS基础
android·web安全
勿问东西7 小时前
【Android】设备操作
android
五味香7 小时前
C++学习，信号处理
android·c语言·开发语言·c++·学习·算法·信号处理
图王大胜9 小时前
Android Framework AMS（01）AMS启动及相关初始化1-4
android·framework·ams·systemserver
工程师老罗11 小时前
Android Button “No speakable text present” 问题解决
android
小雨cc5566ru12 小时前
hbuilderx+uniapp+Android健身房管理系统 微信小程序z488g
android·微信小程序·uni-app
小雨cc5566ru13 小时前
微信小程序hbuilderx+uniapp+Android 新农村综合风貌旅游展示平台
android·微信小程序·uni-app
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache