Kotlin コルーチンをマスターするための包括的なガイド

導入

コルーチンは、非同期プログラミングをより読みやすく効率的にすることで簡素化します。スレッドは、それぞれがスペースとリソースを占有する高速道路上の個々の車と考えてください。対照的に、コルーチンは相乗りのようなもので、複数のタスクがリソースを効率的に共有します。
コルーチンを際立たせる 3 つの主な利点:

1. 非同期操作の処理の単純さと読みやすさ
2. 従来のスレッドと比較して効率的なリソース管理
3. 構造化された同時実行性によるコードの保守性の向上

---

コルーチンのセットアップ

Android プロジェクトでコルーチンを開始するには、次の依存関係を build.gradle ファイルに追加します。

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1"
}

---

コルーチンビルダーを理解する

コルーチン ビルダーは、コルーチンを作成および起動するための基盤です。実際の例を使用して、各タイプを詳しく見てみましょう:

起動

class WeatherService {
    fun updateWeather() {
        lifecycleScope.launch {
            // Simulating weather API call
            val weather = fetchWeatherData()
            updateUI(weather)
        }
    }

    private suspend fun fetchWeatherData(): Weather {
        delay(1000) // Simulate network delay
        return Weather(temperature = 25, condition = "Sunny")
    }
}

非同期

class StockPortfolio {
    suspend fun fetchPortfolioValue() {
        val stocksDeferred = async { fetchStockPrices() }
        val cryptoDeferred = async { fetchCryptoPrices() }

        // Wait for both results
        val totalValue = stocksDeferred.await() + cryptoDeferred.await()
        println("Portfolio value: $totalValue")
    }
}

---

コルーチンのスコープとコンテキスト

スコープとコンテキストを理解することは、コルーチンを適切に管理するために重要です。さまざまなスコープの種類を見てみましょう:

ライフサイクルスコープ

class NewsActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleScope.launch {
            val news = newsRepository.fetchLatestNews()
            newsAdapter.submitList(news)
        }
    }
}

ViewModelScope

class UserViewModel : ViewModel() {
    private val _userData = MutableLiveData<user>()

    fun loadUserData() {
        viewModelScope.launch {
            try {
                val user = userRepository.fetchUserDetails()
                _userData.value = user
            } catch (e: Exception) {
                // Handle error
            }
        }
    }
}
</user>

---

ディスパッチャーとの連携

ディスパッチャは、コルーチンがどのスレッドで実行されるかを決定します。さまざまなディスパッチャを効果的に使用する方法は次のとおりです:

class ImageProcessor {
    fun processImage(bitmap: Bitmap) {
        lifecycleScope.launch(Dispatchers.Default) {
            // CPU-intensive image processing
            val processed = applyFilters(bitmap)

            withContext(Dispatchers.Main) {
                // Update UI with processed image
                imageView.setImageBitmap(processed)
            }
        }
    }

    suspend fun downloadImage(url: String) {
        withContext(Dispatchers.IO) {
            // Network operation to download image
            val response = imageApi.fetchImage(url)
            saveToDatabase(response)
        }
    }

---

エラー処理と例外管理

コルーチンでは適切なエラー処理が不可欠です。これを効果的に実装する方法は次のとおりです:

class DataManager {
    private val exceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("Caught $exception")
    }

    fun fetchData() {
        lifecycleScope.launch(exceptionHandler) {
            try {
                val result = riskyOperation()
                processResult(result)
            } catch (e: NetworkException) {
                showError("Network error occurred")
            } catch (e: DatabaseException) {
                showError("Database error occurred")
            }
        }
    }
}

---

フローとステートフロー

Flow はデータ ストリームの処理に最適ですが、StateFlow は UI 状態の管理に最適です。

class SearchViewModel : ViewModel() {
    private val _searchResults = MutableStateFlow<list>>(emptyList())
    val searchResults: StateFlow<list>> = _searchResults.asStateFlow()

    fun search(query: String) {
        viewModelScope.launch {
            searchRepository.getSearchResults(query)
                .flowOn(Dispatchers.IO)
                .catch { e -> 
                    // Handle errors
                }
                .collect { results ->
                    _searchResults.value = results
                }
        }
    }
}
</list></list>

---

構造化された同時実行性

構造化された同時実行性は、関連するコルーチンを効果的に管理するのに役立ちます:

class OrderProcessor {
    suspend fun processOrder(orderId: String) = coroutineScope {
        val orderDeferred = async { fetchOrderDetails(orderId) }
        val inventoryDeferred = async { checkInventory(orderId) }
        val paymentDeferred = async { processPayment(orderId) }

        try {
            val order = orderDeferred.await()
            val inventory = inventoryDeferred.await()
            val payment = paymentDeferred.await()

            finalizeOrder(order, inventory, payment)
        } catch (e: Exception) {
            // If any operation fails, all others are automatically cancelled
            throw OrderProcessingException("Failed to process order", e)
        }
    }
}

---

結論

Kotlin コルーチンは、Android 開発で非同期操作を処理するための強力かつ直感的な方法を提供します。これらの中心となる概念とパターンを理解することで、より効率的で保守しやすく堅牢なアプリケーションを作成できます。特定の使用例に応じて、適切なスコープ、ディスパッチャ、およびエラー処理戦略を常に考慮することを忘れないでください。

コルーチンをマスターするための鍵は実践です。コルーチンをプロジェクトに実装し始め、さまざまなパターンを試し、理解が進むにつれて徐々により複雑な実装を構築してください。

原文はここに書かれています

以上がKotlin コルーチンをマスターするための包括的なガイドの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。