1. 前言

之前写了一遍文章介绍了Objective-C中GCD的用法: [iOS]多线程--GCD, 现在转战到Swift的战场, 根据前者一些知识点, 讲下使用Swift如何实现.

2. 队列

2.1 串行队列

创建串行队列的方式很简单:

DispatchQueue(label: <#T##String#>)

• label : 队列的标识符

例如:

let queue = DispatchQueue(label: "QueueIdentifier")

如果想指定串行队列的优先级, 可使用下面的方法来创建:

let queue = DispatchQueue(label: "QueueIdentifier", qos: .userInitiated)

参数qos: 用于指定队列的优先级, 是个枚举:

• .userInteractive
• .userInitiated
• .default
• .utility
• .background
• .unspecified
  优先级, 由上往下依次降低

一个最常用的串行队列--主队列:

DispatchQueue.main

2.2 并行队列

并行队列, 可以使用下面这个方法进行创建:

DispatchQueue(label: <#T##String#>, qos: <#T##DispatchQoS#>, attributes: <#T##DispatchQueue.Attributes#>)

和创建串行队列的方法一样, 只不过多了一个参数attributes, 传 .concurrent 即可创建一个并行队列

let queue1 = DispatchQueue(label: "并行队列的创建", qos: .default, attributes: .concurrent)

在使用的时候, 我们一般不去创建并行队列, 而是使用系统为我们提供的全局的并行队列:

// 获取全局并行队列
let queue = DispatchQueue.global()

在获取的时候我们也可以指定其优先级:

let que = DispatchQueue.global(qos: .default)

注意:
在创建串行并行队列的时候, 参数attributes, 可以指定创建的是串行还是并行队列, 他还有一个值: .initiallyInactive, 即: 创建的时候, 是处于不活跃状态, 即不会执行任务, 需要手动调用activate()来激活队列执行任务;

例如:

print("当前线程: \(Thread.current)")
        let queue = DispatchQueue(label: "开始不活跃的串行队列", attributes: .initiallyInactive)
        queue.async {
            print("执行了么?")
        }
        print("任务结束")

这个示例, 程序会crash, 应该这样:

print("当前线程: \(Thread.current)")
        let queue = DispatchQueue(label: "开始不活跃的串行队列", attributes: .initiallyInactive)
            queue.async {
            print("执行了么?")
        }
        queue.activate()
        print("任务结束")

上面这个是, 串行的不活跃队列, 如果想创建并行的不活跃队列呢? 可以这样:

print("当前线程: \(Thread.current)")
let queue = DispatchQueue(label: "开始不活跃的并行队列", attributes: [.concurrent, .initiallyInactive])
queue.async {
            print("执行了么?")
        }
        queue.activate()
        print("任务结束")

2.3 同步, 异步

同步/异步的执行, 只需要使用队列的实例对象调用sync(同步)/async(异步)方法即可, 这里可以使用闭包, 也可以使用DispatchWorkItem对象

queue.sync {
            <#code#>
        }
queue.async(execute: <#T##DispatchWorkItem#>)

3. 同步, 异步, 串行, 并发组合测试

测试一: 用同步函数往串行队列中添加任务

不会开启新的线程:

print("当前线程: \(Thread.current)")
       
        let queue = DispatchQueue(label: "创建串行队列")
        
        queue.sync {
            print("串行队列中同步执行的第1个任务: \(Thread.current)")
            sleep(4)
        }
        
        queue.sync {
            print("串行队列中同步执行的第2个任务: \(Thread.current)")
            sleep(2)
        }
        
        queue.sync {
            print("串行队列中同步执行的第3个任务: \(Thread.current)")
        }

控制台输出:

当前线程: <NSThread: 0x600000065900>{number = 1, name = main}
串行队列中同步执行的第1个任务: <NSThread: 0x600000065900>{number = 1, name = main}
串行队列中同步执行的第2个任务: <NSThread: 0x600000065900>{number = 1, name = main}
串行队列中同步执行的第3个任务: <NSThread: 0x600000065900>{number = 1, name = main}

可以看出, 没有开启新的线程, 同时也是按照顺序依次执行的;

测试二: 用异步函数往串行队列中添加任务

会开启线程，但是只开启一个线程:

print("当前线程: \(Thread.current)")
        
        
        let queue = DispatchQueue(label: "创建串行队列")
        
        queue.async {
            print("串行队列中同步执行的第1个任务: \(Thread.current)")
            sleep(4)
        }
        
        queue.async {
            print("串行队列中同步执行的第2个任务: \(Thread.current)")
            sleep(2)
        }
        
        queue.async {
            print("串行队列中同步执行的第3个任务: \(Thread.current)")
        }

控制台输出:

当前线程: <NSThread: 0x608000064000>{number = 1, name = main}
串行队列中同步执行的第1个任务: <NSThread: 0x608000071dc0>{number = 4, name = (null)}
串行队列中同步执行的第2个任务: <NSThread: 0x608000071dc0>{number = 4, name = (null)}
串行队列中同步执行的第3个任务: <NSThread: 0x608000071dc0>{number = 4, name = (null)}

虽然是异步函数, 但是添加到了串行队列里, 只开启了一个新的线程, 添加到其中的任务还是按顺序依次执行的

测试三: 用同步函数往并发队列中添加任务

不会开启新的线程((同步函数不具备开启新线程的能力))，并发队列失去了并发的功能:

 print("当前线程: \(Thread.current)")
        
        
        let queue = DispatchQueue(label: "创建并行队列", attributes: .concurrent)
        
        queue.sync {
            print("串行队列中同步执行的第1个任务: \(Thread.current)")
            sleep(4)
        }
        
        queue.sync {
            print("串行队列中同步执行的第2个任务: \(Thread.current)")
            sleep(2)
        }
        
        queue.sync {
            print("串行队列中同步执行的第3个任务: \(Thread.current)")
        }

控制台输出:

当前线程: <NSThread: 0x600000077b80>{number = 1, name = main}
串行队列中同步执行的第1个任务: <NSThread: 0x600000077b80>{number = 1, name = main}
串行队列中同步执行的第2个任务: <NSThread: 0x600000077b80>{number = 1, name = main}
串行队列中同步执行的第3个任务: <NSThread: 0x600000077b80>{number = 1, name = main}

可以看出, 虽然使用的是并发队列, 但是使用的是同步函数, 由于同步函数没有开启新线程的能力, 所以并发队列就失去了并发性, 按照任务的添加顺序, 顺序执行;

测试四. 用异步函数往并发队列中添加任务

同时开启多个子线程执行任务:

 print("当前线程: \(Thread.current)")
        
        
        let queue = DispatchQueue(label: "创建并行队列", attributes: .concurrent)
        
        queue.async {
            print("串行队列中同步执行的第1个任务: \(Thread.current)")
            sleep(4)
        }
        
        queue.async {
            print("串行队列中同步执行的第2个任务: \(Thread.current)")
            sleep(2)
        }
        
        queue.async {
            print("串行队列中同步执行的第3个任务: \(Thread.current)")
        }

控制台输出:

当前线程: <NSThread: 0x60000007c6c0>{number = 1, name = main}
串行队列中同步执行的第2个任务: <NSThread: 0x600000270380>{number = 4, name = (null)}
串行队列中同步执行的第3个任务: <NSThread: 0x60800027dec0>{number = 5, name = (null)}
串行队列中同步执行的第1个任务: <NSThread: 0x60000026b600>{number = 3, name = (null)}

可以看出, 这里开启了三个子线程来执行任务, 互相之间没有影响.
只有在并发队列异步执行的时候才能真正起到 并发的作用.

测试五. 控制最大并发数

在进行并发操作的时候, 如果任务过多, 开启很多线程, 会导致APP卡死. 所以, 我们要控制最大并发数, 这就用到了信号量DispatchSemaphore, 我们可以这样创建一个信号量:

let semaphore = DispatchSemaphore.init(value: 10)

参数为最大并发执行的任务数, 也即是信号量.
信号量减一:

semaphore.wait()
// 如果信号量大于1, 则会继续执行, 如果信号量等于0, 会等待timeout的时间, 在等待期间被semaphore.signal()加一了, 这里会继续执行, 并将信号量减一
semaphore.wait(timeout: <#T##DispatchTime#>)

上面函数的返回值为DispatchTimeoutResult, 是个枚举:

• success
• timedOut

---

DispatchTime的值可使用: .now() , 或者 .distantFuture
也可以创建:

DispatchTime.init(uptimeNanoseconds: <#T##UInt64#>)

这里的参数单位为纳秒: 1s = 1000*1000*100ns

信号量加一:

semaphore.signal()

一个应用:

print("当前线程: \(Thread.current)")
        
        let group = DispatchGroup.init()
        let queue = DispatchQueue.global()
        
        let semaphore = DispatchSemaphore.init(value: 10)
        
        for i in 0...100 {
            
            let result = semaphore.wait(timeout: .distantFuture)
            if result == .success {
                
                queue.async(group: group, execute: {
                    
                    print("队列执行\(i)--\(Thread.current)")
                    // 模拟执行任务时间
                    sleep(2)
                    // 任务结束, 信号量+1
                    semaphore.signal()
                })
            }
            
        }
        
        group.wait()

这个示例就是每十个任务并发执行.

测试六: 使用DispatchWorkItem

print("当前线程: \(Thread.current)")
        
        // 新建一个任务
        let workItem = DispatchWorkItem { 
            
            print("执行一个任务\(Thread.current)")
            sleep(3)
        }
        // 在当前线程执行任务
        workItem.perform()
       
        // 执行完成后, 通知主队列
        workItem.notify(queue: DispatchQueue.main) { 
            
            print("任务完成了")
        }

输出:

当前线程: <NSThread: 0x6000000774c0>{number = 1, name = main}
执行一个任务<NSThread: 0x6000000774c0>{number = 1, name = main}
任务完成了

在另一个队列执行任务(异步):

 print("当前线程: \(Thread.current)")
        
        // 新建一个任务
        let workItem = DispatchWorkItem { 
            
            print("执行一个任务\(Thread.current)")
            sleep(3)
        }
        
        let queue = DispatchQueue.global()
        // 执行任务
        queue.async(execute: workItem)
        // 执行完成后, 通知主队列
        workItem.notify(queue: DispatchQueue.main) { 
            
            print("任务完成了")
        }
        
        print("任务结束")

输出:

当前线程: <NSThread: 0x608000261700>{number = 1, name = main}
任务结束
执行一个任务<NSThread: 0x6080004661c0>{number = 4, name = (null)}
任务完成了

在创建任务的时候, 可使用下面的参数来设置其优先级:

let workItem = DispatchWorkItem(qos: <#T##DispatchQoS#>, block: <#T##() -> Void#>)

4. 一些应用

4.1延迟执行

print("当前线程: \(Thread.current)")
        print("开始时间\(Date())")
        let delayQueue = DispatchQueue(label: "delayQueue")
        // 延迟 2s
        let delayTime = DispatchTimeInterval.seconds(2)
        
        delayQueue.asyncAfter(deadline: .now() + delayTime) {
            print("这是延迟2s后执行的任务, 结束时间\(Date())")
            
        }

输出:

当前线程: <NSThread: 0x608000077d80>{number = 1, name = main}
开始时间2017-05-17 06:52:03 +0000
任务结束
这是延迟2s后执行的任务, 结束时间2017-05-17 06:52:05 +0000

这里的时间有以下几种方式设置:

let delayTime = DispatchTimeInterval.seconds(2)// 秒
let delayTime = DispatchTimeInterval.milliseconds(2*1000)// 毫秒
let delayTime = DispatchTimeInterval.microseconds(2*1000*1000)// 微秒
let delayTime = DispatchTimeInterval.nanoseconds(2*1000*1000*1000)// 纳秒

这里都是设置的延迟2s
也可以如下, 直接加上要延迟的时间间隔:

print("当前线程: \(Thread.current)")
        print("开始时间\(Date())")
        let delayQueue = DispatchQueue(label: "delayQueue")
        // 延迟 2s
        delayQueue.asyncAfter(deadline: .now() + 2) {
            print("这是延迟2s后执行的任务, 结束时间\(Date())")
        }
        print("任务结束")

4.2 汇总执行

如果, 你想某个任务在其他任务执行之后再执行, 或者必须某个任务执行完,才能执行下面的任务, 可以使用DispatchGroup:

print("当前线程: \(Thread.current)")
        let queue = DispatchQueue(label: "queueName", attributes: .concurrent)
        
        queue.async {
            sleep(4)
            print("任务 1")
        }
        
        queue.async {
            sleep(2)
            print("任务 2")
        }
        
        queue.async {
            sleep(6)
            print("任务 3")
        }
        
        DispatchGroup.init().notify(qos: .default, flags: .barrier, queue: queue) { 
            
            print("所有任务结束")
        }
        print("任务结束")