Android子线程

Android中的子线程是指在主线程以外的线程中执行的代码。在Android开发中，主线程（也称为UI线程）负责处理用户交互和界面更新，而子线程则用于执行耗时操作，以避免阻塞主线程导致应用无响应。

使用子线程可以执行一些耗时的操作，例如网络请求、文件读写、复杂计算等。通过将这些操作放在子线程中执行，可以确保主线程保持流畅并及时响应用户的操作。

在Android中，有多种方式可以创建和管理子线程。常见的方法包括：
1. 使用Thread类：通过创建Thread对象并重写其run()方法来实现子线程逻辑。
2. 使用HandlerThread类：HandlerThread是Thread的子类，它内部包含了一个Looper和一个Handler，可以方便地在子线程上运行消息循环和处理消息。
3. 使用AsyncTask类：AsyncTask是一个简单且方便的工具类，封装了创建线程、执行后台任务和更新UI等操作。

无论使用哪种方式，需要注意的是，在子线程中不能直接更新UI，因为UI操作必须在主线程中执行。如果需要在子线程中更新UI，可以使用Handler或者runOnUiThread()方法来进行线程间通信。

相关问题

Android子线程kotlin

### 使用 Kotlin 协程在 Android 中创建和管理子线程

#### 利用 Dispatchers 进行线程调度

在 Android 开发中，为了确保应用程序响应迅速并提供良好的用户体验，在后台执行耗时任务是非常重要的。Kotlin 的协程库提供了 `Dispatchers` 来指定代码应该运行在哪种类型的线程池里。

对于需要异步处理的任务可以使用 `Dispatchers.IO` 或者 `Dispatchers.Default`，而当要更新 UI 组件时则需切换到 `Dispatchers.Main` 上下文中[^2]：

import kotlinx.coroutines.*

fun performBackgroundTask() {
    CoroutineScope(Dispatchers.Main).launch { // 启动一个新的协程，并设置其上下文为主UI线程
        val result = withContext(Dispatchers.IO) { // 将会在此处改变当前协程的工作线程为IO线程
            fetchDataFromNetwork()
        }
        updateUi(result) // 更新界面的操作应当回到主线程完成
    }
}

这段代码展示了如何启动一个新协程来进行网络请求这样的 I/O 密集型工作，并最终返回至主线程以安全地修改视图状态。

#### 创建自定义作用域来更好地管理和取消作业

除了简单地调用 `launch()` 方法外，还可以通过构建自己的 `CoroutineScope` 实例实现更精细的作用范围控制以及资源清理逻辑。这有助于防止内存泄漏等问题的发生[^3]:

class MyViewModel : ViewModel(), CoroutineScope {

    private var job: Job = Job()

    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job
    
    fun loadData(){
        launch{
            try {
                val data = withContext(Dispatchers.IO){
                    loadRealData()
                }
                showData(data)
            } catch (e: Exception){
                handleError(e)
            }
        }
    }

    override fun onCleared() {
        super.onCleared()
        job.cancel()// 当ViewModel被销毁的时候取消所有的挂起函数
    }
}

在这个例子中，`MyViewModel` 类实现了 `CoroutineScope` 接口并将自身的生命周期与协程关联起来；一旦该组件不再有效，则自动终止所有正在进行中的后台任务。

Android 子线程 如果加锁

在Android中，当我们在子线程（如AsyncTask、HandlerThread或者其他自定义线程）执行耗时操作时，为了避免修改UI线程的可见状态（比如更新UI组件），我们通常会在子线程中加锁，最常见的是使用synchronized关键字或者通过Handler/Looper来实现同步。以下是两种常见的做法：

1. **synchronized块或方法**：
- 使用`synchronized(this)`包裹需要同步的代码段，这样每次只有一个线程能够进入该同步代码块。

   public class MyTask extends AsyncTask<Void, Void, Bitmap> {
       private final Object lock = new Object();
       protected Bitmap doInBackground(Void... params) {
           synchronized(lock) {
               // 在这里执行耗时操作
           }
       }
   }

2. **Handler/Looper机制**：
- 创建一个Handler，并将其绑定到主线程的Looper，然后在子线程里发送消息，让主线程在消息队列中处理这些消息时更新UI。

   Handler mainHandler = new Handler(Looper.getMainLooper()) {
       @Override
       public void handleMessage(Message msg) {
           super.handleMessage(msg);
           // 在这里的代码将在主线程运行，因此可以直接更新UI
       }
   };
   
   new Thread(new Runnable() {
       @Override
       public void run() {
           Bitmap bitmap = ...; // 执行耗时操作
           mainHandler.sendMessage(Message.obtain(mainHandler, 0, bitmap));
       }
   }).start();

加锁的主要目的是为了保证线程安全，防止并发修改UI时引发的问题，如异常、数据不一致等。但是过度使用锁也可能导致性能下降，所以在实际应用中需要权衡利弊。