Swift3.0 GCD多线程详解

作者: brycegao | 来源:发表于2016-12-27 22:52 被阅读1063次

                                   GCD思维导图

    GCD(Grand Central Dispatch)是苹果公司实现的一套先进先出执行的任务队列, 我们只要将程序闭包传给GCD, mac os会在系统线程池里执行该任务, 而且无法确定到底是哪个线程执行的。 总之, GCD是个顺序或并发执行队列, 封装了线程的调度, 开发者不用直接操作线程了。

    DispatchQueue支持同步sync和异步async方法,每个人物即DispatchWorkItem只执行一遍; 同步和并发方法都是按照先进先出的顺序执行队列里的任务。

    App进程在启动时系统会自动创建一个main queue即DispatchQueue.main, 注意该queue里不能执行耗时操作并只能在main队列里刷新界面。

    1、DispatchQueue基本用法异步async:在子线程执行耗时操作完成后,将结果刷新到界面; 注意放开注释使用实例化queue和global的效果是一样的。

    //let queue = DispatchQueue(label: "com.brycegao.gcdtest")

    DispatchQueue.global().async {

    //queue.async {

    let url = URL(string: "http://img-arch.pconline.com.cn/images/upload/upc/tx/photoblog/1107/05/c5/8235345_8235345_1309860279806.jpg")!

    if let imageData = try? Data(contentsOf: url) {  //从网上取数据,属于耗时操作

    let tmpimage = UIImage(data: imageData as Data)  //二进制数据转换为图片,属于耗时操作

    DispatchQueue.main.async {  //通知ui刷新

    self.image = tmpimage

    self.imageView.image = self.image

    }

    }

    }

    这段代码的作用从网上下载一张图片并显示在UIImageView, 注释值传递! 根据闭包的语法特性, 闭包内可以访问外部的变量, 例如DispatchQueue.main.async闭包内能够使用外部变量self。

    let queue = DispatchQueue(label: "com.brycegao.gcdtest")

    queue.async {

    let date = Date()

    print("async1 \(date.description)")

    Thread.sleep(forTimeInterval: 1)  //停止1秒

    }

    queue.async {

    let date = Date()

    print("async2 \(date.description)")

    Thread.sleep(forTimeInterval: 1)

    }

    queue.async {

    let date = Date()

    print("async3 \(date.description)")

    Thread.sleep(forTimeInterval: 1)

    }

    从日志可以看出FIFO的特点,先添加的任务肯定先执行

    async1 2016-12-27 13:47:38 +0000

    async2 2016-12-27 13:47:39 +0000

    async3 2016-12-27 13:47:40 +0000

    2、DispatchQueue基本用法同步sync, 该方法会阻塞UI队列, 导致不显示控件或无点击事件等问题; sync方法仍然按照FIFO顺序执行。

    let queue = DispatchQueue(label: "com.brycegao.gcdtest")

    queue.async {  //异步方法不阻塞UI

    let date = Date()

    print("async1 \(date.description)")

    Thread.sleep(forTimeInterval: 1)  //停止1秒

    }

    queue.sync {  //同步方法会阻塞UI,造成不显示控件或无点击事件,但仍然是顺序执行

    let date = Date()

    print("sync \(date.description)")

    Thread.sleep(forTimeInterval: 10)

    }

    queue.async {

    let date = Date()

    print("async3 \(date.description)")

    Thread.sleep(forTimeInterval: 1)

    }

    async1 2016-12-27 13:55:17 +0000

    sync 2016-12-27 13:55:18 +0000

    async3 2016-12-27 13:55:28 +0000

    3、DispatchQos用于描述队列优先级, 从高到低分为userInteractive,userInitiated,default,utility,background, 默认是default。

    4、上面介绍的是串行队列(默认), 现在介绍并行队列。 并行对列只能通过实例化方式得到, 区别是有.concurrent参数。将上面的示例代码稍作改动, 即修改DispatchQueue的实例化方法参数。

    let conqueue = DispatchQueue(label: "queuename", attributes: .concurrent)  //并发队列

    conqueue.async {

    let date = Date()

    print("async1 \(date.description)")

    Thread.sleep(forTimeInterval: 1)  //停止1秒

    }

    conqueue.async {  //同步方法会阻塞UI,造成不显示控件或无点击事件,但仍然是顺序执行

    let date = Date()

    print("async2 \(date.description)")

    Thread.sleep(forTimeInterval: 1)

    }

    conqueue.async {

    let date = Date()

    print("async3 \(date.description)")

    Thread.sleep(forTimeInterval: 1)

    }        /*DispatchQueue.global().async

    从日志看跟普通的多线程并发是一样的, 在这里是在mac os线程池内执行的。

    async1 2016-12-27 14:08:21 +0000

    async2 2016-12-27 14:08:21 +0000

    async3 2016-12-27 14:08:21 +0000

    5、设置运行时间asyncAfter函数可以设置延迟一段时间后运行闭包,功能类似于定时器。 还是在上面示例代码上稍作修改。

    .....

    conqueue.async {

    let date = Date()

    print("async1 \(date.description)")

    Thread.sleep(forTimeInterval: 1)  //停止1秒

    }

    let time = DispatchTime.now() + 3

    conqueue.asyncAfter(deadline: time, execute: {

    let date = Date()

    print("asyncAfter \(date.description)")

    })

    ....

    输出:

    async1 2016-12-27 14:16:11 +0000

    async3 2016-12-27 14:16:11 +0000

    async2 2016-12-27 14:16:11 +0000

    asyncAfter 2016-12-27 14:16:14 +0000

    6、DispatchGroup的作用就是监听一个或多个DispatchQueue任务结束的触发事件, 类似于Java的wait/notifyAll。

    let group = DispatchGroup()

    let queue1 = DispatchQueue(label: "queue1")

    queue1.async(group: group) {

    Thread.sleep(forTimeInterval: 1)  //停止1秒

    let date = Date()

    print("async1 \(date.description)")

    }

    let queue2 = DispatchQueue(label: "queue2")

    queue2.async(group: group) {

    Thread.sleep(forTimeInterval: 3)

    let date = Date()

    print("asycn2 \(date.description)")

    }

    let queue3 = DispatchQueue(label: "queue3")

    queue3.async(group: group){

    Thread.sleep(forTimeInterval: 1)

    let date = Date()

    print("async3 \(date.description)")

    }

    let date1 = Date()

    print("date1: \(date1.description)")

    group.wait()    //等待group的任务都执行完成后向下执行

    let date2 = Date()

    print("date2: \(date2.description)")

    日志:

    date1: 2016-12-27 14:32:52 +0000

    async3 2016-12-27 14:32:53 +0000

    async1 2016-12-27 14:32:53 +0000

    asycn2 2016-12-27 14:32:55 +0000

    date2: 2016-12-27 14:32:55 +0000

    如上面示例代码, 将3个DispatchQueue的任务添加到DispatchGroup中,  date1先打印出来, 等到async1、async2、async3都执行完成后才打印date2。

    相关文章

      网友评论

        本文标题:Swift3.0 GCD多线程详解

        本文链接:https://www.haomeiwen.com/subject/ezwevttx.html