第12天：后台任务

最新推荐文章于 2025-04-10 14:42:18 发布

陟彼高冈yu

最新推荐文章于 2025-04-10 14:42:18 发布

阅读量762

点赞数 23

分类专栏： Android开发14天从入门到精通文章标签： kotlin android android studio

本文链接：https://blog.youkuaiyun.com/weixin_41644568/article/details/143664937

版权

Android开发14天从入门到精通专栏收录该内容

37 篇文章

订阅专栏

欢迎来到第12天的Android编程教程！
今天，我们将深入探讨如何在Android应用中处理后台任务。后台任务对于执行耗时操作（如网络请求、文件操作、数据库访问等）而不阻塞主线程（UI线程）至关重要。本节将详细介绍后台任务的重要性、传统方法以及Kotlin协程，并通过一个实践实例帮助你更好地理解和应用这些知识。

##本节对应的代码链接为:

链接: BackgroundTaskDemo

1. 后台任务的重要性

1.1 什么是后台任务？

在Android应用中，后台任务指的是那些不需要立即与用户交互的任务。这些任务通常涉及耗时操作，如：

网络请求：获取或发送数据到服务器。
文件操作：读写文件、下载或上传文件。
数据库访问：查询、插入、更新或删除数据库中的数据。
复杂计算：执行大量计算或数据处理。

1.2 主线程与后台线程

Android应用运行在多个线程中，其中最重要的是主线程（也称为UI线程）和后台线程。

主线程（UI线程）：
- 负责处理用户界面（UI）的绘制和用户交互事件（如按钮点击、触摸事件）。
- 任何在主线程中执行的代码都会直接影响用户界面的响应速度和流畅度。
后台线程：
- 负责处理耗时操作，不直接与用户交互。
- 通过将耗时任务放在后台线程中执行，可以避免阻塞主线程，确保应用界面保持流畅。

1.3 为什么后台任务至关重要？

避免应用卡顿：如果在主线程中执行耗时操作，应用界面会变得卡顿，用户体验极差。
防止ANR错误：Android系统监测应用的响应性，如果主线程长时间（通常超过5秒）没有响应，系统会弹出“应用无响应”（ANR）对话框，用户可能会选择强制关闭应用。
提升用户体验：通过合理使用后台任务，确保应用界面流畅、响应迅速，提供良好的用户体验。

1.4 典型应用场景

数据加载：在启动应用时从网络获取数据或从数据库加载数据。
图片处理：下载、上传或编辑图片。
音视频处理：播放、录制或编辑音视频内容。
定时任务：定期同步数据或执行某些后台操作。

2. 传统方法简介

在Kotlin协程普及之前，Android开发者常用以下几种方法来处理后台任务：

2.1 AsyncTask（已废弃）

AsyncTask 是Android早期提供的一种简化后台任务处理的工具。它通过在后台线程执行任务，并在主线程更新UI，简化了线程间的切换。

特点

简化线程操作：无需手动创建和管理线程。
内置回调方法：如onPreExecute()、doInBackground()、onPostExecute()，方便在不同阶段执行特定操作。

使用示例

private inner class DownloadTask : AsyncTask<String, Void, String>() {

    override fun onPreExecute() {
        super.onPreExecute()
        // 在任务开始前执行，如显示进度条
    }

    override fun doInBackground(vararg params: String?): String {
        val urlString = params[0]
        // 执行网络请求或耗时操作
        return downloadData(urlString!!)
    }

    override fun onPostExecute(result: String?) {
        super.onPostExecute(result)
        // 在任务完成后更新UI，如显示结果
        textView.text = result
    }

    private fun downloadData(urlString: String): String {
        // 实现网络下载逻辑
        return "下载的数据"
    }
}

缺点

内存泄漏风险：AsyncTask 持有对外部类（如Activity）的隐式引用，可能导致内存泄漏。
生命周期问题：如果Activity在任务执行期间销毁，任务仍然持有对Activity的引用，可能引发崩溃。
灵活性差：难以处理复杂的异步任务和错误处理。

弃用情况

由于上述缺点，Google在API Level 30（Android 11）中正式弃用AsyncTask，推荐开发者使用更现代的解决方案，如Kotlin协程、WorkManager等。

2.2 使用线程和Handler

在AsyncTask被弃用后，开发者常用线程和Handler来管理后台任务。这种方法虽然灵活，但需要手动管理线程生命周期和UI更新。

线程与Handler简介

Thread：用于执行后台任务。
Handler：用于在后台线程与主线程之间传递消息，实现UI更新。

使用示例

import android.os.Handler
import android.os.Looper
import kotlin.concurrent.thread

class MainActivity : AppCompatActivity() {

    private lateinit var handler: Handler
    private lateinit var textView: TextView
    private lateinit var button: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 设置布局
        setContentView(R.layout.activity_main)

        handler = Handler(Looper.getMainLooper())
        textView = findViewById(R.id.textView)
        button = findViewById(R.id.button)

        button.setOnClickListener {
            // 启动后台线程
            thread {
                val result = downloadData("https://api.github.com/")
                // 使用Handler更新UI
                handler.post {
                    textView.text = result
                }
            }
        }
    }

    private fun downloadData(urlString: String): String {
        // 实现网络下载逻辑
        return "下载的数据"
    }
}

优点

灵活性高：可以根据需求自定义线程和消息处理。
适用于复杂任务：适合需要多线程协作和复杂同步的场景。

缺点

代码复杂：需要手动管理线程和Handler，增加了代码的复杂性和维护难度。
易出错：如线程未正确关闭、Handler泄漏等问题，可能导致应用崩溃或性能问题。
不易扩展：对于更复杂的异步操作，如多任务协作和错误处理，代码难以维护和扩展。

2.3 对比传统方法与现代方法

可读性和简洁性：现代方法（如协程）提供更简洁、易读的代码，减少了回调和线程管理的复杂性。
生命周期管理：协程与生命周期组件（如ViewModel）紧密集成，自动管理任务的生命周期，减少内存泄漏风险。
错误处理：协程提供结构化的错误处理机制，更容易捕获和处理异常。
性能和资源管理：协程比传统线程更轻量，支持大量并发任务而不消耗过多资源。

综上所述，虽然传统方法在某些场景下仍然适用，但现代方法（如Kotlin协程）因其优越的可读性、可维护性和性能，已成为处理后台任务的主流选择。

3. Kotlin协程

随着Kotlin在Android开发中的广泛应用，Kotlin协程成为处理异步任务和后台操作的强大工具。协程使得异步代码更简洁、易读，并且更容易管理复杂的并发任务。

3.1 为什么选择协程？

简化异步代码：协程允许你编写看似同步的代码来处理异步任务，避免了回调地狱（Callback Hell）。
轻量级：协程比线程更轻量，可以同时运行数千个协程，而线程则难以承载如此多的并发。
结构化并发：协程支持结构化并发，确保所有启动的协程在适当的时间被取消，避免内存泄漏。
集成度高：与Android架构组件（如ViewModel、LiveData）无缝集成，提供更好的生命周期管理。
强大的错误处理：协程提供了内置的异常处理机制，使得捕获和处理异常更加便捷。

3.2 基本概念

3.2.1 CoroutineScope（协程作用域）

CoroutineScope 定义了协程的生命周期和上下文。在Android中，常用的协程作用域有：

GlobalScope：全局作用域，生命周期与整个应用程序相同。不推荐在大多数情况下使用，因为它不绑定任何生命周期，容易导致内存泄漏。
生命周期作用域（LifecycleScope）：与Android组件（如Activity、Fragment）的生命周期绑定，当组件销毁时，自动取消所有协程。
ViewModelScope：与ViewModel的生命周期绑定，适用于在ViewModel中启动协程。

3.2.2 Dispatcher（调度器）

Dispatcher 决定了协程在哪个线程或线程池中执行。常用的调度器有：

Dispatchers.Main：主线程，适用于更新UI。
Dispatchers.IO：I/O线程池，适用于网络请求、文件操作等I/O密集型任务。
Dispatchers.Default：CPU密集型任务，如复杂计算。
Dispatchers.Unconfined：不受限的调度器，协程会在调用它的线程上执行，适用于特殊情况。

3.2.3 挂起函数（suspend functions）

挂起函数是可以在协程中挂起执行的函数，而不会阻塞线程。使用suspend关键字声明，允许在协程内部使用挂起函数，如delay()、withContext()等。

3.2.4 启动协程

launch：启动一个新协程，返回Job对象，可用于管理协程（如取消）。
async：启动一个新协程，返回Deferred对象，可用于获取协程的结果。
runBlocking：在当前线程上运行一个新协程，通常用于测试和主函数。

3.2.5 结构化并发

结构化并发确保所有子协程在父协程完成时也被取消，避免内存泄漏和资源浪费。通过在作用域内启动协程，自动管理协程的生命周期。

3.3 协程的使用示例

以下是一个使用Kotlin协程进行网络请求的简单示例：

import kotlinx.coroutines.*

fun main() = runBlocking {
    // 启动一个协程
    launch {
        // 切换到IO线程执行网络请求
        val data = withContext(Dispatchers.IO) {
            fetchDataFromNetwork()
        }
        // 更新UI（假设在主线程）
        println("Received data: $data")
    }
}

suspend fun fetchDataFromNetwork(): String {
    delay(1000) // 模拟网络延迟
    return "网络数据"
}

解释

runBlocking：在主线程上启动一个阻塞协程，适用于示例和测试。
launch：在协程作用域内启动一个新协程。
withContext(Dispatchers.IO)：切换到I/O线程池执行网络请求，避免阻塞主线程。
suspend fun：fetchDataFromNetwork是一个挂起函数，模拟网络请求并返回数据。

3.4 协程与生命周期的结合

在Android开发中，协程需要与组件的生命周期相结合，以避免内存泄漏和资源浪费。常用的方法有：

LifecycleScope：适用于Activity和Fragment。
ViewModelScope：适用于ViewModel。

使用LifecycleScope的示例

import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 设置布局
        setContentView(R.layout.activity_main)

        // 使用LifecycleScope启动协程
        lifecycleScope.launch {
            val data = withContext(Dispatchers.IO) {
                fetchDataFromNetwork()
            }
            // 更新UI
            findViewById<TextView>(R.id.textView).text = data
        }
    }

    private suspend fun fetchDataFromNetwork(): String {
        delay(1000) // 模拟网络延迟
        return "网络数据"
    }
}

使用ViewModelScope的示例

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class MyViewModel : ViewModel() {

    fun fetchData() {
        viewModelScope.launch {
            val data = withContext(Dispatchers.IO) {
                fetchDataFromNetwork()
            }
            // 更新LiveData或其他数据
        }
    }

    private suspend fun fetchDataFromNetwork(): String {
        delay(1000) // 模拟网络延迟
        return "网络数据"
    }
}

3.5 协程的高级特性

异常处理：使用try-catch块或CoroutineExceptionHandler捕获和处理协程中的异常。
超时控制：使用withTimeout或withTimeoutOrNull控制协程的执行时间，避免无限等待。
并行执行：使用async和await并行执行多个任务，提高性能。
流（Flow）：处理和操作异步数据流，适用于实时数据和事件流。

4. 实践实例：在后台下载数据

通过本节的学习，我们已经了解了后台任务的重要性、传统方法以及Kotlin协程的基本概念。接下来，我们将通过一个实践实例，运用所学知识，构建一个简单的应用，实现点击按钮从网络API下载数据，并在界面上显示结果。

4.1 项目创建过程

步骤1：创建新项目

打开Android Studio，点击Start a new Android Studio project（启动一个新的Android Studio项目）。
选择模板：选择Empty Activity（空活动），点击Next。
配置项目：
- Name（名称）：BackgroundTaskDemo
- Package name（包名）：com.example.backgroundtaskdemo
- Save location（保存位置）：选择合适的位置
- Language（语言）：Kotlin
- Minimum SDK（最低SDK）：选择API 21或更高
点击Finish（完成），等待项目创建完成。

步骤2：添加必要的权限

在AndroidManifest.xml中添加网络权限，以允许应用访问互联网。

<!-- AndroidManifest.xml -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.backgroundtaskdemo">

    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:allowBackup="true"
        android:label="@string/app_name"
        android:icon="@mipmap/ic_launcher"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.BackgroundTaskDemo">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

步骤3：添加协程依赖

在build.gradle (Module: app)文件中添加Kotlin协程的依赖。

// build.gradle (Module: app)
plugins {
    id 'com.android.application'
    id 'kotlin-android'
}

android {
    compileSdk 33

    defaultConfig {
        applicationId "com.example.backgroundtaskdemo"
        minSdk 21
        targetSdk 33
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib:1.8.0"
    implementation 'androidx.core:core-ktx:1.9.0'
    implementation 'androidx.appcompat:appcompat:1.5.1'
    implementation 'com.google.android.material:material:1.7.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1'

    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.4'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.0'
}

然后点击Sync Now（立即同步）以同步项目。

4.2 实现代码

步骤1：设计UI界面

在activity_main.xml中设计一个简单的界面，包含一个按钮和一个TextView。

<!-- res/layout/activity_main.xml -->
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/layout_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btn_fetch"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="下载数据" />

    <TextView
        android:id="@+id/tv_result"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="结果显示在这里"
        android:paddingTop="16dp"
        android:textSize="16sp" />

</LinearLayout>

步骤2：编写MainActivity

在MainActivity.kt中编写代码，实现点击按钮后从网络获取数据并显示在TextView中。

// src/main/java/com/example/backgroundtaskdemo/MainActivity.kt
package com.example.backgroundtaskdemo

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import kotlinx.coroutines.*
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL

class MainActivity : AppCompatActivity() {

    private lateinit var btnFetch: Button
    private lateinit var tvResult: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 设置布局
        setContentView(R.layout.activity_main)

        // 初始化视图
        btnFetch = findViewById(R.id.btn_fetch)
        tvResult = findViewById(R.id.tv_result)

        // 设置按钮点击事件
        btnFetch.setOnClickListener {
            fetchData()
        }
    }

    private fun fetchData() {
        // 启动协程
        lifecycleScope.launch {
            tvResult.text = "正在下载数据..."
            try {
                // 在IO线程中执行网络请求
                val data = withContext(Dispatchers.IO) {
                    downloadData("https://api.github.com/")
                }
                // 更新UI
                tvResult.text = data
            } catch (e: Exception) {
                tvResult.text = "发生错误: ${e.message}"
            }
        }
    }

    // 挂起函数，用于执行网络请求
    private suspend fun downloadData(urlString: String): String {
        return withContext(Dispatchers.IO) {
            val url = URL(urlString)
            val connection = url.openConnection() as HttpURLConnection
            try {
                connection.requestMethod = "GET"
                connection.connectTimeout = 5000
                connection.readTimeout = 5000

                val responseCode = connection.responseCode
                if (responseCode != HttpURLConnection.HTTP_OK) {
                    throw Exception("HTTP错误代码: $responseCode")
                }

                val stream = connection.inputStream
                val reader = BufferedReader(InputStreamReader(stream))
                val response = StringBuilder()
                var line: String?

                while (reader.readLine().also { line = it } != null) {
                    response.append(line)
                }

                reader.close()
                response.toString()
            } finally {
                connection.disconnect()
            }
        }
    }
}

步骤3：运行和测试

运行应用：点击Android Studio中的运行按钮，选择一个模拟器或连接的真机设备。
测试功能：
- 启动应用后，点击“下载数据”按钮。
- TextView将显示“正在下载数据…”，表示开始下载。
- 下载完成后，TextView将显示从https://api.github.com/获取的JSON数据。
- 如果发生错误（如无网络连接），TextView将显示错误信息。