通过改装实现Thread安全

Question

我仍然有一点困难把所有关于使用协程启动网络请求的线程安全的信息放在一起。

假设我们有以下用例，有一个我们获得的用户列表，对于其中的每个用户，我将进行一些特定的检查，这些检查必须通过对API的网络请求来运行，并向我返回有关该用户的一些信息。

userCheck发生在一个库中，它不公开挂起函数，但仍然使用回调。在这个库中，我看到了这样的代码来启动每个网络请求：

internal suspend fun <T> doNetworkRequest(request: suspend () -> Response<T>): NetworkResult<T> {
    return withContext(Dispatchers.IO) {
        try {
            val response = request.invoke()
            ...

根据文件，调度员。IO可以使用多个线程来执行代码，而且请求函数只是来自改装API的函数。

因此，我所做的是为每个用户启动请求，并使用单个resultHandler对象，该对象将结果添加到列表中，并检查结果列表的长度是否等于用户列表的长度，如果是，则完成所有用户检查，我知道我可以对结果做些什么，这些结果需要一起返回。

val userList: List<String>? = getUsers()
val userCheckResultList = mutableListOf<UserCheckResult>()
val handler = object : UserCheckResultHandler {
                  override fun onResult(
                        userCheckResult: UserCheckResult?
                  ) {
                        userCheckResult?.let {
                            userCheckResultList.add(
                                it
                            )
                        }
                        if (userCheckResultList.size == userList?.size) {
                            doSomethingWithResultList()
                            print("SUCCESS")
                        }
                    }
                }

userList?.forEach {
    checkUser(it, handler)
}

我的问题是：这个实现是线程安全的吗？据我所知，Kotlinhtml" target="_blank">对象应该是线程安全的，但我得到的反馈是，这可能不是最好的实现：D

但从理论上讲，即使请求同时异步和多个启动，一次也只有一个可以访问结果处理程序运行的线程的锁，并且不会有竞争条件或将项目添加到列表和比较大小的问题。

我错了吗？有没有更好的方法来处理这种情况？

Answer 1

如果您并行执行多个请求-它不是。List不是线程安全的。但它很简单。创建一个Mutex对象，然后将您对list的操作打包为锁，如下所示：

val lock = Mutex()
val userList: List<String>? = getUsers()
val userCheckResultList = mutableListOf<UserCheckResult>()
val handler = object : UserCheckResultHandler {
                  override fun onResult(
                        userCheckResult: UserCheckResult?
                  ) {
                        lock.withLock {
                            userCheckResult?.let {
                                userCheckResultList.add(
                                    it
                                )
                            }
                            if (userCheckResultList.size == userList?.size) {
                                doSomethingWithResultList()
                                print("SUCCESS")
                            }
                        }
                    }
                }

userList?.forEach {
    checkUser(it, handler)
}

我必须补充一点，这个整个解决方案看起来非常粗鲁。我会走完全不同的路线。运行所有包装在async{//network Request}中的请求，这将返回Deferred对象。将此对象添加到某个列表中。之后使用waitAll（）等待所有这些延迟对象。像这样：

val jobs = mutableListOf<Job>()
userList?.forEach {
   // i assume checkUser is suspendable here
   jobs += async { checkUser(it, handler) }
}

// wait for all requests
jobs.awaitAll()

// After that you can access all results like this:
val resultOfJob0 = jobs[0].getCompleted()