Swift 获取数据中的dispatch\u async与dispatch\u sync。敏捷的

在阅读了这么多关于并行和并发的文章之后，我仍然不知道什么是获取数据的正确方法。例如，在我的项目中，我有一个按钮供用户获取数据。我的代码如下所示

var array = [Int]()
func fetchData() {

   ....
   ....
   response(objects: [object], error: NSError?) {
       for object in objects {
           array.append(object.number) // assume object.number return an Int
       }

       // confuse here. Should I use async here because I am worry if the user 
       // click the fetchData button more than one time, the append and make 
       // function will be happened at the same time. Or, is there anything I 
       // made a wrong assumption? I guess I need a serial operation. Correct?

       dispatch_async(dispatch_get_main_queue()) {
           makeCollectionView() // using the data in array
       }
   }
}

更新

试图运行此代码。10000-19999在0-9999之后运行。第二个异步似乎不会停止第一个异步来处理其操作

dispatch_async(dispatch_get_main_queue(), { () -> Void in
    for i in 0 ..< 10000 {
        print(i)
    }
})
dispatch_async(dispatch_get_main_queue(), { () -> Void in
    for i in 10000 ..< 20000 {
         print(i)
    }
})

dispatch\u async（dispatch\u get\u main\u queue（），{（）->Void in
对于0..<10000中的i{
印刷品（一）
}
})
dispatch\u async（dispatch\u get\u main\u queue（），{（）->Void in
对于我来说，10000..<20000{
印刷品（一）
}
})

为了提高性能，任何涉及UI的操作都应该在主线程上运行。所以基本上：

dispatch_async(dispatch_get_main_queue()) {
       //anything that involves UI
   }

---

GCD为执行任务提供队列。队列可以有两种类型–并发队列或串行队列。在串行队列中，任务一次执行一个（按FIFO顺序），在并发队列中，任务一次执行多个

为了防止用户在一个提取任务运行时提取数据，此时需要不将提取任务提交到队列。无论是哪种队列—并发队列还是串行队列

var array = [Int]()
var isFethingData = false

func fetchData() {
    if !isFethingData {
        isFethingData = true
        dispatch_async(queueForFetchData) {
            …
            response(objects: [object], error: NSError?) {
                for object in objects {
                    array.append(object.number)
                }

                dispatch_async(dispatch_get_main_queue()) {
                    makeCollectionView()
                }
                isFethingData = false
            }
    }
}

dispatch\u async

和

dispatch\u sync

是将任务提交到队列的函数。区别在于

dispatch\u async

在任务提交后立即返回，但

dispatch\u sync

等待任务完成。例如：

print("\(NSDate()) qq")
dispatch_sync(queue) {
    // … some code which runs for 10 minutes.
    print("\(NSDate()) ee")
}
print("\(NSDate()) ww")
// 2016-08-18 16:02:00 qq
// 2016-08-18 16:12:00 ee
// 2016-08-18 16:12:00 ww


print("\(NSDate()) qq")
dispatch_async(queue) {
    // … some code which runs for 10 minutes.
    print("\(NSDate()) ee")
}
print("\(NSDate()) ww")
// 2016-08-18 16:02:00 qq
// 2016-08-18 16:02:00 ww
// 2016-08-18 16:12:00 ee

---

啊。还有一个问题。如果我调用dispatch_async（queue）{makeCollectionView（）}两次，第二个makeCollectionView将在第一个makeCollectionView之后运行，或者第二个makeCollectionView将立即停止第一个makeCollectionView并运行？如果它将立即停止第一个任务，是否有任何功能可以将其作为队列中的第一个任务执行？@PakHoCheung

dispatch\u async

仅向队列提交任务。若您调用它两次，那个么队列将有两个以上的任务。主队列是串行队列，所以如果FIFO排序，任务将执行（在更新中，第一个将执行0..1000循环，第二个将执行10000..20000）。如果您在并发队列上调用dispatch\u async，那么任务将并发运行（例如

dispatch\u async（dispatch\u get\u global\u queue（dispatch\u queue\u PRIORITY\u DEFAULT，0），{}）

），并且您将同时看到两个循环的打印。@pakhocheng，如果您对管理任务（执行、停止、取消）感兴趣，那么您最好查看和。