加载中…
正文 字体大小:

GCD for Swift

(2017-08-12 22:28:03)
仔细学习一遍GCD,常用的都在这里了。当然了,GCD的I/O queue,还有data queue 还没看到 以后有机会再更新吧。这里的内容基本上够用了 
func exdispathQueue(){//自定义的dispatchQueue

        let serialQ = dispatch_queue_create("selrialQueue"DISPATCH_QUEUE_SERIAL)//串行队列    程序的主线程 就是一个串行的队列。在系统级别的多线程 称之为多进程

        

        let concurrentQ = dispatch_queue_create("conQueue"DISPATCH_QUEUE_CONCURRENT)//并行队列

        //区别 串行队列中的线程是串行的,要实现多线程的话,则需要创建多个串行队列,当线程较多时,内存消耗的厉害; 并行队列,队列中的线程,比如线程1,和线程2,先执行1的一部分,马上执行2的一部分,这样就实现了 一个并行队列的多线程。通常,程序里面的多线程都是并行队列来实现的

    }

    

    

   class func systemQueue(){//系统提供的标准队列

        //main dispatch queue 主线程  串行队列

        let mainQ = dispatch_get_main_queue()//获取主队列

        //Global Dispatch Queue不需要通过dispatch_queue_create函数来逐个生成Concurrent Dispatch Queue,只要获取Global Dispatch Queue就行了

        let GlobalQ = dispatch_get_global_queue(QOS_CLASS_DEFAULT0)

        

        //使用示例

        dispatch_async(GlobalQ) { 

            print(NSThread.currentThread())

            var a:String?

            a = "线程变量"

            //做一些耗时操作完成之后  返回主线程

            dispatch_async(dispatch_get_main_queue(), {

                print(NSThread.currentThread())

                print(a)

            })

        }

    }

    

    class func dispatchGroupOne(){//虽然也是group,但是有个问题,如果子线程中有异步的,就有问题,所以如果子线程中有下载或上传等异步任务,这种group就不行

        let queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT0)//创建并行队列

        let group = dispatch_group_create()//创建组

        dispatch_group_async(group, queue) {print("任务1")}

        dispatch_group_async(group, queue) {print("任务2")}//向线程组里添加线程任务

        dispatch_group_async(group, queue) {print("任务3")}

//        dispatch_group_notify(group, dispatch_get_main_queue()) {

//            print("1,2,3都完成了")//所有任务都完成了 再执行某一任务。

//        }

        

        let result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER)//------>这个是上面的翻版,意思是如果group里面的线程没结束就永远等待下去,等的结果通过返回值表现

        if result == 0 {//返回0表示全结束了,看API

            print("1,2,3都完成了")

        }

    }

    

    class func dispatchGroupTwo(){//这种方案 应对线程之中如果有异步操作,比如发表说说

        let group = dispatch_group_create()

        for in 0...3 {

            dispatch_group_enter(group)

            let queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT0)

            dispatch_async(queue, { 

                //耗时操作完成之后

                print(i)

                dispatch_group_leave(group)

            })

        }

        dispatch_group_notify(group, dispatch_get_main_queue()) { 

            print("都完成了")

        }

    }

    

    class func apply() -> () {//将第三个参数block加入到第二个参数的队列中去。第一个参数是执行这样的操作的次数

        dispatch_apply(10dispatch_get_global_queue(QOS_CLASS_DEFAULT0)) { (index) in

            print(index)

        }

    }

    

    func suspendQ() -> () {//对加入队列中未执行的block暂停或继续其执行

//        dispatch_suspend(queue) 暂停

        //dispatch_resume(queue) 恢复

    }

    

    class func dispatchSet() ->() {

//        let queue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

//        let queue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)

//        

//        dispatch_set_target_queue(queue1, queue2)//queue1的优先级设置为queue2的优先级一致     设置队列的优先级

//        

//        dispatch_apply(1, queue1) { (index) in

//            print("queue1----\(NSThread.currentThread())")

//        }

//        

//        dispatch_apply(1, queue2) { (index) in

//            print("queue2----\(NSThread.currentThread())")

//        }

        

        let targetQueue = dispatch_queue_create("targetQueue"DISPATCH_QUEUE_SERIAL)

        let queue1 = dispatch_queue_create("queue1"DISPATCH_QUEUE_CONCURRENT)

        let queue2 = dispatch_queue_create("queue2"DISPATCH_QUEUE_CONCURRENT)

        //targetQueue 是串行队列,如果希望queue1queue2同步执行,则dispatch_set_target_queue将排上用场,不这么处理,q1q2将并行处理

        dispatch_set_target_queue(queue1, targetQueue)

        dispatch_set_target_queue(queue2, targetQueue)

        

        dispatch_async(queue1) { 

            for in 0...5{

                NSThread.sleepForTimeInterval(0.5)

                print("queue1----\(NSThread.currentThread()) ---- \(i)")

            }

        }

        

        dispatch_async(queue1) {

            

            for in 0...5{

                NSThread.sleepForTimeInterval(0.5)

                print("queue1 again----\(NSThread.currentThread()) ---- \(i)")

            }

        }

        

        dispatch_async(queue2){

            for in 0...5{

                NSThread.sleepForTimeInterval(0.5)

                print("queue2----\(NSThread.currentThread()) ---- \(i)")

            }

        }

    }

    

    class func barrier() {//作用 异步线程 barrier前面的线程执行结束,再继续执行后面的代码 1.实现高效率的数据库访问和文件访问 2.避免数据竞争q1,q2次序不定,q3,q4次序不定。但是肯定是q1,q2执行完后才执行q3,q4

        let queue = dispatch_queue_create("queue"DISPATCH_QUEUE_CONCURRENT)

        

        dispatch_async(queue) { 

            print("----1  \(NSThread.currentThread())")

        }

        dispatch_async(queue) { 

            print("----2  \(NSThread.currentThread())")

            NSThread.sleepForTimeInterval(5)

        }

        

        dispatch_barrier_async(queue) {

            print("5s delay continue running")

        }

        

        dispatch_async(queue) {

            print("----3  \(NSThread.currentThread())")

        }

        

        dispatch_async(queue) {

            print("----4  \(NSThread.currentThread())")

        }

    }

    

    class func Semaphore() -> () {

        let groupQ = dispatch_group_create()

        let semQueue = dispatch_semaphore_create(10)//创建信号量为10的信号队列

        let taskQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT0)

        

        for in 0...20{

            dispatch_semaphore_wait(semQueue, DISPATCH_TIME_FOREVER)//信号量-1 如果总信号量为则永远等待下去

            dispatch_group_async(groupQ, taskQueue, {

                print("-----\(i)")

                NSThread.sleepForTimeInterval(5)

                dispatch_semaphore_signal(semQueue)// 信号量 +1

            })

        }

        dispatch_group_notify(groupQ, dispatch_get_main_queue()) { 

            print("我执行完了")

        }//运行这段代码可以发现,使用信号量 配合group可以实现同一时刻 异步执行的线程的个数,从而实现并发控制,原理是主线程每循环10,信号量就为主线程进入等待。开辟了10个子线程之后,每个子线程都被阻塞5s,阻塞完成后,每个子线程又各自将信号量+1 这样信号总量又为10,从而进入下一个循环。由于cup运算速度极快,每一组子线程之间的先后次序可以认为是同一时刻。这样就实现了 并发控制

    }

0

阅读 评论 收藏 转载 喜欢 打印举报
已投稿到:
后一篇:Block for iOS
  • 评论加载中,请稍候...
发评论

    发评论

    以上网友发言只代表其个人观点,不代表新浪网的观点或立场。

    后一篇 >Block for iOS
      

    新浪BLOG意见反馈留言板 不良信息反馈 电话:4006900000 提示音后按1键(按当地市话标准计费) 欢迎批评指正

    新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 会员注册 | 产品答疑

    新浪公司 版权所有