Looper 需要手动 quit,那主线程 Looper 呢?

简介: Looper 需要手动 quit,那主线程 Looper 呢?

我们都清楚自行启动 Looper 的线程,在任务结束时需要手动调用 quit() 或 quitSafely() 终止 Looper 轮循。但对于其中细节似乎没有仔细思考过,抽上五分钟简要学习下!


Looper 线程为什么要手动 quit?

quit 时 Message 们怎么处置?

quitSafely 做了哪些优化?

主线程 Looper 需要 quit 吗?

Looper 线程为什么要手动 quit?

创建 Looper 并执行 loop() 的线程在任务结束的时候,需要手动调用 quit。


反之,线程将由于 loop() 的轮询一直处于可运行状态,CPU 资源无法释放。更有可能因为 Thread 作为 GC Root 持有超出生命周期的实例引发内存泄漏。


当 quit 调用后,Looper 不再因为没有 Message 去等待,而是直接取到为 null 的 Message,这将触发轮循死循环的退出。

// Looper.java
    public static void loop() {
        ...
        for (;;) {
            Message msg = queue.next();
            if (msg == null) {
                // 拿到 null 则退出
                return;
            }
            ...
        }
    }

quit 时 Message 们怎么处置?

Looper 的很多处理实则都是 MessageQueue 在发挥作用,包括这里的 Looper#quit()。它其实是调用 MessageQueue 的同名函数 quit(boolean),并指定 safe 参数为 false

// Looper.java
    public void quit() {
        // 默认是不安全的退出
        mQueue.quit(false);
    }

MessageQueue#quit() 则主要执行几项简单工作,包括:标记正在退出,并清空所有未执行的 Mesage,最后唤醒线程。

// MessageQueue.java
    void quit(boolean safe) {
        ...
        synchronized (this) {
            ...
            mQuitting = true; // 标记 quitting
            // 不安全的退出将回收队列中所有 Message,并清空队列
            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }
            // 唤醒线程
            nativeWake(mPtr);
        }
    }
  1. 退出的标记将导致后续的 sendMessage()postRunnable() 失效,直接返回 false
// MessageQueue.java
    boolean enqueueMessage(Message msg, long when) {
        ...
        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();
                // quitting flag 导致后续的 Message send 失败
                return false;
            }
            ...
        }
        return true;
    }
  1. 默认的策略是清空队列里所有 Message,包括时间正好抵达的 Message 都无法处理,不太友好安全
// MessageQueue.java
    // 一刀切:无论 when 是否抵达都出队
    // 可能当前时刻本该执行的 Message 也会被剔除,无法执行
    private void removeAllMessagesLocked() {
        Message p = mMessages;
        while (p != null) {
            Message n = p.next;
            p.recycleUnchecked();
            p = n;
        }
        mMessages = null;
    }
  1. 最后唤醒线程,进入读取队列的下一次循环,因为队列已无 Message,将直接返回 null。
// MessageQueue.java
    Message next() {
        ...
        for (;;) {
            ...
            synchronized (this) {
                ...
                // 队列已无 Message
                // 将因为行退出标志的存在直接返回 null
                if (mQuitting) {
                    dispose();
                    return null;
                }
                ...
            }
            ...
        }
    }
  1. loop() 拿到的 Message 为 null,死循环退出,线程结束。

quitSafely 做了哪些优化?

大家都知道 SDK 更推荐使用 quitSafely() 去终止 Looper,原因在于其只会剔除执行时刻 when 晚于当前调用时刻的 Message。


这样可以保证 quitSafely 调用的那刻,满足执行时间条件的 Message 继续保留在队列中,在都执行完毕才退出轮询。


调用 MessageQueue#quit(),并指定 safe 参数为 true。

// Looper.java
    public void quitSafely() {
        mQueue.quit(true);
    }
  1. 安全 quit 的时候调用 removeAllFutureMessagesLocked()
// MessageQueue.java
    void quit(boolean safe) {
        synchronized (this) {
            if (safe) {
                // 安全退出的调用
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }
            nativeWake(mPtr);
        }
    }

顾名思义, 其只会移除未来 Message。※未来是 when 相较于当前时刻而言,不是没执行的都叫作未来,不要误解!

// MessageQueue.java
    private void removeAllFutureMessagesLocked() {
        final long now = SystemClock.uptimeMillis();
        Message p = mMessages;
        if (p != null) {
            // 如果队首 Message 的执行时刻仍晚于当前时刻,那么全部清空
            if (p.when > now) {
                removeAllMessagesLocked();
            } else {
                // 否则遍历队列,筛选需要剔除的 Message
                Message n;
                for (;;) {
                    n = p.next;
                    // 没有更晚的 Message,均不需要剔除,直接返回
                    if (n == null) {
                        return;
                    }
                    // 找到队列中最前一个晚于当前时刻的 Message
                    if (n.when > now) {
                        break;
                    }
                    p = n;
                }
                // 前一个 Message 后全部出队
                p.next = null;
                // 将最前一个晚于当前时刻的 Message 及之后的 Message 回收
                do {
                    p = n;
                    n = p.next;
                    p.recycleUnchecked();
                } while (n != null);
            }
        }
    }
  1. 移除未来 Message 之后唤醒线程的 next() 循环,其将取出留在队列里的 Message 进行处理。
    Message next() {
        ...
        for (;;) {
            ...
            synchronized (this) {
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                ...
                if (msg != null) {
                    // 队列里的 Message 早于当前时间,进入else
                    if (now < msg.when) {
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        mBlocked = false;                        
                        // Message 出队并更新指向
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            // 队首后移一个节点
                            mMessages = msg.next;
                        }
                        // 拿到了 Message,并交给 Looper 回调
                        msg.next = null;
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    ...
                }
                // 队列里仍残存 Message
                // 暂时不会因为退出标志返回 null
                if (mQuitting) {
                    dispose();
                    return null;
                }
            }
            ...
        }
    }
  1. 等残存 Message 都执行完了,下一次轮询的 next() 将取不到 Message,最终因为 quitting flag 返回 null,进而触发 loop() 死循环的退出。

主线程 Looper 需要 quit 吗?

主线程 ActivityThread 创建 Looper 时指定了不允许 quit 的标志,即不可以手动调用 quit。

// Looper.java
    public static void prepareMainLooper() {
        prepare(false);
        ...
    }
    private static void prepare(boolean quitAllowed) {
        ...
        sThreadLocal.set(new Looper(quitAllowed));
    }
    // Main Looper 初始化的时候指定了不允许退出
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        ...
    }

如果强行在主线程里调用了 quit(),会发生如下异常:

java.lang.IllegalStateException: Main thread not allowed to quit.

// MessageQueue.java
    void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }
        ...
    }

那主线程需要 quit 吗?


不需要,在内存不足的时候 App 由 AMS 直接回收进程。


不需要 quit 的原因在于?


主线程极为重要,承载着 ContentProvider、Activity、Service 等组件生命周期的管理,即便某个组件结束了,它仍有继续存在去调度其他组件的必要!


换言之,ActivityThread 的作用域超过了这些组件,不该由这些组件去处理它的结束。 比如,Activity destroy 了,ActivityThread 仍然要处理其他 Activity 或 Service 等组件的事务,不能结束。

结语

基于回收资源或避免内存泄漏的考虑,在 Thread 完成任务后应当手动 quit。而为了确保 quit 时本可以执行的 Message 能安全执行,尽量调用 quitSafely。同时搞清楚主线程 Looper 的重要性,不需要也不可以被手动 quit!

目录
打赏
0
0
0
0
8
分享
相关文章
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区,如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等,并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比,直观展示了正确与错误的实现方式,旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
深入浅出Java多线程编程
【10月更文挑战第40天】在Java的世界中,多线程是提升应用性能和响应能力的关键。本文将通过浅显易懂的方式介绍Java中的多线程编程,从基础概念到高级特性,再到实际应用案例,带你一步步深入了解如何在Java中高效地使用多线程。文章不仅涵盖了理论知识,还提供了实用的代码示例,帮助你在实际开发中更好地应用多线程技术。
108 5
|
17天前
|
Linux编程: 在业务线程中注册和处理Linux信号
本文详细介绍了如何在Linux中通过在业务线程中注册和处理信号。我们讨论了信号的基本概念,并通过完整的代码示例展示了在业务线程中注册和处理信号的方法。通过正确地使用信号处理机制,可以提高程序的健壮性和响应能力。希望本文能帮助您更好地理解和应用Linux信号处理,提高开发效率和代码质量。
42 17
|
26天前
|
Linux编程: 在业务线程中注册和处理Linux信号
通过本文,您可以了解如何在业务线程中注册和处理Linux信号。正确处理信号可以提高程序的健壮性和稳定性。希望这些内容能帮助您更好地理解和应用Linux信号处理机制。
54 26
|
2月前
|
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
239 2
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景,并结合代码示例和实用技巧,帮助开发者有效避免这些陷阱,提升并发程序的稳定性和性能。 ####
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
2月前
|
多线程编程核心:上下文切换深度解析
在现代计算机系统中,多线程编程已成为提高程序性能和响应速度的关键技术。然而,多线程编程中一个不可避免的概念就是上下文切换(Context Switching)。本文将深入探讨上下文切换的概念、原因、影响以及优化策略,帮助你在工作和学习中深入理解这一技术干货。
63 10
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱,并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手,逐步深入到具体的代码示例,帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者,都能从中获得有价值的见解和建议。 ####
|
2月前
|
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念,包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着,详细讲解了Java提供的同步机制,如synchronized关键字、wait()和notify()方法等,以及如何通过这些机制实现线程间的协调与通信。最后,本文还讨论了一些常见的并发问题,例如死锁、竞态条件等,并提供了相应的解决策略。
76 3
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等