モバイル開発における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()
    }
}

// Coroutines：バックグラウンドタスクの構成
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 }