GCD(Swift)

原文连接

这篇文主要想总结下多线程在swift中的使用，先看下基本概念

进程

进程指在系统中能独立运行并做为资源分配的基本单位，它是由一组机器指令、数据和堆栈等组成的，是一个能独立运行的活动实体

线程

线程是进程的基本执行单元，一个进程（程序）的全部任务都在线程中执行。

队列

队列，又称为伫列（queue），是先进先出（FIFO, First-In-First-Out）的线性表。在具体应用中一般用链表或者数组来实现。队列只容许在后端（称为rear）进行插入操做，在前端（称为front）进行删除操做。队列的操做方式和堆栈相似，惟一的区别在于队列只容许新数据在后端进行添加。

同步/异步

能够这么理解：（知乎）

• 假如你要作两件事 ， 烧水 、 刷牙
• 同步 ：你烧水 ， 等水烧开了你再去刷牙
• 异步 ：你烧水 ，不等水烧开就去刷牙了 ， 水烧开了会发出声音告诉你（callback） ， 而后你再处理水烧开以后的事情

只要你是个正常人 ， 都会选择第二种 , 固然也有特殊状况 ， 那我的喜欢用热水刷牙

并发

指两个或多个事件在同一时间间隔内发生。能够在某条线程和其余线程之间反复屡次进行上下文切换，看上去就好像一个CPU可以而且执行多个线程同样。实际上是伪异步。

线程队列中并行/串行

串行队列：串行队列的特色是队列内的线程是一个一个执行，直到结束。并行队列：并行队列的特色是队列中全部线程的执行结束时必须是一块的，队列中其余线程执行完毕后，会阻塞当前线程等待队列中其余线程执行，而后一块执行完毕。

---

如何使用

DispatchQueue.global().async {

    print("do something in global \(Thread.current)")

    DispatchQueue.main.async {

        print("do something in main \(Thread.current)")
    }
}
复制代码

这里使用了全局的队列执行一些任务 ， 而后切回主队列 , 这里要注意主队列是运行在主线程上的任务堆栈 。

自定义队列

除了使用全局队列外咱们还可使用自定义的队列

let q = DispatchQueue(label: "com.felix.felix")
复制代码

初始化一个队列最简单的方式就是声明它的标签 。

async

打开Xcode,新建一个commandLineTool工程、 打开main.swift

let q = DispatchQueue(label: "com.felix.felix")

q.sync {
    (1...5).forEach({ i in
        print("🍎 \(Thread.current) + \(i)")
    })
}
q.async {
    (6...10).forEach({ i in
        print("🍇 \(Thread.current) + \(i)")
    })
}
(11...15).forEach({ i in
    print("🍌 \(Thread.current) + \(i)")
})
复制代码

先声明一个队列,使用sync添加一个同步的任务输出1到5,使用async异步输出6到10,同时在主线程打印11到15 。

按下command+R运行project,

🍎 <NSThread: 0x103103480>{number = 1, name = main} + 1
🍎 <NSThread: 0x103103480>{number = 1, name = main} + 2
🍎 <NSThread: 0x103103480>{number = 1, name = main} + 3
🍎 <NSThread: 0x103103480>{number = 1, name = main} + 4
🍎 <NSThread: 0x103103480>{number = 1, name = main} + 5
🍌 <NSThread: 0x103103480>{number = 1, name = main} + 11
🍇 <NSThread: 0x103007940>{number = 2, name = (null)} + 6
🍌 <NSThread: 0x103103480>{number = 1, name = main} + 12
🍇 <NSThread: 0x103007940>{number = 2, name = (null)} + 7
🍌 <NSThread: 0x103103480>{number = 1, name = main} + 13
🍇 <NSThread: 0x103007940>{number = 2, name = (null)} + 8
🍌 <NSThread: 0x103103480>{number = 1, name = main} + 14
🍇 <NSThread: 0x103007940>{number = 2, name = (null)} + 9
🍌 <NSThread: 0x103103480>{number = 1, name = main} + 15
🍇 <NSThread: 0x103007940>{number = 2, name = (null)} + 10
Program ended with exit code: 0
复制代码

咱们能够看到,🍎表明的任务所有是优先执行的,这说明sync添加的任务会阻塞当前线程,在看到🍌和🍇是均匀分部的,这是因为async添加的任务会默认加入由系统管理的线程池,异步执行 。

优先级 QoS

当多个队列同时执行的时候,系统须要知道哪一个队列优先级更高,才能优先安排计算资源给他,咱们能够这样定义优先级：

let q = DispatchQueue(label: "com.felix.felix", qos: DispatchQoS.background)
复制代码

初始化的时候加上qos参数 ， qos（quality of service）从字面上理解就是「服务质量」，在swift中是这样定义的：

public enum QoSClass {

        @available(OSX 10.10, iOS 8.0, *)
        case background

        @available(OSX 10.10, iOS 8.0, *)
        case utility

        @available(OSX 10.10, iOS 8.0, *)
        case `default`

        @available(OSX 10.10, iOS 8.0, *)
        case userInitiated

        @available(OSX 10.10, iOS 8.0, *)
        case userInteractive

        case unspecified

        @available(OSX 10.10, iOS 8.0, *)
        public init?(rawValue: qos_class_t)

        @available(OSX 10.10, iOS 8.0, *)
        public var rawValue: qos_class_t { get }
    }
复制代码

• User Interactive： 和用户交互相关，好比动画等等优先级最高。好比用户连续拖拽的计算
• User Initiated： 须要马上的结果，好比push一个ViewController以前的数据计算
• Utility： 能够执行很长时间，再通知用户结果。好比下载一个文件，给用户下载进度。
• Background： 用户不可见，好比在后台存储大量数据

在选择优先级时能够参考以下判断 。

• 这个任务是用户可见的吗？
• 这个任务和用户交互有关吗？
• 这个任务的执行时间有多少？
• 这个任务的最终结果和UI有关系吗？

并发队列

默认状况下添加进Queue的任务会串行执行 ， 先执行完一个再执行下一个：

import Foundation

let q = DispatchQueue(label: "com.felix.felix")

q.async {
    (1...5).forEach({ i in
        print("🍎 \(Thread.current) + \(i)")
    })
}
q.async {
    (6...10).forEach({ i in
        print("🍇 \(Thread.current) + \(i)")
    })
}
(11...15).forEach({ i in
    print("🍌 \(Thread.current) + \(i)")
})
复制代码

运行看下日志输出

🍎 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 1
🍌 <NSThread: 0x100f046f0>{number = 1, name = main} + 11
🍎 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 2
🍌 <NSThread: 0x100f046f0>{number = 1, name = main} + 12
🍎 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 3
🍌 <NSThread: 0x100f046f0>{number = 1, name = main} + 13
🍎 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 4
🍌 <NSThread: 0x100f046f0>{number = 1, name = main} + 14
🍎 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 5
🍌 <NSThread: 0x100f046f0>{number = 1, name = main} + 15
🍇 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 6
🍇 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 7
🍇 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 8
🍇 <NSThread: 0x102a081a0>{number = 2, name = (null)} + 9
Program ended with exit code: 0
复制代码

咱们能够看到直到🍎都输出完毕才会输出🍇,有时候咱们想把任务并行执行,怎么办呢。 能够设置queue的Attributes。

let q = DispatchQueue(label: "com.felix.felix", attributes: DispatchQueue.Attributes.concurrent)
复制代码

再运行下看看会怎样。

DispatchWorkItem

有的时候,对于同一个操做咱们有可能会放在不一样的线程中去执行,这样咱们就能够把这个操做用DispatchWorkItem的形式包裹起来,在不一样的线程中执行 。

import Foundation

let group = DispatchGroup()

let q = DispatchQueue(label: "com.felix.felix", attributes: DispatchQueue.Attributes.concurrent)

let item1 = DispatchWorkItem {
    (1...5).forEach({ i in
        print("🍎 \(Thread.current) + \(i)")
    })
}

let item2 = DispatchWorkItem {
    (6...10).forEach({ i in
        print("🍇 \(Thread.current) + \(i)")
    })
}


q.async(execute: item1)

q.async(execute: item2)

(11...15).forEach({ i in
    print("🍌 \(Thread.current) + \(i)")
})
复制代码

Group 队列组

DispatchGroup 能够用来管理一组队列,监听全部队列的全部任务都完成的通知,比较经常使用的就是在一个页面请求多个接口的时候,所有请求完再刷新UI 。

总结

总之,使用GCD一方面会提高咱们应用的性能,给用户带来更好的体验,不过必定要注意线程安全问题。