Kotlin协程任务并发

在现代Android开发中，Kotlin协程已成为处理并发任务的核心工具。本文将通过Jetpack组件的实践，展示如何有效管理多个并发任务。

基础并发实现

首先，我们创建一个Repository类来管理网络请求和数据库操作的并发执行：

@Singleton
class UserRepository @Inject constructor(
    private val apiService: ApiService,
    private val userDao: UserDao
) {

    suspend fun fetchUserData(userId: String): User {
        return withContext(Dispatchers.IO) {
            // 并发执行多个网络请求
            val userDeferred = async { apiService.getUser(userId) }
            val profileDeferred = async { apiService.getProfile(userId) }
            val preferencesDeferred = async { apiService.getPreferences(userId) }
            
            // 等待所有任务完成
            val user = userDeferred.await()
            val profile = profileDeferred.await()
            val preferences = preferencesDeferred.await()
            
            // 合并结果
            user.copy(
                profile = profile,
                preferences = preferences
            )
        }
    }
}

在ViewModel中的使用

class UserViewModel(private val repository: UserRepository) : ViewModel() {

    private val _userState = MutableLiveData<UserState>()
    val userState: LiveData<UserState> = _userState

    fun loadUser(userId: String) {
        viewModelScope.launch {
            try {
                _userState.value = UserState.Loading
                val user = repository.fetchUserData(userId)
                _userState.value = UserState.Success(user)
            } catch (e: Exception) {
                _userState.value = UserState.Error(e.message)
            }
        }
    }
}

高级并发模式

对于更复杂的场景，可以使用supervisorScope来处理任务失败：

suspend fun fetchUserWithRetry(userId: String): User {
    return supervisorScope {
        val userDeferred = async { apiService.getUser(userId) }
        val profileDeferred = async { apiService.getProfile(userId) }
        
        try {
            // 等待所有任务完成
            val user = userDeferred.await()
            val profile = profileDeferred.await()
            user.copy(profile = profile)
        } catch (e: Exception) {
            // 单个任务失败不影响其他任务
            throw e
        }
    }
}

在Fragment中的实际应用

class UserFragment : Fragment() {

    private lateinit var viewModel: UserViewModel

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        viewModel = ViewModelProvider(this)[UserViewModel::class.java]
        
        viewModel.userState.observe(viewLifecycleOwner) { state ->
            when (state) {
                is UserState.Loading -> showLoading()
                is UserState.Success -> updateUserUI(state.user)
                is UserState.Error -> showError(state.message)
            }
        }
        
        viewModel.loadUser("user_123")
    }
}

通过以上实践，我们实现了基于Jetpack组件的现代化并发处理方案。关键在于合理使用async、await和viewModelScope，确保任务并发执行的同时保持良好的错误处理机制。