问题描述

我有以下代码，它使用DispatchGroup在任务完成时收到通知：

func getSomething(completion: ()->()) {
    completion()
}

func doSomeWork(completion: ()->()) {
    let myGroup: DispatchGroup = DispatchGroup()
    for _ in 0..<10 {
        myGroup.enter()
        getSomething {
            myGroup.leave()
        }
    }
    myGroup.notify(queue: DispatchQueue.main) { // this here is the key
        completion()
    }
}

DispatchQueue.global().async {
    print("We are doing background work")
    doSomeWork {
        print("We are done with the work - but on main thread now!!!")
    }
}

所以我的问题是，我在线程上调用某个函数，该函数有一个在某个固定队列上调用的完成。

我的选项是：

1. 检测Thread.isMainThread并在主队列或后台队列上通知
2. 为所有函数调用传递我们正在处理的队列 问题：这不是一个真正的智能设计模式
3. 处理此完成有固定队列的情况，然后再次手动调度

但我对任何选项都不满意...我不想收到这么多急件。

想象一下：

DispatchQueue.global().async {
    print("We are doing background work")
    doSomeWork {
        DispatchQueue.global().async {
            print("Now we are in background again")
        }
    }
}

这已经是一个级别3的闭包，使用起来并不是很好，特别是如果在后台异步调用中我们有另一个闭包或级别。

任何关于在这里做什么的帮助都是很棒的！谢谢您

推荐答案

问题是，我正在调用一个函数bla({//块代码 后台队列。Bla()在Main上调用完成处理程序 线程，由于分派组-Janosch Hübner

再次检查您的代码段

func doSomeWork(completion: ()->()) {
    let myGroup: DispatchGroup = DispatchGroup()
    for _ in 0..<10 {
        myGroup.enter()
        getSomething {
            myGroup.leave()
        }
    }
    myGroup.notify(queue: DispatchQueue.main) { // this here is the key
        completion()
    }
}

请看，因为getSomething是同步的，所以您可以简单地编写

func doSomeWork(completion: ()->()) {
    //let myGroup: DispatchGroup = DispatchGroup()
    for _ in 0..<10 {
        //myGroup.enter()
        getSomething {
            //myGroup.leave()
        }
    }
    //myGroup.notify(queue: DispatchQueue.main) { // this here is the key
        completion()
    /