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