深入理解 Android Handler

news2025/4/24 2:51:56

一、引言

Handler 在安卓中的地位是不言而喻的，几乎维系着整个安卓程序运行的生命周期，但是这么重要的一个东西，我们真的了解它吗？下面跟随着我的脚步，慢慢揭开Hanler的神秘面纱吧！

本文将介绍Handler 的运行机制、MessageQueue、Looper 的关系，ThreadLocal，以及Handler 导致的内存泄漏问题

二、Handler 系统组成概览

在 Handler 的源码中，主要涉及以下核心组件：

  • Message：封装消息的数据结构。
  • MessageQueue：存储 Message 的队列，内部是单链表。
  • Looper：负责循环读取 MessageQueue 并分发消息。
  • Handler：对外提供 sendMessage()、post() 发送消息，并处理 MessageQueue 中的消息。

它们之间关系如下图所示：

三、Handler 的创建

当 Handler 被创建时，它会绑定当前线程的 Looper：

public Handler() {
    this(Looper.myLooper(), null, false);
}

public Handler(Looper looper) {
    this(looper, null, false);
}

最终调用：

public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async,
               boolean shared) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
    mIsShared = shared;
}
  • mLooper 通过 Looper.myLooper() 获取当前线程的 Looper。
  • mQueue 由 Looper 提供，确保所有 Handler 在同一个 Looper 线程内共享 MessageQueue。

重点：主线程默认初始化 Looper，但子线程默认没有，需要手动 Looper.prepare()。

如果一定要在子线程中使用，推荐使用 HandlerThread，比于手动创建 Looper，HandlerThread 封装了 Looper 的创建和管理逻辑，代码更加简洁，也更易于维护。同时，HandlerThread 有自己独立的消息队列，不会干扰主线程或其他线程的消息处理。

四、sendMessage() 如何发送消息

当我们调用 sendMessage() 时：

handler.sendMessage(msg);

实际上调用：

public boolean sendMessage(Message msg) {
    return sendMessageDelayed(msg, 0);
}

最终：

public boolean sendMessageDelayed(Message msg, long delayMillis) {
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

最终调用 enqueueMessage()：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this; // 绑定 Handler
    return queue.enqueueMessage(msg, uptimeMillis);
}

@UnsupportedAppUsage
/*package*/ Handler target;

也就是说 Message 引用了 Handler，这也为内存泄漏埋下伏笔

五、MessageQueue 插入消息

boolean enqueueMessage(Message msg, long when) {
    synchronized (this) {
        // 插入 MessageQueue
                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;
            }
    }
    return true;
}

enqueueMessage 方法负责将消息按照时间顺序正确地插入到单链表结构的队列中，按 when 进行排序。

六、Looper 如何处理消息

Looper.loop() 读取消息
public static void loop() {
    for (;;) {
        Message msg = queue.next(); // 取出消息
        //...
        msg.target.dispatchMessage(msg); // 交给 Handler 处理
    }
}
MessageQueue.next()
Message next() {
    // 检查消息队列是否已销毁，若销毁则返回 null
    if (mPtr == 0) return null;

    int nextPollTimeoutMillis = 0;
    for (;;) {
        // 若有超时时间，刷新 Binder 待处理命令
        if (nextPollTimeoutMillis != 0) Binder.flushPendingCommands();
        // 阻塞线程，等待新消息或超时
        nativePollOnce(mPtr, nextPollTimeoutMillis);

        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            Message msg = mMessages;
            // 若为屏障消息，找下一个异步消息
            if (msg != null && msg.target == null) {
                do { 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 {
                    // 若消息到处理时间，从队列移除并返回
                    mMessages = msg.next;
                    msg.next = null;
                    msg.markInUse();
                    return msg;
                }
            } else {
                // 若无消息，一直阻塞
                nextPollTimeoutMillis = -1;
            }
            // 若消息队列正在退出，释放资源并返回 null
            if (mQuitting) {
                dispose();
                return null;
            }
        }
    }
}

nativePollOnce() 让当前线程进入阻塞状态，直到有新的消息到来或者超时

nativePollOnce() 的主要功能是：

  • 线程阻塞：让当前线程进入等待状态，避免空转消耗CPU资源
  • 事件唤醒：当有新消息到达或超时发生时，立即唤醒线程处理
  • Native 层集成：与 Linux 的 epoll 机制对接，实现高效I/O多路复用
void nativePollOnce(long ptr, int timeoutMillis)

ptr：指向 Native Looper 对象的指针（C++对象地址）

timeoutMillis 的含义：

  • 如果 timeoutMillis > 0
    • epoll_wait 最多阻塞 timeoutMillis 毫秒，期间如果有事件发生，则提前返回。
  • 如果 timeoutMillis == 0
    • epoll_wait 立即返回（非阻塞）。
  • 如果 timeoutMillis < 0
    • epoll_wait 无限等待，直到有事件触发。

最终调用了 Linux epoll 机制 来监听消息事件。

七、nativePollOnce 方法调用流程

Java 层调用
// MessageQueue.java
private native void nativePollOnce(long ptr, int timeoutMillis);

JNI 本地方法，由 MessageQueue 调用，用于等待消息。

在 MessageQueue.next() 方法中：

// MessageQueue.java
nativePollOnce(mPtr, nextPollTimeoutMillis);

它的作用是：

  • 如果 MessageQueue 里有消息，立即返回。
  • 如果没有消息，则阻塞，直到有新的消息到来或 timeoutMillis 超时。
JNI 层调用
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jlong ptr, jint timeoutMillis) {
    MessageQueue* mq = reinterpret_cast<MessageQueue*>(ptr);
    mq->pollOnce(timeoutMillis);
}

将 Java 传来的 mPtr 转换成 MessageQueue* 对象，并调用 pollOnce() 方法。

Native 层 pollOnce()

在 MessageQueue.cpp：

void MessageQueue::pollOnce(int timeoutMillis) {
    mLooper->pollOnce(timeoutMillis);
}

调用了 Looper::pollOnce()，进入 消息轮询 逻辑。

Looper 的 pollOnce()

在 Looper.cpp：

int Looper::pollOnce(int timeoutMillis) {
    return pollInner(timeoutMillis);
}

这里调用 pollInner(timeoutMillis)，它的核心逻辑是 使用 epoll_wait() 监听事件。

epoll 监听消息事件

pollInner(timeoutMillis) 的核心逻辑：

int Looper::pollInner(int timeoutMillis) {
    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);

    if (eventCount > 0) {
        for (int i = 0; i < eventCount; i++) {
            // 处理事件
        }
    }
}

其中：

  • mEpollFd 是 epoll 文件描述符，用于监听多个文件描述符（FD）。
  • epoll_wait() 会 阻塞当前线程，直到：
    • 有 新消息可读
    • 有 文件描述符事件触发
    • 超时（timeoutMillis 毫秒后自动返回）

到这里，我们清楚了 nativePollOnce 的主要作用是等待新消息到达消息队列。当调用这个方法时，如果当前消息队列中没有需要立即处理的消息，线程会被阻塞，从而释放 CPU 资源，直到有新消息到来或者发生其他唤醒条件。

那么 epoll_wait() 如何监听消息？
epoll_wait() 监听哪些事件？

MessageQueue 的 pipe（管道）：当 Handler 发送消息时，写入 pipe，触发 epoll 事件。

输入事件：当用户触摸屏幕或按键时，触发 epoll 事件。

文件描述符（FileDescriptor）：例如 Binder 进程间通信（IPC）事件。

等等…

消息如何触发 epoll？
  • Handler.sendMessage() 会向 MessageQueue 写入数据：
  write(mWakeEventFd, "W", 1);

  • epoll_wait() 监听到 pipe 有数据，返回。

  • Looper 处理新消息，Java 层 Handler 开始执行 handleMessage()。

epoll_wait阻塞等待wakeFd上的可读事件，当有数据写入wakeFd，epoll_wait返回，线程被唤醒，这里并不关心写入wakeFd的具体数据是什么，只关心可读事件的发生。

pipe 的作用

让 Handler.sendMessage() 触发 epoll 事件，立即唤醒 Looper。

至此，综上，我们可以知道 epoll_wait() 只负责等待事件，不会提前返回“第一条消息”，它只会返回“有事件触发”的信号，具体执行哪个消息是 MessageQueue.next() 的逻辑，它会选择最早应该执行的消息，这就是 Handler 的阻塞唤醒的核心逻辑所在！

八、Handler 处理消息

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        msg.callback.run();
    } else {
        handleMessage(msg);
    }
}

最终执行：

@Override
public void handleMessage(Message msg) {
    // 需要用户实现
}

九、核心组件之间的关系

Thread
  └── ThreadLocal<Looper>
        └── Looper
              └── MessageQueue
                    └── Message1 → Message2 → ...
                          ↑
                       Handler
  • Handler 持有对 MessageQueue 的引用（间接通过 Looper）因为Handler中的 MessageQueue 是从 Looper 中获取的；
    public Handler(@Nullable Callback callback, boolean async) {
        //..
        mQueue = mLooper.mQueue;
        //..
    }
  • 每个线程通过 ThreadLocal 绑定自己的 Looper；
  • Looper 管理其对应的 MessageQueue；

这样它们的关系就清晰了，每个线程只有一个Looper(是由ThreadLocal确保的)，可以有多个Handler。

public final class Looper {
    // 线程本地存储，每个线程一个Looper实例
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

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

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

关于ThreadLocal的详细介绍可以看这篇文章：深入剖析Java中ThreadLocal原理

十、内存泄漏问题分析及解决方案

我们都知道判断内存泄漏的依据是：短生命周期对象是否被长生命周期对象引用！既然使用Handler不当会导致内存泄漏，那么我们只需要找到被引用的源头，然后去解决。

Handler 导致内存泄漏的完整引用流程
  • 匿名内部类或非静态内部类的隐式引用：

众所周知，在Java中 匿名内部类或非静态内部类会持有外部类的引用，如下：

public class MainActivity extends AppCompatActivity {
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            // 处理消息
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mHandler.sendEmptyMessageDelayed(0, 10000);
    }
}

这里的mHandler是一个非静态内部类。非静态内部类会隐式持有外部类（这里是MainActivity）的引用。这意味着mHandler对象中包含了对MainActivity实例的引用。

  • MessageQueue 对 Message 的持有：

在上面示例中，我们发送了一个延迟的Message，尽管只传了一个0,但是其内部也会封装为Message，这时候Handler 会将 Message对象并将其发送到与之关联的MessageQueue中，MessageQueue会持有这个Message对象，直到该消息被处理。

  • Message 对 Handler 的持有：

由上面第四小节的sendMessage()可知，在放入队列的时候，会将Handler 与 Message 关联:

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this; // 绑定 Handler
    return queue.enqueueMessage(msg, uptimeMillis);
}

主要作用是，让Message知道是从哪个Handler发送的，并最终让那个Handler 的 handleMessage去处理。

public final class Looper {
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    @UnsupportedAppUsage
    private static Looper sMainLooper;  // guarded by Looper.class
    //...
}

我们都知道，在主线程中，主线程的Looper会一直运行下去（或者说 Looper被 静态 ThreadLocal<Looper> 所引用），不能被停止，而MessageQueue 又被Looper 所引用，这就产生了一条完整的引用链：ThreadLocal<Looper> - Looper - MessageQueue - Message - Handler - MainActivity

** 解决方案**
  • 使用静态内部类 + WeakReference：

要解决内存泄漏，就是把引用链上任意一条引用断开，让GC不可达就行了，其实我们能操作的就只有 Handler - **MainActivity **这一条引用：

static class MyHandler extends Handler {
    private final WeakReference<MyActivity> ref;
    MyHandler(MyActivity activity) {
        ref = new WeakReference<>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        MyActivity activity = ref.get();
        if (activity != null) {
            // Safe to use activity
        }
    }
}
  • 在 Activity 的 onDestroy() 中清除消息：
handler.removeCallbacksAndMessages(null);

其实，只要消息不是延迟很久或者反复堆积，就不会在 MessageQueue 中长时间滞留，从而也就不会延长 Handler 或其持有对象的生命周期。

想想，在实际开发中，谁会在Activity中延迟发送一个很长时间的消息，所以我们不必为 Handler 导致内存泄漏，过度紧张，稍微留意一下就可以避免了 😃

十一、最后

Handler 是 Android 消息机制的基础组成部分。通过对 Handler、Looper、MessageQueue 之间关系的理解，我们可以更深入掌握 Android 的线程模型与 UI 更新流程。

由于本人能力有限，并没有对 Handler 进行过度深入全面了解，比如同步屏障等，如果文章内容解读有误，还望不吝赐教。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2341169.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++ 什么是隐式类型转换，什么是显式类型转换

C++ 什么是隐式类型转换，什么是显式类型转换

在 C 中&#xff0c;​​类型转换​​是将一种数据类型的值转换为另一种数据类型的过程&#xff0c;分为 ​​隐式类型转换​​&#xff08;由编译器自动完成&#xff09;和 ​​显式类型转换​​&#xff08;由程序员手动指定&#xff09;。以下是它们的区别和示例&#xff1a…
阅读更多...
NVIDIA 自动驾驶技术见解

NVIDIA 自动驾驶技术见解

前言 参与 NVIDIA自动驾驶开发者实验室 活动&#xff0c;以及解读了 NVIDIA 安全报告 自动驾驶 白皮书&#xff0c;本文是我的一些思考和见解。自动驾驶技术的目标是为了改善道理安全、减少交通堵塞&#xff0c;重塑更安全、高效、包容的交通生态。在这一领域&#xff0c;NVI…
阅读更多...
【Flask】Explore-Flask：早期 Flask 生态的实用指南

【Flask】Explore-Flask：早期 Flask 生态的实用指南

开源项目&#xff1a;explore-flask/README.rst at master rpicard/explore-flask (github.com) 一、Coding conventions Summary Try to follow the coding style conventions laid out in PEP 8. Try to document your app with docstrings as defined in PEP 257. def…
阅读更多...
【论文阅读21】-PSOSVM-CNN-GRU-Attention-滑坡预测（2024-12）

【论文阅读21】-PSOSVM-CNN-GRU-Attention-滑坡预测（2024-12）

这篇论文主要提出并验证了一种新型的混合智能模型&#xff08;PSOSVM-CNN-GRU-Attention&#xff09;&#xff0c;用于准确预测滑坡的点位移&#xff0c;并构建可靠的位移预测区间。通过对Baishuihe滑坡和Shuping滑坡的案例分析&#xff0c;展示了该模型的出色性能。 [1] Zai D…
阅读更多...
蓝牙 6.0 发布，解锁无线科技新可能

蓝牙 6.0 发布，解锁无线科技新可能

在5G和Wi-Fi 7高速发展的时代&#xff0c;蓝牙技术始终以独特优势深度融入日常生活。从无线耳机到智能家居&#xff0c;它凭借低功耗、高兼容的特性&#xff0c;悄然连接各类智能设备&#xff0c;打造无缝的数字生活体验。无论是聆听音乐、智能门禁还是健康监测&#xff0c;蓝牙…
阅读更多...
EasyCVR视频智能分析平台助力智慧园区：全场景视频监控摄像头融合解决方案

EasyCVR视频智能分析平台助力智慧园区：全场景视频监控摄像头融合解决方案

一、方案背景 在智慧园区建设的浪潮下&#xff0c;设备融合、数据整合与智能联动已成为核心诉求。视频监控作为智慧园区的“视觉中枢”&#xff0c;其高效整合直接影响园区的管理效能与安全水平。然而&#xff0c;园区内繁杂的视频监控设备生态——不同品牌、型号、制式的摄像…
阅读更多...
为您的照片提供本地 AI 视觉：使用 Llama Vision 和 ChromaDB 构建 AI 图像标记器

为您的照片提供本地 AI 视觉：使用 Llama Vision 和 ChromaDB 构建 AI 图像标记器

有没有花 20 分钟浏览您的文件夹以找到心中的特定图像或屏幕截图&#xff1f;您并不孤单。 作为工作中的产品经理&#xff0c;我总是淹没在竞争对手产品的屏幕截图、UI 灵感以及白板会议或草图的照片的海洋中。在我的个人生活中&#xff0c;我总是捕捉我在生活中遇到的事物&am…
阅读更多...
K8S节点出现Evicted状态“被驱逐”

K8S节点出现Evicted状态“被驱逐”

在Kubernetes集群中&#xff0c;Pod状态为“被驱逐&#xff08;evicted&#xff09;”表示Pod无法在当前节点上继续运行&#xff0c;已被集群从节点上移除。 问题分析&#xff1a; 节点磁盘空间不足 &#xff0c;使用df -h查看磁盘使用情况 可以看到根目录 / 已100%满&#x…
阅读更多...
重学React（一）：描述UI

重学React（一）：描述UI

背景&#xff1a;React现在已经更新到19了&#xff0c;文档地址也做了全面的更新&#xff0c;上一次系统性的学习还是在16-17的大版本更新。所以&#xff0c;现在就开始重新学习吧&#xff5e; 学习内容&#xff1a; React官网教程&#xff1a;https://zh-hans.react.dev/lea…
阅读更多...
遨游通讯发布国产化旗舰三防手机AORO AU1：以自主可控重塑工业安全

遨游通讯发布国产化旗舰三防手机AORO AU1：以自主可控重塑工业安全

在全球产业链加速重构的背景下&#xff0c;国产化技术突破已成为工业领域高质量发展的核心驱动力。作为专精特新中小企业&#xff0c;遨游通讯始终以“让世界更安全、更高效、更简单”为使命&#xff0c;深耕“危、急、特”场景智能通信设备的研发。近日&#xff0c;遨游通讯正…
阅读更多...
【Python】Selenium切换网页的标签页的写法（全！！！）

【Python】Selenium切换网页的标签页的写法（全！！！）

在使用selenium做网站爬取测试的时候&#xff0c;我们经常会遇到一些需要点击的元素&#xff0c;才能点击到我们想要进入的页面&#xff0c; 于是我们就要模拟 不断地 点点点击 鼠标的样子。 这个时候网页上就会有很多的标签页&#xff0c;你的浏览器网页标签栏 be like: 那…
阅读更多...
DeepSeek和Excel结合生成动态图表

DeepSeek和Excel结合生成动态图表

文章目录 一、前言二、3D柱状图案例2.1、pyecharts可视化官网2.2、Bar3d-Bar3d_puch_card2.3、Deepseek2.4、WPS2.5、动态调整数据 一、前言 最近在找一些比较炫酷的动态图表&#xff0c;用于日常汇报&#xff0c;于是找到了 DeepseekExcel王牌组合&#xff0c;其等同于动态图…
阅读更多...
Ubuntu20.04 部署llama-factory问题集

Ubuntu20.04 部署llama-factory问题集

llama3 微调教程之 llama factory 的 安装部署与模型微调过程&#xff0c;模型量化和gguf转换。_llamafactory 部署-CSDN博客 1.跟着教程 llama-factory下载不下来 来&#xff0c;试着换源&#xff0c;多试几次&#xff0c;就可以成功了。。。 2.跟着教程&#xff0c;发现无法…
阅读更多...
大语言模型助力 Support Case 分析，提升云服务效率

大语言模型助力 Support Case 分析，提升云服务效率

1. 背景 技术工单&#xff08;Support Case&#xff09;是企业在进行云平台操作的时候通常会用到的一种技术支持类型&#xff0c;提供的技术支持通常包括所有的云服务的使用问题、账单问题、限制额度提升等等。对于云平台的管理者而言&#xff0c;对各个 BU 所提的工单进行统计…
阅读更多...
ubuntu磁盘挂载

ubuntu磁盘挂载

1、‌查看磁盘设备及分区‌ 命令‌&#xff1a;列出所有块设备&#xff08;磁盘及分区&#xff09; lsblk 0表示此块未挂载 2、格式化分区 sudo mkfs.ext4 /dev/sdb 注意sdb换成自己的块名称 3、创建挂载点目录‌ sudo mkdir -p /mnt/data4、永久挂载 sudo blkid /dev…
阅读更多...
chili3d调试笔记8 打印零件属性 浏览器元素展开

chili3d调试笔记8 打印零件属性 浏览器元素展开

无效&#xff0c; 返回的是节点不是坐标啥的&#xff0c; 找他的属性 把document和selectednote&#xff08;空集&#xff09;传给handleshowproperty方法 怎么获得selectnotes和selectnotes的property值 有selectnotes运行这段就行了 明天再搞 ----------------------------…
阅读更多...
新书速览|DeepSeek移动端AI应用开发：基于Android与iOS

新书速览|DeepSeek移动端AI应用开发：基于Android与iOS

《DeepSeek移动端AI应用开发&#xff1a;基于Android与iOS》 1 本书内容 《DeepSeek移动端AI应用开发:基于Android与iOS》深入剖析了DeepSeek平台的架构原理、API调用及开发实践等核心内容&#xff0c;助力读者在Android与iOS移动端高效集成DeepSeek API&#xff0c;打造出契…
阅读更多...
Android调用springboot接口上传大字段，偶现接口超时的优化

Android调用springboot接口上传大字段，偶现接口超时的优化

介绍 最近有个功能&#xff0c;Android通过okhttp上传实体类&#xff0c;实体类包含一个大字段&#xff0c;上传的字符串长度达到300k&#xff0c;偶现接口超时的情况&#xff0c;大概100次有5次&#xff0c;看日志发现数据并没有到达接口&#xff0c;可能在网络传输中就超时了…
阅读更多...
react组件之间如何使用接收到的className（封装一个按钮案例）

react组件之间如何使用接收到的className（封装一个按钮案例）

带有hover渐变效果 一、父组件 import LineGradientBox from ../line-gradient-box; import styles from ./index.module.scss;<LineGradientBoxfontSize{20}className{styles.btn_height}textSign upwidth"100%"onClick{() > {navigate(/sign-up);}} /> …
阅读更多...
JavaScript 数组常用方法解析

JavaScript 数组常用方法解析

1. concat - 合并数组 语法&#xff1a; const newArray oldArray.concat(value1, value2, ..., arrayN); 作用&#xff1a; 将当前数组与其他数组或值合并&#xff0c;返回一个新数组&#xff0c;原数组不变。 测试案例&#xff1a; const arr1 [1, 2, 3]; const arr2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023