dispatch_after
功能：延迟一段时间把一项任务提交到队列中执行，返回之后就不能取消,常用来在在主队列上延迟执行一项任务。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> *NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
<#code to be executed after a specified delay#>
});
用法：可以利用dispatch_after写一个自己用的Delay函数，delay一段时间在主线程上执行一段代码
func hwcDelay(delay:Double, closure:()->()) {
dispatch_after(
dispatch_time(
DISPATCH_TIME_NOW,
Int64(delay * Double(NSEC_PER_SEC))
),
dispatch_get_main_queue(), closure)
}
//只需要这样使用
hwcDelay(0.5){
//Do everything you want
}
比如，我们的App需要打开蓝牙，如果在APP启动的时候测到蓝牙是Off状态后，我们应当给用户一个提示打开蓝牙。在view载入完成后，延迟给用户一个提示,也可以给这个提示添加一些动画，要比view在载入完成直接显示提示要友好得多：在viewLoad后，延迟1s，提示一个alertview
class ViewController: UIViewController{
func hwcDelay(delay:Double, closure:()->()) {
dispatch_after(
dispatch_time(
DISPATCH_TIME_NOW,
Int64(delay * Double(NSEC_PER_SEC))
),
dispatch_get_main_queue(), closure)
}
override func viewDidLoad(){
super.viewDidLoad()
hwcDelay(1.0){
var alertview = UIAlertView(title:"Dispatch_after",message:"Message",delegate:self,cancelButtonTitle:"OK")
alertview.show()
}
}
override func didReceiveMemoryWarning(){
super.didReceiveMemoryWarning()
}
}
dispatch_apply
功能：把一项任务提交到队列中多次执行，具体是并行执行还是串行执行由队列本身决定（不在意它是并行执行还是串行执行）。注意，dispatch_apply不会立刻返回，在执行完毕后才会返回，是同步的调用。用处：我们调用它可以把不相关的循环提交到后台线程并行执行。
func dispatch_apply(_ iterations: UInt,
_ queue: dispatch_queue_t!,
_ block: ((UInt) -> Void)!)
//iterations 执行的次数
//queue 提交到的队列
//block 执行的任务
举例：
比如我有一个数组，存储了一系列对象，初始化的时候，这些对象都要调用一次某函数来进行相关的计算。这些计算相互没有影响。这时，我们就可以用dispatch_apply来使用异步队列来初始化。这里把这种情况进行简化
class ViewController: UIViewController{
var hwcarray = ["hello","hwc","hellohwc"]
override func viewDidLoad(){
super.viewDidLoad()
dispatch_apply(3,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){
(index:UInt) -> () in
var expObject = self.hwcarray[Int(index)] as NSString
NSLog("%d",expObject.length)
}
NSLog("Dispatch_after is over")
}
override func didReceiveMemoryWarning(){
super.didReceiveMemoryWarning()
}
}
可以看到，输出是
3
5
8
dispatch_after is over
这样写的缺点：
1、会阻塞主线程
2、下文与dispatch_apply的执行结果无关
所以可以在异步队列中调用dispatch_apply,然后执行完成后进行通知。
class ViewController: UIViewController{
var hwcarray = ["hello","hwc","hellohwc"]
override func viewDidLoad(){
super.viewDidLoad()
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){
dispatch_apply(3,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){
(index:UInt) -> () in
var expObject = self.hwcarray[Int(index)] as NSString
NSLog("%d",expObject.length)
}
NSLog("Dispatch_after in global queue is over")
}
NSLog("Dispatch_after in main queue is over")
}
override func didReceiveMemoryWarning(){
super.didReceiveMemoryWarning()
}
}
这样输出为
8
Dispatch_after in main queue is over
3
5
Dispatch_after in global queue is over
可以看到，计算过程相对主队列(主线程)是异步的，在global队列中是并行执行的。
dispatch_group
如果想在dispatch_queue中所有的任务执行完成后在做某种操作，在串行队列中，可以把该操作放到最后一个任务执行完成后继续，但是在并行队列中怎么做呢。这就有dispatch_group 成组操作。比如:
dispatch_queue_t dispatchQueue = dispatch_queue_create("ted.queue.next", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t dispatchGroup = dispatch_group_create();
dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
NSLog(@"dispatch-1");
});
dispatch_group_async(dispatchGroup, dispatchQueue, ^(){
NSLog(@"dspatch-2");
});
dispatch_group_notify(dispatchGroup, dispatch_get_main_queue(), ^(){
NSLog(@"end");
});
上面的 log1 和log2输出顺序不定，因为是在并行队列上执行，当并行队列全部执行完成后，最后到main队列上执行一个操作，保证“end”是最后输出。 另外，这里也可以不用创建自己的并行队列，用全局的global，那个也是个并行队列. dispatch_get_gloable_queue(0,0);
dispatch_barrier_async
一个dispatch barrier 允许在一个并发队列中创建一个同步点。当在并发队列中遇到一个barrier, 他会延迟执行barrier的block,等待所有在barrier之前提交的blocks执行结束。 这时，barrier block自己开始执行。 之后， 队列继续正常的执行操作。
dispatch_queue_t concurrentQueue = dispatch_queue_create("my.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentQueue, ^(){
NSLog(@"dispatch-1");
});
dispatch_async(concurrentQueue, ^(){
NSLog(@"dispatch-2");
});
dispatch_barrier_async(concurrentQueue, ^(){
NSLog(@"dispatch-barrier");
});
dispatch_async(concurrentQueue, ^(){
NSLog(@"dispatch-3");
});
dispatch_async(concurrentQueue, ^(){
NSLog(@"dispatch-4");
});
dispatch_barrier_async 作用是在并行队列中，等待前面两个操作并行操作完成，这里是并行输出
dispatch-1，dispatch-2，然后执行dispatch_barrier_async中的操作，(现在就只会执行这一个操作)执行完成后，即输出
"dispatch-barrier，最后该并行队列恢复原有执行状态，继续并行执行dispatch-3,dispatch-4
