我正在尝试跟踪当前异步网络请求的数量，并仅在有一个或多个请求正在进行时显示事件指示器。我正在使用调度组，但我认为我在 dispatch_group_notify block 和我的 closure block 之间存在竞争条件，因为我偶尔会在 dispatch_group_leave 上崩溃(任务组)行:

fatal error: unexpectedly found nil while unwrapping an Optional value

我认为发生这种情况是因为当调度组中没有更多项目时，它有时没有及时释放(设置为 nil)，在它被后面的请求使用之前(而不是正在创建的新组)。然后，该组立即通知它为空，回调闭包被调用，它被设置为nil，但是还有一个额外的项目试图离开现在的nil 组。

我认为解决方案在于确保 dispatch_group_leave 在最后一个 dispatch_group_leave 被触发后立即触发它的 block ，即在 callback 关闭之前。

我尝试将 dispatch_group_leave 和 callback 代码包装在单独的 dispatch_sync 闭包中，然后将它们添加到自定义串行队列中，但问题仍然存在在所有处决的 50% 以上。

将 callback 闭包调用包装在主队列的 dispatch_async 中(如下面的代码所示)会有所帮助，但问题仍然存在于大约 10% 的队列中所有处决。

这是我的代码(复制粘贴到 Playground 进行测试):

import UIKit
import XCPlayground

// Allow for asynchronous execution to take as long as it likes
XCPlaygroundPage.currentPage.needsIndefiniteExecution = true

// Background container view
let view = UIView(frame: CGRectMake(0, 0, 100, 100))
view.backgroundColor = UIColor.blackColor()
XCPlaygroundPage.currentPage.liveView = view

// Our activity indicator
let activityIndicator = UIActivityIndicatorView()
view.addSubview(activityIndicator)
activityIndicator.center = view.center

// Used to keep track of the number of current tasks
var taskGroup: dispatch_group_t!

// An async task that calls its callback after 2 to 5 seconds
func fireATask(callback: String -> Void) {

    if taskGroup == nil {
        print("Creating new dispatch group")
        taskGroup = dispatch_group_create()
        dispatch_group_enter(taskGroup)
        activityIndicator.startAnimating()
        dispatch_group_notify(taskGroup, dispatch_get_main_queue()) {
            activityIndicator.stopAnimating()
            taskGroup = nil
            print("All done!")
        }
    } else {
        print("Using existing dispatch group")
        dispatch_group_enter(taskGroup)
    }

    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)) {

        let delay = arc4random_uniform(1) + 2
        print("Task fired with [\(delay)] second delay.")
        let delayNanoseconds = Int64(UInt64(delay) * NSEC_PER_SEC)
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayNanoseconds), dispatch_get_main_queue()) {

            dispatch_group_leave(taskGroup) // Sometimes crashing here because taskGroup is nil

            dispatch_async(dispatch_get_main_queue()) { // My attempt to make sure dispatch_group_notify is called before the callback
                callback("Task with [\(delay)] second delay finished!")
            }
        }
    }
}

我有时会得到很好的结果:

Creating new dispatch group
Using existing dispatch group
Task fired with [2] second delay.
Task fired with [2] second delay.
Task with [2] second delay finished!
All done!
Task with [2] second delay finished!
Creating new dispatch group
Task fired with [2] second delay.
All done!
Task with [2] second delay finished!

其他时候我会崩溃:

Creating new dispatch group
Using existing dispatch group
Task fired with [2] second delay.
Task fired with [2] second delay.
Task with [2] second delay finished!
Using existing dispatch group
Task fired with [2] second delay.
All done!
Task with [2] second delay finished!
fatal error: unexpectedly found nil while unwrapping an Optional value

最佳答案

dispatch_group_notify 安排一个 block 对象在组为空时提交到队列。因此，在您的第二个示例中，您遇到了崩溃。由于从不同线程异步调用 print，日志中的消息出现乱序。这是真实情况:

Creating new dispatch group
Using existing dispatch group
Task fired with [2] second delay.
Task fired with [2] second delay.
Task with [2] second delay finished!
Task with [2] second delay finished!
All done!

Using existing dispatch group
Task fired with [2] second delay.
Task with [2] second delay finished!
fatal error: unexpectedly found nil while unwrapping an Optional value

只需使用 dispatch_sync(dispatch_get_main_queue()) 包装所有 print 调用，您将得到类似的结果。

这里是我解决问题的方式:

// The execution queue
var tasksQueue = dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
var nTasks = 0

// An async task that calls its callback after 2 to 5 seconds
func fireATask(callback: String -> Void) {
    dispatch_async(tasksQueue) {

        dispatch_sync(dispatch_get_main_queue()) {
            nTasks += 1
            activityIndicator.startAnimating()
        }

        let delay = arc4random_uniform(1) + 2
        print("Task fired with [\(delay)] second delay.")
        let delayNanoseconds = Int64(UInt64(delay) * NSEC_PER_SEC)
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayNanoseconds), dispatch_get_main_queue()) {
            callback("Task with [\(delay)] second delay finished!")
            nTasks -= 1
            if nTasks == 0 {
                activityIndicator.stopAnimating()
                print("All done!")
            }
        }
    }
}

关于ios - GCD - 跟踪总数或异步任务，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37507038/