Android Handler实现进度条动态更新技术讲解

最新推荐文章于 2024-09-30 11:36:04 发布

codingdie

最新推荐文章于 2024-09-30 11:36:04 发布

阅读量1.5k

点赞数 29

本文链接：https://blog.csdn.net/weixin_33557333/article/details/141789960

版权

本文还有配套的精品资源，点击获取

简介：在Android开发中，为了不阻塞UI线程，耗时操作需要在后台线程处理。本篇文章详细介绍了如何使用Handler、Looper和Message机制跨线程更新UI，特别关注进度条的动态更新。文章首先解释了Handler、Looper和Message的基本概念，然后通过实例演示了如何创建Handler实例、定义后台任务，以及如何在后台线程中发送进度信息到主线程进行UI更新。文章最后强调了移除Handler回调的重要性，并总结了这种机制对于提升用户体验的关键作用。 Android Handler模拟进度条更新

1. Android UI线程和后台线程的作用

Android 应用程序架构简介

在 Android 开发中，UI 线程是应用程序中负责处理用户界面交互的主要线程。它负责创建视图、响应用户操作（如点击和触摸事件）以及更新 UI 组件。然而，UI 线程并不是执行耗时操作的好地方，因为这会阻塞主线程，导致应用无响应（ANR）的情况发生。

后台线程的角色

为了避免在 UI 线程中执行耗时任务，我们需要使用后台线程。后台线程处理那些非交互式的、可能需要较长时间运行的任务，例如网络请求、大量数据处理等。当后台线程执行完毕后，它需要通过一定的机制将结果传递回 UI 线程进行显示或进一步的用户交互。

UI线程与后台线程的协作

为了实现 UI 线程和后台线程的协作，Android 提供了 Handler、Looper 和 Message 等机制，这些机制允许后台线程在不直接操作 UI 元素的情况下，安全地更新 UI。在接下来的章节中，我们将详细探讨这些机制的工作原理和使用方法，帮助开发者更有效地管理线程间的通信和 UI 更新。

2. Handler、Looper、Message基本概念介绍

2.1 Handler的原理与作用

2.1.1 Handler的核心机制解析

Handler在Android中用于实现不同线程之间的通信，它依赖于一个消息队列（MessageQueue）和一个线程循环器（Looper）来处理线程间的消息传递。核心机制基于这样一种设计：主线程（UI线程）创建一个Looper对象，该对象会启动一个无限循环，不断地从消息队列中读取消息，并根据消息类型分发给相应的Handler进行处理。

Handler对象能够将其自身与创建它的线程绑定，即Handler发送的消息会回到创建它的线程中。消息是通过Message对象来封装的，这些Message对象包含了要传递的数据以及目标Handler的引用。当Handler收到消息时，它会调用处理消息的回调方法 handleMessage(Message msg) 来完成实际的业务逻辑。

代码示例：

public class MyHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        // 在这里处理消息
    }
}

// 在主线程中发送消息
MyHandler handler = new MyHandler();
Message message = Message.obtain();
message.what = SOME_MESSAGE_ID;
handler.sendMessage(message);

逻辑分析：在主线程中创建的 MyHandler 实例将自动关联当前线程的Looper。调用 sendMessage 方法时，它实际上会把消息交给Looper的MessageQueue进行排队。当Looper轮到这个Message时，就会调用 MyHandler 的 handleMessage 方法。这里的 SOME_MESSAGE_ID 是一个自定义的整型常量，用于标识消息类型。

2.1.2 Handler在消息传递中的角色

在Android开发中，Handler扮演着调度员的角色，它在不同的线程间传递信息。它接收来自其他线程的Message或者Runnable对象，并将其放入消息队列中。一旦轮到消息被处理，它就会在创建它的线程中被执行。这种机制允许开发者在后台线程中执行耗时操作，然后在操作完成时通知UI线程更新界面，而不会阻塞UI线程。

使用Handler进行线程间通信的典型场景是网络请求：网络请求在后台线程中进行，处理完网络响应后，通过Handler将结果发送回UI线程进行更新。这种方式确保了UI的流畅性。

代码示例：

// 在后台线程中，假设networkTask()是进行网络请求的方法
private class DownloadThread extends Thread {
    public void run() {
        String response = networkTask();
        Message message = Message.obtain();
        message.what = DOWNLOAD_COMPLETE;
        message.obj = response;
        handler.sendMessage(message);
    }
}

// 消息处理
private Handler handler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        switch(msg.what) {
            case DOWNLOAD_COMPLETE:
                // 更新UI或处理下载结果
                break;
            default:
                super.handleMessage(msg);
        }
    }
};

逻辑分析：上述代码展示了一个后台线程通过Handler传递消息到主线程的过程。首先定义了一个后台线程 DownloadThread ，在该线程中进行网络操作。当网络请求完成时，构造一个Message对象，并通过Handler发送到主线程。在主线程中，Handler接收到了这个Message，并根据 what 字段判断消息类型，执行相应的逻辑处理。

2.2 Looper的作用与工作机制

2.2.1 Looper的基本概念

Looper是Android中用于实现线程消息循环的一个类。在Android中，每个线程默认只有主线程（UI线程）拥有Looper对象，后台线程是不具备Looper的。但是，可以通过调用 Looper.prepare() 在任意线程上准备Looper，再通过 Looper.loop() 启动循环读取和处理消息队列中的消息。

一个线程只能有一个Looper实例，并且一个Looper可以有一个或多个Handler与之关联。当调用 Looper.loop() 之后，该线程会进入一个无限循环，持续地检查消息队列，并将消息分发给合适的Handler进行处理。

代码示例：

class MyThread extends Thread {
    private Handler handler;

    public MyThread() {
        Looper.prepare();
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                // 处理消息
            }
        };
        Looper.loop();
    }
}

逻辑分析：在上述示例中， MyThread 类创建了一个新的线程，并在该线程中准备了一个Looper。然后创建了一个匿名内部类形式的Handler实例，这个Handler与新创建的Looper绑定。调用 Looper.loop() 之后，该线程开始处理消息队列中的消息，直到该线程结束。

2.2.2 Looper如何实现消息循环

Looper的工作方式可以看作是一个生产者和消费者模式。在这个模式中，Handler负责发送（生产）消息或Runnable对象到消息队列，而Looper则负责从消息队列中取出（消费）消息，并将消息分发到相应的Handler进行处理。

消息队列（MessageQueue）是一个先进先出的队列，用于存放Message或Runnable对象。当调用 Looper.loop() 方法时，它会不断从消息队列中取出消息，然后根据消息的Handler来分发消息。如果没有消息，它将阻塞等待消息到来。

核心流程如下： 1. Looper对象在创建时会初始化一个MessageQueue。 2. Looper调用 loop() 方法开始消息循环。 3. Looper从MessageQueue中取出消息。 4. Looper将消息分发给该消息对应的Handler。 5. Handler执行消息处理方法 handleMessage() 。 6. 回到步骤3，继续处理下一个消息，直到MessageQueue为空且没有新的消息进入。

代码示例：

// Looper处理消息的核心代码
for (;;) {
    Message msg = queue.next(); // might block
    if (msg == null) {
        // No message indicates that the message queue is quitting.
        return;
    }

    // This must be in a local variable, in case a UI event sets the logger
    Printer logging = me.mLogging;
    if (logging != null) {
        logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
    }

    msg.target.dispatchMessage(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();
    msg.recycleUnchecked();
    Binder.restoreCallingIdentity(newIdent);
}

逻辑分析：这段伪代码是Looper处理消息的简化版核心逻辑。它通过一个无限循环，不断从MessageQueue中取出消息。然后通过调用消息 target 的 dispatchMessage() 方法来分发消息。其中， msg.target 就是发送消息的Handler。完成消息处理后，还需要进行资源回收和身份验证的恢复工作。

2.3 Message对象的使用和意义

2.3.1 Message的结构和属性

在Android中，Message是用于在线程间传递数据的一种基本结构。它是一个轻量级的数据容器，可以包含任何类型的数据，但主要目的是传递整型的数据以及一个可选的对象。Message包含以下重要属性：

what: 一个整型字段，用于标识消息类型。
arg1 和 arg2: 两个整型字段，用于传递小量数据。
obj: 一个Object类型的字段，可以传递任意类型的数据。
replyTo: 一个Handler对象，用于消息回复。

每个Message对象可以放入一个消息队列中，然后由Looper循环地从中取出，并由Handler来处理。

代码示例：

Message msg = Message.obtain();
msg.what = MESSAGE_ID;
msg.obj = "Data payload";
handler.sendMessage(msg);

逻辑分析：创建了一个Message实例，并设置了 what 字段来标识消息类型，然后通过 obj 字段传递了字符串数据。最后，将Message实例发送给Handler处理。

2.3.2 如何构造和发送Message

构造和发送Message的步骤并不复杂，但需要注意正确地使用Message对象，以避免内存泄漏和线程安全问题。构造Message对象通常有两种方式：使用 Message.obtain() 方法获取一个复用的Message对象，或者直接创建一个Message实例。发送Message对象时，则是通过Handler的方法（如 sendMessage 或 post ）来实现。

发送消息的步骤： 1. 获取Message对象：可以通过 Message.obtain() 来获取或直接new一个Message实例。 2. 设置Message属性：根据需要，设置what、arg1、arg2以及obj等属性。 3. 发送Message：通过Handler的 sendMessage() 或 post() 方法发送Message。

代码示例：

// 构造和发送Message
Message msg = Message.obtain();
msg.what = 1;
msg.arg1 = 100;
msg.obj = "Hello World";
handler.sendMessage(msg);

逻辑分析：上述代码演示了如何构造一个Message对象并设置其属性，然后通过Handler发送这个Message。在实际开发中，我们推荐使用 Message.obtain() 获取Message对象以支持对象的复用，这有助于减少资源的消耗和避免内存泄漏。

以上内容为第二章关于Handler、Looper、Message基本概念的介绍，深入分析了它们之间的联系以及如何在Android开发中运用这些核心组件来处理线程间的消息传递。接下来的章节将会进一步扩展这些概念，并介绍如何在实际应用中利用它们来更新UI、处理耗时任务以及避免内存泄漏等问题。

3. Handler实现耗时任务中进度条更新的步骤

3.1 创建Handler和Looper的正确方式

在Android开发中，正确地创建和使用Handler、Looper对于实现在耗时任务中更新进度条至关重要。Handler、Looper和Message是Android消息传递机制的核心组件，它们之间的协作可以实现线程间的通信。

3.1.1 在Activity中初始化Handler和Looper

在主线程（UI线程）中使用Handler，通常不需要显式创建一个Looper，因为在Android应用启动时，主线程已经有一个默认的Looper运行着。不过，我们仍然需要创建一个Handler来处理消息队列中的消息。

public class MyActivity extends AppCompatActivity {
    private MyHandler handler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);

        handler = new MyHandler(getMainLooper());
    }

    class MyHandler extends Handler {
        public MyHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            // 处理UI更新
        }
    }
}

上面代码创建了一个Handler实例，并将其与主线程的Looper关联起来。 handleMessage 方法是在主线程中被调用来处理UI更新的。

3.1.2 使用HandlerThread创建后台线程的Looper

对于在后台线程中执行耗时任务，推荐使用HandlerThread。HandlerThread自带Looper，可以在后台线程中处理消息。

public class MyActivity extends AppCompatActivity {
    private HandlerThread handlerThread;
    private Handler handler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);

        handlerThread = new HandlerThread("MyBackgroundThread");
        handlerThread.start();
        handler = new MyBackgroundHandler(handlerThread.getLooper());
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        handlerThread.quit();
    }

    class MyBackgroundHandler extends Handler {
        public MyBackgroundHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            // 处理后台线程的任务
        }
    }
}

这段代码展示了如何使用HandlerThread创建一个新的线程，并在该线程中使用Handler进行消息处理。

3.2 利用Handler发送更新UI的消息

3.2.1 如何在Handler中处理消息

在前面创建的Handler中，我们已经定义了一个 handleMessage 方法，这是处理消息的主要方法。当Handler接收到消息时，该方法会被调用。

@Override
public void handleMessage(Message msg) {
    switch (msg.what) {
        case MESSAGE_UPDATE_PROGRESS:
            // 更新进度条的代码
            break;
        // 其他消息处理
    }
}

通过 msg.what 我们可以判断消息的类型，并进行相应的UI操作。

3.2.2 消息发送的时机与进度条更新逻辑

在耗时任务中，我们需要在适当的时候发送消息给Handler，来更新进度条。这通常是在任务的某个阶段完成时执行的。

public void updateProgress(int progress) {
    Message msg = Message.obtain();
    msg.what = MESSAGE_UPDATE_PROGRESS;
    msg.arg1 = progress;
    handler.sendMessage(msg);
}

此代码段展示了如何构造消息，并通过Handler发送它来更新UI。

3.3 实际案例：使用Handler更新进度条

3.3.1 案例背景和需求分析

假设我们有一个任务需要下载网络图片，并在下载过程中显示一个进度条。我们需要使用Handler来在后台线程中更新进度条。

3.3.2 实现步骤和代码解读

实现步骤包括创建下载任务、处理下载进度更新、以及通过Handler发送消息更新UI。

// 假设的下载图片方法，会调用updateProgress来更新进度
private void downloadImage(String imageUrl) {
    // 省略实际下载代码...
    updateProgress(currentProgress);
}

// 这个方法会在下载任务的适当阶段被调用，更新进度条
public void updateProgress(int progress) {
    if (handler != null) {
        Message msg = Message.obtain();
        msg.what = MESSAGE_UPDATE_PROGRESS;
        msg.arg1 = progress;
        handler.sendMessage(msg);
    }
}

通过这种方式，我们在后台线程中处理下载任务，并通过Handler在主线程中安全地更新UI。这样的设计遵循了Android开发的最佳实践，即不要在非UI线程中直接操作UI组件。

以上是本章节的内容概览，接下来的章节将继续深入探讨如何安全地在后台线程中更新UI，以及防止因Activity或Fragment销毁导致的UI异常处理。

4. 如何在后台线程中正确更新UI

4.1 理解Android UI更新的线程限制

Android的UI系统并不是线程安全的，这意味着所有的UI操作必须在主线程（UI线程）中执行。如果尝试从后台线程直接访问和修改UI元素，将会抛出 CalledFromWrongThreadException 异常，或者产生不可预见的行为。理解这一点对于开发Android应用至关重要。

4.1.1 UI线程与其他线程的区别

UI线程是Android应用启动时创建的一个线程，负责运行主循环（main loop），在这个循环中处理输入事件（如点击和按键事件）并更新UI组件。所有的UI更新，如更改文本、颜色、布局等，都应该在这个线程中执行。

其他线程，通常是通过 new Thread() 或 ExecutorService 创建的线程，它们用于处理耗时的操作，如网络请求、文件操作或复杂计算等。这些操作不应该在主线程中执行，因为它们可能会阻塞主线程，导致应用无响应（ANR，Application Not Responding）。

4.1.2 线程安全与UI线程的交互原则

为了保证UI的线程安全，Android提供了几种机制，其中一种就是 Handler 。 Handler 允许你发送消息或者运行时调用代码，这些消息或代码将会被排入主线程的消息队列中，从而保证线程安全。使用 Handler 的 post() 方法或 sendMessage() 方法可以将任务安排在主线程执行，这些方法背后的机制是将任务封装为 Message 或 Runnable 对象，然后加入到消息队列中。

4.2 使用Handler在后台线程中安全更新UI

4.2.1 Handler在后台线程中的应用场景

在Android开发中，后台线程通常用于处理耗时操作，如图像处理、文件读写等。在这些操作中，如果需要更新UI（比如进度条的更新），则必须通过 Handler 将更新UI的任务发送到主线程执行。

4.2.2 正确的Handler使用方法和技巧

在后台线程中正确使用 Handler 更新UI的关键在于确保 Handler 对象与主线程的 Looper 关联。创建 Handler 实例时，如果没有指定 Looper ， Handler 会默认使用与创建它的线程关联的 Looper 。因此，在后台线程中创建 Handler 时，需要确保其关联的 Looper 是主线程的 Looper 。这里展示如何实现：

class MyHandler extends Handler {
    private WeakReference<Activity> activityReference;

    MyHandler(Activity activity) {
        // 使用getMainLooper()获取主线程的Looper
        super(Looper.getMainLooper());
        activityReference = new WeakReference<>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        Activity activity = activityReference.get();
        if (activity != null && !activity.isFinishing()) {
            // 更新UI
        }
    }
}

在后台线程中，你可以使用这个 Handler 来发送消息或运行 Runnable ，以更新UI：

Handler mainHandler = new MyHandler(this); // this指的是Activity实例

// 在后台线程中，创建Runnable，由Handler负责执行在主线程中
Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        // 耗时操作...
        Message message = Message.obtain();
        // 携带数据
        message.what = 1;
        // 发送消息到主线程的Handler
        mainHandler.sendMessage(message);
    }
};

new Thread(myRunnable).start();

4.3 防止因Activity或Fragment销毁导致的UI异常

4.3.1 Activity或Fragment生命周期中的注意事项

在Activity或Fragment的生命周期中，可能会遇到用户按返回键退出、系统因内存不足而杀死应用或Activity被系统配置更改等情况。在这类情况下，如果后台线程仍然尝试更新UI，就会导致应用崩溃。

4.3.2 处理UI更新操作与生命周期的同步问题

为了避免这种情况的发生，我们需要在Activity或Fragment的生命周期中管理后台线程。具体来说，在 onStop() 、 onDestroy() 等生命周期方法中，应该通知后台线程停止执行，同时移除所有通过 Handler 安排到主线程执行的操作。

@Override
public void onDestroy() {
    super.onDestroy();
    // 确保Handler不再进行UI操作
    if (handler != null) {
        handler.removeCallbacksAndMessages(null);
    }
    // 停止后台线程
    // ...
}

另外，使用弱引用来持有Activity或Fragment的实例，可以避免内存泄漏问题。弱引用（WeakReference）是一种特殊的引用，在垃圾回收器线程扫描它所引用的对象时，一旦这个对象没有被其他强引用引用，这个对象就会被回收。这样即使后台线程持有Activity的引用，也不会阻止Activity的回收。

// 使用WeakReference防止内存泄漏
WeakReference<Activity> activityReference = new WeakReference<>(this);
Handler handler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        Activity activity = activityReference.get();
        if (activity != null && !activity.isFinishing()) {
            // 更新UI
        }
    }
};

通过以上方法，我们可以确保即使Activity或Fragment被销毁，后台线程也不会尝试更新已经不存在的UI，从而避免应用崩溃。

5. Activity或Fragment销毁时移除Handler回调的重要性

5.1 回调机制与内存泄漏的关系

5.1.1 回调在Handler中的作用和风险

在Android开发中，回调（Callback）是一种常见的设计模式，它允许对象在内部状态改变时通知其他对象。在 Handler 机制中，回调用于处理 Message 和 Runnable 对象。然而，如果回调对象持有对 Activity 或 Fragment 的强引用，并且在它们生命周期结束时未能及时移除，那么即使界面销毁，这些回调仍然能够保持界面对象不被垃圾回收，从而导致内存泄漏。

5.1.2 内存泄漏的定义与影响

内存泄漏是指由于程序设计上的缺陷，导致系统无法回收某些不再使用的内存片段。在Android中，内存泄漏会导致应用可用内存减少，从而引发性能问题，比如应用变慢，甚至抛出 OutOfMemoryError 导致应用崩溃。长期未解决的内存泄漏，最终会降低设备的整体性能，影响用户体验。

5.2 正确移除Handler回调的方法和时机

5.2.1 在Activity或Fragment生命周期中移除回调

为了避免内存泄漏，开发人员需要确保在 Activity 或 Fragment 的生命周期内适时移除 Handler 的回调。在 Activity 中，可以重写 onStop() 或 onDestroy() 方法，在 Fragment 中，则应该在 onDetach() 方法中移除回调。代码示例如下：

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

    @Override
    protected void onStop() {
        super.onStop();
        // 移除所有消息和回调
        myHandler.removeCallbacksAndMessages(null);
    }
    // 当Activity结束时，确保移除回调
    @Override
    protected void onDestroy() {
        super.onDestroy();
        myHandler.removeCallbacksAndMessages(null);
    }
}

public class MyFragment extends Fragment {
    private Handler myHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            // 处理消息
        }
    };

    @Override
    public void onDetach() {
        super.onDetach();
        myHandler.removeCallbacksAndMessages(null);
    }
}

5.2.2 使用弱引用避免内存泄漏

为了进一步防止内存泄漏，推荐使用 WeakReference 来持有 Activity 或 Fragment 的引用。当垃圾回收器运行时，如果只有弱引用指向对象，那么该对象就会被回收。这样可以确保即使回调没有被显式移除，也不会阻止 Activity 或 Fragment 被垃圾回收器回收。修改后的 Handler 示例如下：

public class MyActivity extends AppCompatActivity {
    private final WeakReference<MyActivity> weakActivity = new WeakReference<>(this);
    private Handler myHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            MyActivity activity = weakActivity.get();
            if (activity != null) {
                // 安全地使用Activity实例
            }
        }
    };
    // ... 其他生命周期方法
}

5.3 案例分析：移除回调防止应用崩溃

5.3.1 案例背景与问题定位

假设有一个 Activity ，在其中创建了一个 Handler 用于异步任务，并在任务执行完毕后通过回调更新UI。由于没有在 Activity 销毁时移除 Handler 的回调，导致了内存泄漏。用户在离开 Activity 后，通过系统任务管理器强制结束应用，应用崩溃。

5.3.2 实际操作步骤和效果验证

为了修复这个问题，开发者在 Activity 的 onStop() 和 onDestroy() 方法中添加了 myHandler.removeCallbacksAndMessages(null); 来移除回调。通过日志记录和性能分析工具，确认在 Activity 销毁时，与之关联的 Handler 回调已被正确移除，内存泄漏问题得到了解决。最终，应用的稳定性得到了提升，不再因为内存泄漏而崩溃。

本文还有配套的精品资源，点击获取