移动开发中的Background Thread：它是什么、任务及使用方法

import UIKit

class ImageDownloader {

    func downloadImagesSequentially() {
        let urls = ["https://example.com/1.png", "https://example.com/2.png"]

        // maxConcurrentOperationCount = 2的OperationQueue
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .utility

        for urlString in urls {
            queue.addOperation {
                guard let url = URL(string: urlString),
                      let data = try? Data(contentsOf: url)
                else { return }

                DispatchQueue.main.async {
                    print("已加载：\(url.lastPathComponent)")
                }
            }
        }
    }

    // GCD：具有不同QoS的全局后台队列
    func backgroundTaskWithQoS() {
        DispatchQueue.global(qos: .userInitiated).async {
            // 高优先级——用户等待结果
            let result = self.heavyComputation()
            DispatchQueue.main.async {
                self.showResult(result)
            }
        }
    }

    private func heavyComputation() -> String {
        Thread.sleep(forTimeInterval: 2) // 工作模拟
        return "计算结果"
    }

    private func showResult(_ result: String) {
        print("Result on Main: \(result)")
    }
}

// Android：Executors和Coroutines Dispatchers
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.util.concurrent.Executors

class DataRepository {

    private val ioExecutor = Executors.newFixedThreadPool(4)

    // 通过Executors的经典方法
    fun loadDataLegacy(callback: (String) -> Unit) {
        ioExecutor.execute {
            val result = readFromFile()
            val handler = android.os.Handler(android.os.Looper.getMainLooper())
            handler.post { callback(result) }
        }
    }

    // 通过Coroutines的现代方法
    suspend fun loadDataCoroutines(): String {
        return withContext(Dispatchers.IO) {
            // 文件操作——在后台池中执行
            readFromFile()
        }
        // 结果自动返回到Dispatchers.Main
    }

    // Dispatchers.Default上的CPU密集型任务
    suspend fun processImage(pixels: IntArray): IntArray {
        return withContext(Dispatchers.Default) {
            // 排序、过滤——在Default池上执行
            pixels.sortedArray()
        }
    }

    private fun readFromFile(): String {
        Thread.sleep(1000) // 从文件读取的模拟
        return "file_content"
    }

    fun cleanup() {
        ioExecutor.shutdown()
    }
}

// 协程：后台任务的组合
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay

suspend fun loadUserProfile(userId: String): UserProfile =
    coroutineScope {
        // 从不同来源并行加载数据
        val user = async(Dispatchers.IO) { fetchUser(userId) }
        val posts = async(Dispatchers.IO) { fetchPosts(userId) }
        val avatar = async(Dispatchers.Default) {
            processAvatar(fetchAvatar(userId))
        }

        // await()——挂起直到所有任务完成
        UserProfile(
            user = user.await(),
            posts = posts.await(),
            avatar = avatar.await()
        )
    }

data class UserProfile(
    val user: String,
    val posts: List<String>,
    val avatar: ByteArray
)

suspend fun fetchUser(id: String): String { delay(300); return "User:$id" }
suspend fun fetchPosts(id: String): List<String> { delay(500); return listOf("Post1") }
suspend fun fetchAvatar(id: String): ByteArray { delay(200); return ByteArray(1024) }
suspend fun processAvatar(data: ByteArray): ByteArray { delay(100); return data }