Kotlin Concurrency Expert

new-silvermoon/awesome-android-agent-skills/.github/skills/concurrency_and_networking/kotlin-concurrency-expert

作者 new-silvermoon82900eacc8dbe13de93c6310af27b9df4b2bd2f6無授權條款收錄於 2026年10月9日更新於 2026年10月9日

Kotlin Coroutines review and remediation for Android. Use when asked to review concurrency usage, fix coroutine-related bugs, improve thread safety, or resolve lifecycle issues in Kotlin/Android code.

僅含說明Software Development

AI 產生的概覽

審查並修正 Android 程式碼中的 Kotlin 協程並行問題，涵蓋作用域、生命週期安全與執行緒安全。

功能: 引導代理排查 Android 程式庫中的協程問題，例如 ANR、記憶體洩漏、競態條件與狀態錯誤，再套用最小且安全的修正。內容涵蓋調度器注入、生命週期感知的 Flow 收集、狀態封裝、取消處理、回呼轉 Flow 以及作用域選擇。也提供使用 runTest 與測試調度器的測試模式。產出是審查指引與修正後的程式碼變更，而非產生的檔案。
適用情境: 當被要求審查並行用法、修正協程相關缺陷、提升執行緒安全，或解決 Kotlin/Android 程式碼中的生命週期問題時使用。適合對現有協程程式碼進行程式碼審查與修正。
執行需求: 沒有指令碼或附帶資源，僅為說明性指示。被審查的專案需使用 Kotlin Coroutines for Android，並包含 kotlinx-coroutines-android 與 lifecycle-runtime-ktx；測試模式涉及 kotlinx-coroutines-test。

Kotlin Concurrency Expert

Overview

Review and fix Kotlin Coroutines issues in Android codebases by applying structured concurrency, lifecycle safety, proper scoping, and modern best practices with minimal behavior changes.

Workflow

1. Triage the Issue

Capture the exact error, crash, or symptom (ANR, memory leak, race condition, incorrect state).
Check project coroutines setup: kotlinx-coroutines-android version, lifecycle-runtime-ktx version.
Identify the current scope context (viewModelScope, lifecycleScope, custom scope, or none).
Confirm whether the code is UI-bound (Dispatchers.Main) or intended to run off the main thread (Dispatchers.IO, Dispatchers.Default).
Verify Dispatcher injection patterns for testability.

2. Apply the Smallest Safe Fix

Prefer edits that preserve existing behavior while satisfying structured concurrency and lifecycle safety.

Common fixes:

ANR / Main thread blocking: Move heavy work to withContext(Dispatchers.IO) or Dispatchers.Default; ensure suspend functions are main-safe.
Memory leaks / zombie coroutines: Replace GlobalScope with a lifecycle-bound scope (viewModelScope, lifecycleScope, or injected applicationScope).
Lifecycle collection issues: Replace deprecated launchWhenStarted with repeatOnLifecycle(Lifecycle.State.STARTED).
State exposure: Encapsulate MutableStateFlow / MutableSharedFlow; expose read-only StateFlow or Flow.
CancellationException swallowing: Ensure generic catch (e: Exception) blocks rethrow CancellationException.
Non-cooperative cancellation: Add ensureActive() or yield() in tight loops for cooperative cancellation.
Callback APIs: Convert listeners to callbackFlow with proper awaitClose cleanup.
Hardcoded Dispatchers: Inject CoroutineDispatcher via constructor for testability.

Critical Rules

Dispatcher Injection (Testability)

kotlin

// CORRECT: Inject dispatcherclass UserRepository(    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO) {    suspend fun fetchUser() = withContext(ioDispatcher) { ... }}
// INCORRECT: Hardcoded dispatcherclass UserRepository {    suspend fun fetchUser() = withContext(Dispatchers.IO) { ... }}

// CORRECT: Inject dispatcherclass UserRepository(    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO) {    suspend fun fetchUser() = withContext(ioDispatcher) { ... }}
// INCORRECT: Hardcoded dispatcherclass UserRepository {    suspend fun fetchUser() = withContext(Dispatchers.IO) { ... }}

Lifecycle-Aware Collection

kotlin

// CORRECT: Use repeatOnLifecycleviewLifecycleOwner.lifecycleScope.launch {    viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {        viewModel.uiState.collect { state -> updateUI(state) }    }}
// INCORRECT: Direct collection (unsafe, deprecated)lifecycleScope.launchWhenStarted {    viewModel.uiState.collect { state -> updateUI(state) }}

// CORRECT: Use repeatOnLifecycleviewLifecycleOwner.lifecycleScope.launch {    viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {        viewModel.uiState.collect { state -> updateUI(state) }    }}
// INCORRECT: Direct collection (unsafe, deprecated)lifecycleScope.launchWhenStarted {    viewModel.uiState.collect { state -> updateUI(state) }}

State Encapsulation

kotlin

// CORRECT: Expose read-only StateFlowclass MyViewModel : ViewModel() {    private val _uiState = MutableStateFlow(UiState())    val uiState: StateFlow<UiState> = _uiState.asStateFlow()}
// INCORRECT: Exposed mutable stateclass MyViewModel : ViewModel() {    val uiState = MutableStateFlow(UiState()) // Leaks mutability}

// CORRECT: Expose read-only StateFlowclass MyViewModel : ViewModel() {    private val _uiState = MutableStateFlow(UiState())    val uiState: StateFlow<UiState> = _uiState.asStateFlow()}
// INCORRECT: Exposed mutable stateclass MyViewModel : ViewModel() {    val uiState = MutableStateFlow(UiState()) // Leaks mutability}

Exception Handling

kotlin

// CORRECT: Rethrow CancellationExceptiontry {    doSuspendWork()} catch (e: CancellationException) {    throw e // Must rethrow!} catch (e: Exception) {    handleError(e)}
// INCORRECT: Swallows cancellationtry {    doSuspendWork()} catch (e: Exception) {    handleError(e) // CancellationException swallowed!}

// CORRECT: Rethrow CancellationExceptiontry {    doSuspendWork()} catch (e: CancellationException) {    throw e // Must rethrow!} catch (e: Exception) {    handleError(e)}
// INCORRECT: Swallows cancellationtry {    doSuspendWork()} catch (e: Exception) {    handleError(e) // CancellationException swallowed!}

Cooperative Cancellation

kotlin

// CORRECT: Check for cancellation in tight loopssuspend fun processLargeList(items: List<Item>) {    items.forEach { item ->        ensureActive() // Check cancellation        processItem(item)    }}
// INCORRECT: Non-cooperative (ignores cancellation)suspend fun processLargeList(items: List<Item>) {    items.forEach { item ->        processItem(item) // Never checks cancellation    }}

// CORRECT: Check for cancellation in tight loopssuspend fun processLargeList(items: List<Item>) {    items.forEach { item ->        ensureActive() // Check cancellation        processItem(item)    }}
// INCORRECT: Non-cooperative (ignores cancellation)suspend fun processLargeList(items: List<Item>) {    items.forEach { item ->        processItem(item) // Never checks cancellation    }}

Callback Conversion

kotlin

// CORRECT: callbackFlow with awaitClosefun locationUpdates(): Flow<Location> = callbackFlow {    val listener = LocationListener { location ->        trySend(location)    }    locationManager.requestLocationUpdates(listener)        awaitClose { locationManager.removeUpdates(listener) }}

// CORRECT: callbackFlow with awaitClosefun locationUpdates(): Flow<Location> = callbackFlow {    val listener = LocationListener { location ->        trySend(location)    }    locationManager.requestLocationUpdates(listener)        awaitClose { locationManager.removeUpdates(listener) }}

Scope Guidelines

Scope	Use When	Lifecycle
`viewModelScope`	ViewModel operations	Cleared with ViewModel
`lifecycleScope`	UI operations in Activity/Fragment	Destroyed with lifecycle owner
`repeatOnLifecycle`	Flow collection in UI	Started/Stopped with lifecycle state
`applicationScope` (injected)	App-wide background work	Application lifetime
`GlobalScope`	NEVER USE	Breaks structured concurrency

Testing Pattern

kotlin

@Testfun `loading data updates state`() = runTest {    val testDispatcher = StandardTestDispatcher(testScheduler)    val repository = FakeRepository()    val viewModel = MyViewModel(repository, testDispatcher)        viewModel.loadData()    advanceUntilIdle()        assertEquals(UiState.Success(data), viewModel.uiState.value)}

@Testfun `loading data updates state`() = runTest {    val testDispatcher = StandardTestDispatcher(testScheduler)    val repository = FakeRepository()    val viewModel = MyViewModel(repository, testDispatcher)        viewModel.loadData()    advanceUntilIdle()        assertEquals(UiState.Success(data), viewModel.uiState.value)}

Reference Material

來源與署名

來源：new-silvermoon/awesome-android-agent-skills位於.github/skills/concurrency_and_networking/kotlin-concurrency-expert提交82900ea

授權條款：無授權條款

內容歸原作者所有。SourceWeft 從公開儲存庫中收錄這些內容。

檢舉或申請下架

Kotlin Concurrency Expert

Kotlin Concurrency Expert

Overview

Workflow

1. Triage the Issue

2. Apply the Smallest Safe Fix

Critical Rules

Dispatcher Injection (Testability)

Lifecycle-Aware Collection

State Encapsulation

Exception Handling

Cooperative Cancellation

Callback Conversion

Scope Guidelines

Testing Pattern

Reference Material

來源與署名

更多來自 new-silvermoon/awesome-android-agent-skills 的技能

Android Testing

Compose Ui

Android Viewmodel

Navigation3

Android Accessibility

Android Data Layer

更多Software Development技能

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices