如何一个接一个地执行多个异步请求

Question

我有一组异步执行的请求。但是，每个下一个请求只能在上一个请求完成时开始（由于数据依赖性）。

由于所有请求都应该按正确的顺序完成，DispatchGroup() 似乎没有用。

我目前实施了 DispatchSemaphore()，但我觉得这不是最佳解决方案，因为我想确保所有请求都在后台执行。

let semaphore = DispatchSemaphore(value: requests.count)

for request in requests {
    apiManager().performAsyncRequest(request, failure: { error in
        print(error); semaphore.signal()
        }) { print(“request finished successful”) 
        // Next request should be performed now
        semaphore.signal()
    }
}
semaphore.wait()

有没有更好的方法来执行此操作？

注意：基于以下答案之一的实现，我遇到 apiManager() 不是线程安全的（由于使用了 Realm 数据库）。

为了明确这个问题，并以线程安全的方式考虑答案，线程安全定义为 performAsyncRequest:

public func performAsyncRequest(_ requestNumber: Int, success: @escaping (Int) -> Void)->Void {
    DispatchQueue(label: "performRequest").async {
        usleep(useconds_t(1000-requestNumber*200))
        print("Request #\(requestNumber) starts")
        success(requestNumber)
    }
}

DispatchSemaphore

的解决方案

        let semaphore = DispatchSemaphore(value: 1)
        DispatchQueue(label: "requests").async {
            for requestNumber in 0..<4 {
                semaphore.wait()
                performAsyncRequest(requestNumber) { requestNumber in
                        print("Request #\(requestNumber) finished")
                        semaphore.signal()
                }
            }
        }

预期输出：

Request #0 starts
Request #0 finished
Request #1 starts
Request #1 finished
Request #2 starts
Request #2 finished
Request #3 starts
Request #3 finished

尝试Operation

不成功

    var operations = [Operation]()

    for requestNumber in 0..<4 {
        let operation = BlockOperation(block: {
            performAsyncRequest(requestNumber) { requestNumber in
                DispatchQueue.main.sync {
                    print("Request #\(requestNumber) finished")
                }
            }
        })

        if operations.count > 0 {
            operation.addDependency(operations.last!)
        }
        operations.append(operation)
    }

    let operationQueue = OperationQueue.main
    operationQueue.addOperations(operations, waitUntilFinished: false)

输出不正确：

Request #0 starts
Request #1 starts
Request #2 starts
Request #3 starts
Request #0 finished
Request #3 finished
Request #2 finished
Request #1 finished

我的感觉是 Operation 也应该可以实现，但我不知道它是否比 DispatchSemaphore 更好。

Answer 1

您可以使用 NSOperationQueue 并将每个请求添加为操作

let firstOperation: NSOperation
let secondOperation: NSOperation
secondOperation.addDependency(firstOperation)

let operationQueue = NSOperationQueue.mainQueue()
operationQueue.addOperations([firstOperation, secondOperation], waitUntilFinished: false)

Answer 2

您在 DispatchSemaphore 的正确轨道上确保在前一个调用完成之前不会启动异步调用。我只是确保管理对异步 API 调用的代码在后台运行：

let backgroundQueue = DispatchQueue(label: "requests")
let semaphore = DispatchSemaphore(value: 1)

backgroundQueue.async {
    var requestNumber = 1

    for request in requests {
        semaphore.wait()

        let currentRequestNumber = requestNumber

        print("Request launched #\(requestNumber)")

        apiManager().performAsyncRequest(request,
        failure: {
            error in
            print("Request error #\(currentRequestNumber)")
            semaphore.signal()
        }) {
            print("Request result #\(currentRequestNumber)")
            semaphore.signal()
        }

        requestNumber = requestNumber + 1
    }
}

当 for 循环在后台循环中运行并在等待前一个请求完成后启动每个请求时，代码将立即继续执行。

或者如果 apiManager() 不是线程安全的：

let semaphore = DispatchSemaphore(value: 1)

var requestNumber = 1

for request in requests {
    semaphore.wait()

    let currentRequestNumber = requestNumber

    print("Request launched #\(requestNumber)")

    apiManager().performAsyncRequest(request,
    failure: {
        error in
        print("Request error #\(currentRequestNumber)")
        semaphore.signal()
    }) {
        print("Request result #\(currentRequestNumber)")
        semaphore.signal()
    }

    requestNumber = requestNumber + 1
}

这有一个限制，即for循环将一直执行到最后一个请求开始执行。但是，如果您调用的代码不是线程安全的，则没有办法解决这个问题。

如何一个接一个地执行多个异步请求

How to perform multiple asynchronous requests starting one after another

multithreading

asynchronous

grand-central-dispatch

ios

swift