Android中Looper.prepare()和Looper.loop()的作用和用法

在 Android 开发中，Looper 是一个非常重要的类，它用于管理消息队列（Message Queue）并循环处理消息。Looper.prepare() 和 Looper.loop() 是 Looper 类中的两个核心方法，它们共同构成了 Android 线程的消息循环机制。本文将详细介绍这两个方法的作用、用法及其应用场景。

一、Looper.prepare() 的作用与用法

1. 基本概念

Looper.prepare() 是 Looper 类中的一个静态方法，用于初始化当前线程的消息队列。

在调用 Looper.prepare() 之前，线程必须没有已经存在的消息队列。

1. 方法签名

public static void prepare()该方法不会接受任何参数，也不会返回任何值。

1. 应用场景

主线程（UI 线程）：在主线程中，通常不需要显式调用 Looper.prepare()，因为 Android 框架会在应用启动时自动为主线程创建消息队列。

工作线程：在自定义的工作线程中，如果需要处理消息，则必须手动调用 Looper.prepare() 来初始化消息队列。

1. 代码示例

new Thread(new Runnable() {
    @Override
    public void run() {
        Looper.prepare(); // 初始化消息队列
        Handler handler = new Handler();
        handler.post(new Runnable() {
            @Override
            public void run() {
                Log.d("Thread", "Message received");
            }
        });
        Looper.loop(); // 开始循环处理消息
    }
}).start();

1. 注意事项

每个线程只能有一个消息队列，因此在同一个线程中多次调用 Looper.prepare() 会导致 IllegalStateException。

如果不调用 Looper.loop()，消息队列将不会被处理。

二、Looper.loop() 的作用与用法

1. 基本概念

Looper.loop() 是 Looper 类中的一个静态方法，用于启动消息循环，开始处理消息队列中的消息。

调用 Looper.loop() 后，线程会进入一个无限循环，不断从消息队列中取出消息并执行。

1. 方法签名

public static void loop()该方法不会接受任何参数，也不会返回任何值。

1. 应用场景

主线程（UI 线程）：在主线程中，Looper.loop() 由 Android 框架自动调用，开发者无需手动干预。

工作线程：在自定义的工作线程中，如果需要处理消息，则必须手动调用 Looper.loop() 来启动消息循环。

1. 代码示例

new Thread(new Runnable() {
    @Override
    public void run() {
        Looper.prepare(); // 初始化消息队列
        Handler handler = new Handler();
        handler.post(new Runnable() {
            @Override
            public void run() {
                Log.d("Thread", "Message received");
            }
        });
        Looper.loop(); // 开始循环处理消息
    }
}).start();

1. 注意事项

Looper.loop() 会进入一个无限循环，直到调用 Looper.quit() 或 Looper.quitSafely() 才会退出。

如果在消息循环中抛出异常，整个线程会崩溃，因此需要妥善处理异常。

三、Looper.prepare() 和 Looper.loop() 的配合使用

1. 基本流程

首先调用 Looper.prepare() 初始化消息队列。

创建 Handler 对象，用于发送和处理消息。

调用 Looper.loop() 启动消息循环，开始处理消息队列中的消息。

1. 代码示例

new Thread(new Runnable() {
    @Override
    public void run() {
        Looper.prepare(); // 初始化消息队列
        Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 1:
                        Log.d("Thread", "Message 1 received");
                        break;
                    case 2:
                        Log.d("Thread", "Message 2 received");
                        break;
                }
            }
        };
        handler.sendEmptyMessage(1);
        handler.sendEmptyMessage(2);
        Looper.loop(); // 开始循环处理消息
    }
}).start();

1. 注意事项

必须先调用 Looper.prepare() 再创建 Handler，否则会抛出 NullPointerException。

必须先调用 Looper.loop() 才能处理消息，否则消息队列中的消息不会被执行。

四、Looper.quit() 和 Looper.quitSafely()

1. Looper.quit()

Looper.quit() 是 Looper 类中的一个静态方法，用于终止消息循环。

调用 Looper.quit() 后，消息循环会立即退出，不再处理后续消息。

1. Looper.quitSafely()

Looper.quitSafely() 是 Looper 类中的另一个静态方法，用于安全地终止消息循环。

调用 Looper.quitSafely() 后，消息循环会继续处理消息队列中的所有消息，然后退出。

1. 代码示例

new Thread(new Runnable() {
    @Override
    public void run() {
        Looper.prepare(); // 初始化消息队列
        Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                Looper.quit(); // 终止消息循环
            }
        }, 2000); // 2秒后终止
        Looper.loop(); // 开始循环处理消息
    }
}).start();

1. 注意事项

Looper.quit() 和 Looper.quitSafely() 必须在同一个线程中调用，否则会抛出 IllegalStateException。

使用 Looper.quitSafely() 可以确保所有消息都被处理后再退出，避免遗漏重要任务。

五、实际应用案例

1. 后台线程处理任务

在某些情况下，需要在后台线程中处理耗时任务，并通过消息机制通知主线程更新 UI。

示例代码：

new Thread(new Runnable() {
    @Override
    public void run() {
        Looper.prepare(); // 初始化消息队列
        Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 1:
                        Log.d("Thread", "Task completed");
                        break;
                }
            }
        };
        handler.sendEmptyMessage(1);
        Looper.loop(); // 开始循环处理消息
    }
}).start();

1. 定时任务处理

使用 Handler 和 Looper 实现定时任务，每隔一段时间执行一次任务。

示例代码：

new Thread(new Runnable() {
    @Override
    public void run() {
        Looper.prepare(); // 初始化消息队列
        Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                Log.d("Thread", "Task executed");
                this.sendEmptyMessageDelayed(0, 1000); // 每隔1秒执行一次
            }
        };
        handler.sendEmptyMessage(0);
        Looper.loop(); // 开始循环处理消息
    }
}).start();

Looper.prepare() 和 Looper.loop() 是 Android 中实现线程间通信的重要工具。Looper.prepare() 用于初始化消息队列，而 Looper.loop() 则用于启动消息循环并处理消息队列中的消息。这两个方法在主线程和工作线程中都有广泛的应用，特别是在需要处理耗时任务或定时任务时尤为重要。

声明：所有来源为“聚合数据”的内容信息，未经本网许可，不得转载！如对内容有异议或投诉，请与我们联系。邮箱：marketing@think-land.com