swift之GCD(二)

我们接着看GCD，下面我们来看GCD中的一些方法

dispatch_suspend(queue)暂停某个队列上的操作，如果某个跟这个队列相关的block已经开始执行，则会在这个block执行完毕之后再进行暂停

dispatch_resume(queue)恢复某个队列上的操作

dispatch_set_target_queue(NSObject,queue)指定一个dispatch source相应的事件处理提交到哪个queue上。

让我们看一下代码吧

        var low = dispatch_queue_create("low", DISPATCH_QUEUE_SERIAL)

        var hight = dispatch_queue_create("hight", DISPATCH_QUEUE_CONCURRENT)

       

      dispatch_async(low, { () -> Void in

            println("--------1")//首先打印这个，因为已经进来，所以会把这个block执行完

            NSThread.sleepForTimeInterval(5)//在这延迟

            println("low")//第三个打印这个

            println("--------2")//第四个打印这个

        })

        NSThread.sleepForTimeInterval(3)

        dispatch_async(low, { () -> Void in//因为被暂停这个block进不来

            println("--------5")//最后打印这个block的值

            NSThread.sleepForTimeInterval(5)

            println("low")

            println("--------6")

        })

        dispatch_suspend(low)//暂停low

        dispatch_async(hight, { () -> Void in

            println("--------3")//这二个打印这个

            NSThread.sleepForTimeInterval(6)

            println("--------4")//第五个打印这个

            println("hight")//第六个打印这个

            dispatch_resume(low)//恢复low

        })

打印结果如下

--------1

--------3

low

--------2

--------4

hight

--------5

low

--------6

接下来让我们看一下dispatch_barrier_async，等待队列上已存在操作完成之后在进行这个队列上的其他操作，dispatch_barrier_sync等待队列上已存在操作完成之后在进行后面其他的操作，还是让我们用代码说话吧

        var queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT)

        dispatch_async(queue, { () -> Void in

            NSThread.sleepForTimeInterval(3)

            println(1)//第二个打印

        })

        dispatch_async(queue, { () -> Void in

            NSThread.sleepForTimeInterval(4)

            println(2)//第三个打印

        })

        dispatch_barrier_async(queue, { () -> Void in//在这只会让后面的这个队列上的block等待，并不是让后面所有的代码都等待，所以会先打印4，这里如果是dispatch_barrier_sync，4并不会先去打印，而是要等3打印之后才会去打印

            NSThread.sleepForTimeInterval(3)

            println(3)//第四个打印，因为会在这个block完之后才会执行后面的block操作

        })

        println(4)//首先打印这个值

        dispatch_async(queue, { () -> Void in

            NSThread.sleepForTimeInterval(2)

            println(5)

        })

        dispatch_async(queue, { () -> Void in

            NSThread.sleepForTimeInterval(1)

            println(6)

        })

然后看一下dispatch_group还是直接上代码

 var group = dispatch_group_create()//创建一个组

        var queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT)

        dispatch_group_async(group, queue) { () -> Void in

            NSThread.sleepForTimeInterval(4)

            println(3)//第三个被打印

        }

        dispatch_group_async(group, queue) { () -> Void in

            NSThread.sleepForTimeInterval(3)

            println(2)//第二个被打印

        }

        dispatch_group_async(group, queue) { () -> Void in

            NSThread.sleepForTimeInterval(2)

            println(1)//第一个被打印

        }

        dispatch_group_notify(group, queue) { () -> Void in//只有等这个组里的队列执行完之后，这里才会被打印

            println(10)

        }

        var time = dispatch_time(DISPATCH_TIME_NOW, (Int64)(10 * NSEC_PER_SEC))

        var a = dispatch_group_wait(group, time)

        println(a)//这里是等待这个组里的队列执行完，但是可以设置一个超时时间，如果在超时时间范围内执行完成会返回0，如果没有完成会返回一个非零误差，如果把time换成DISPATCH_TIME_FOREVER这个常量，则会一直等待下去

dispatch_once

        var onceToken :dispatch_once_t = 0//必须初始化为0，我也不知道为什么，文档里是这么说的

        dispatch_once(&onceToken, { () -> Void in

            //这里的代码只会执行一次

        })

            var queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL)

             //DISPATCH_QUEUE_SERIAL block块会按顺序一次一次接着执行

             //DISPATCH_QUEUE_CONCURRENT block块会并发执行

            dispatch_apply(5, queue, { (count:UInt) -> Void in

                println("--------")

                println(count)//count是第几次执行

            })