Android中线程等待的正确方法与避免UI阻塞

在Android开发过程中，线程管理是绕不开的核心知识点。很多开发者在需要实现线程等待逻辑时，容易误用错误的阻塞方式，导致主线程被卡住，引发应用无响应（ANR）的问题。本文会详细介绍Android中线程等待的正确实现方式，以及如何有效避免UI线程阻塞。

为什么不能直接在主线程做耗时等待

Android的UI渲染和操作响应都依赖主线程（也叫UI线程），如果主线程被阻塞超过5秒，系统就会弹出应用无响应的提示，严重影响用户体验。不少新手开发者会有这样的误区：在需要等待某个异步任务完成的时候，直接在UI线程调用Thread.sleep()或者Object.wait()做等待，这种方式是绝对不可取的。

举个错误的示例，假设我们要等待一个后台线程加载完成数据再更新UI，错误写法如下：

// 错误示例：在UI线程做耗时等待
new Thread(new Runnable() {
    @Override
    public void run() {
        // 模拟后台耗时操作
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 尝试回到UI线程更新，但之前的等待如果在UI线程就会出问题
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                // 更新UI逻辑
            }
        });
    }
}).start();

// 如果直接在UI线程调用下面的代码，就会阻塞UI
try {
    Thread.sleep(3000); // 这行代码如果在UI线程执行，会直接阻塞3秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

上面的代码中，如果Thread.sleep(3000)写在UI线程里，整个界面就会卡住3秒，用户无法进行任何操作，这在实际开发中是完全要避免的。

子线程等待的正确实现方式

如果是子线程内部需要等待某个条件满足再继续执行，我们可以使用Java标准库提供的等待/通知机制，或者更简便的CountDownLatch工具类，既不会阻塞UI线程，也能实现精准的等待逻辑。

方式一：使用CountDownLatch实现线程等待

CountDownLatch是java.util.concurrent包下的同步工具类，它通过一个计数器来实现等待逻辑：初始化时设置计数器数值，线程调用await()方法后会阻塞，直到其他线程调用countDown()把计数器减到0，等待的线程才会继续执行。

下面是一个子线程使用CountDownLatch等待另外两个后台任务完成的示例：

import java.util.concurrent.CountDownLatch;

public class ThreadWaitDemo {
    public static void main(String[] args) {
        // 创建计数器，初始值为2，代表需要等待2个任务完成
        CountDownLatch latch = new CountDownLatch(2);

        // 第一个后台任务
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务1开始执行");
                try {
                    Thread.sleep(2000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务1执行完成");
                latch.countDown(); // 计数器减1
            }
        }).start();

        // 第二个后台任务
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务2开始执行");
                try {
                    Thread.sleep(3000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务2执行完成");
                latch.countDown(); // 计数器减1
            }
        }).start();

        // 等待线程，等待上面的两个任务都完成
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("等待线程开始等待");
                    latch.await(); // 阻塞当前线程，直到计数器减到0
                    System.out.println("两个任务都已完成，等待线程继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

这种方式的好处是逻辑清晰，不需要手动处理复杂的同步锁，而且计数器的数值可以根据需要等待的任务数量灵活调整，非常适合需要等待多个异步任务完成的场景。

方式二：使用wait/notify机制实现线程等待

如果场景需要更灵活的等待条件控制，也可以使用Object类的wait()、notify()或者notifyAll()方法实现线程等待。不过要注意，调用这些方法的前提是必须持有对象的锁，也就是要在synchronized代码块或者synchronized方法中使用。

下面是一个使用wait/notify实现线程等待的示例：

public class WaitNotifyDemo {
    private static final Object lock = new Object();
    private static boolean isTaskDone = false;

    public static void main(String[] args) {
        // 任务线程，执行完任务后通知等待线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("后台任务开始执行");
                try {
                    Thread.sleep(2500); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock) {
                    isTaskDone = true;
                    lock.notify(); // 唤醒等待在lock对象上的线程
                    System.out.println("后台任务执行完成，已发送通知");
                }
            }
        }).start();

        // 等待线程，等待任务完成
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while (!isTaskDone) { // 用while循环判断条件，避免虚假唤醒
                        try {
                            System.out.println("等待线程开始等待");
                            lock.wait(); // 释放lock的锁，进入等待状态
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("收到任务完成的通知，等待线程继续执行");
                }
            }
        }).start();
    }
}

这里要特别注意，判断等待条件（比如示例中的isTaskDone）要使用while循环，而不是if语句，因为线程可能会在没有被通知的情况下被唤醒（也就是虚假唤醒），用while循环可以再次检查条件是否满足，避免逻辑错误。

Android中避免UI阻塞的最佳实践

在Android开发中，除了正确使用子线程等待方式，还需要遵循一些通用的实践来避免UI阻塞：

• 所有耗时操作（网络请求、数据库读写、大文件处理等）都必须放在子线程执行，绝对不能在UI线程做耗时操作。
• 子线程执行完任务后，如果需要更新UI，要通过Handler、runOnUiThread()、View.post()等正规方式切回UI线程，不要直接在子线程操作UI组件。
• 如果需要执行多个有依赖关系的异步任务，可以使用RxJava、Kotlin协程或者Android原生的WorkManager、AsyncTask（注意AsyncTask在Android 11已经废弃，不推荐新项目使用）来管理任务流程，避免手动处理复杂的线程等待逻辑。
• 不要在UI线程中调用任何可能阻塞的方法，比如Thread.sleep()、Object.wait()、Socket的阻塞读取等，这些操作都会直接导致UI卡顿。

常见误区总结

很多开发者容易混淆线程等待的使用场景，这里总结几个常见误区：

只要合理选择线程等待的方式，并且严格区分UI线程和子线程的职责，就能有效避免Android应用中的UI阻塞问题，提升应用的稳定性和用户体验。

Android线程等待UI线程阻塞CountDownLatchwait_notify异步任务优化修改时间：2026-05-24 13:56:54