Swift 3.0中GCD的常用方法
2016-10-28 10:24
549 查看
随着苹果推出swift3.0,很多API都发生了变化,下面我就来总结下GCD的一些常用API用法。
首先为了方便先定义几个属性:
创建好的队列执行任务
串行执行队列
接下来是GCD常用的用法
开线程异步执行完耗时代码返回主线程刷新UI
2.等待异步执行多个任务后, 再执行下一个任务
延时提交任务
信号量:
信号量的说明:
GCD 信号量控制并发 (dispatch_semaphore)
当我们在处理一系列线程的时候,当数量达到一定量,在以前我们可能会选择使用NSOperationQueue来处理并发控制,但如何在GCD中快速的控制并发呢?答案就是dispatch_semaphore。
信号量是一个整形值并且具有一个初始计数值,并且支持两个操作:信号通知和等待。当一个信号量被信号通知,其计数会被增加。当一个线程在一个信号量上等待时,线程会被阻塞(如果有必要的话),直至计数器大于零,然后线程会减少这个计数。
在GCD中有三个函数是semaphore的操作,分别是:
1、dispatch_semaphore_create 创建一个semaphore
2、dispatch_semaphore_signal 发送一个信号
3、dispatch_semaphore_wait 等待信号
重复提交任务(定时器)
2 . wait(任务等待)
3. enter leave 手动管理group计数,enter和leave必须配对
最后来说说dispatch_set_target_queue的具体用法
首先这个OC中的API在Swift中已经发生变化,具体请看下图:
![](http://img.blog.csdn.net/20170314153320257?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaG1oMDA3/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
可以看到更新后的API,那么这个方法到底有什么用呢?
(一),使用dispatch_set_target_queue更改Dispatch Queue的执行优先级
dispatch_queue_create函数生成的DisPatch Queue不管是Serial DisPatch Queue还是Concurrent Dispatch Queue,执行的优先级都与默认优先级的Global Dispatch queue相同,如果需要变更生成的Dispatch Queue的执行优先级则需要使用dispatch_set_target_queue函数
(二),使用dispatch_set_target_queue修改用户队列的目标队列,使多个serial queue在目标queue上一次只有一个执行
首先,我们需要阐述一下生成多个Serial DisPatch Queue时的注意事项
Serial DisPatch Queue是一个串行队列,只能同时执行1个追加处理(即任务),当用Dispatch_queue_create函数生成多个Serial DisPatch Queue时,每个Serial DisPatch Queue均获得一个线程,即多个Serial DisPatch Queue可并发执行,同时处理添加到各个Serial DisPatch Queue中的任务,但要注意如果过多地使用多线程,就会消耗大量内存,引起大量的上下文切换,大幅度降低系统的响应性能,所以我们只在为了避免多个线程更新相同资源导致数据竞争时,使用Serial DisPatch Queue
第一种情况:使用dispatch_set_target_queue(Dispatch Queue1, Dispatch Queue2)实现队列的动态调度管理
func GCDTest11() {
// 创建串行队列1
let serialQueue1 = DispatchQueue(label: "queue1")
// 创建串行队列2
let serialQueue2 = DispatchQueue(label: "queue2")
// 使用setTarget实现队列的动态调度管理
serialQueue1.setTarget(queue: serialQueue2)
// 此时,serialQueue1上还未运行的block会在serialQueue2上运行,这时如果暂停serialQueue1运行:
// serialQueue1.suspend()
// 这时只会暂停serialQueue1上原来的block的执行,serialQueue2的block不受影响,而如果暂停serialQueue2的运行,则会暂停serialQueue1的运行
// 另外DispatchQueue不支持cancel,没有实现dispatch_cancel,不想NSOperationQUeue,这可以说是个小缺憾。。。
serialQueue1.async {
for i in 0..<10 {
print("serialQueue1:\(Thread.current)\(i)")
Thread.sleep(forTimeInterval: 0.5)
if i == 5 {
serialQueue1.suspend()
}
}
}
serialQueue1.async {
for i in 0..<100 {
print("serialQueue1:\(Thread.current)\(i)")
}
}
serialQueue2.async {
for i in 0..<100 {
print("serialQueue2:\(Thread.current)\(i)")
}
}
}
第二种情况:使用dispatch_set_target_queue将多个串行的queue指定到了同一目标,那么着多个串行queue在目标queue上就是同步执行的,不再是并行执行。
func GCDTest12() {
// 创建目标队列
let targetQueue = DispatchQueue(label: "test.target.queue")
// 创建三个串行队列
let queue1 = DispatchQueue(label: "test.1")
let queue2 = DispatchQueue(label: "test.2")
let queue3 = DispatchQueue(label: "test.3")
// 将三个串行队列分别添加到目标队列
queue1.setTarget(queue: targetQueue)
queue2.setTarget(queue: targetQueue)
queue3.setTarget(queue: targetQueue)
queue1.async {
print("1 in")
Thread.sleep(forTimeInterval: 3.0)
print("1 out")
}
queue2.async {
print("2 in")
Thread.sleep(forTimeInterval: 2.0)
print("2 out")
}
queue3.async {
print("3 in")
Thread.sleep(forTimeInterval: 1.0)
print("3 out")
}
}
以上就是个人对swift 3.0 GCD 的理解. 欢迎大家留言补充.
首先为了方便先定义几个属性:
class ViewController:UIViewController{ /**队列*/ var myQueue:DispatchQueue? var myQueueTimer:DispatchQueue? var mnytimer:DispatchSourceTimer? var myGroup:DispatchGroup? var mySource:DispatchSource? override fun viewDidLoad() { super.viewDidLoad() GCDTest1() GCDTest8() } }
定义队列
//MARK: - 创建队列 //1. myQueue = DispatchQueue(label: "第一条线程") /* - parameter qos:DispatchQoS 线程的策略 case background //后台 case utility //公共的 case `default` //默认的 case userInitiated //用户期望优先级(不要放太耗时的操作) case userInteractive //用户交互(跟主线程一样) case unspecified //不指定 */ //2. myQueue = DispatchQueue(label: "第二条线程", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
创建好的队列执行任务
myQueue?.sync(execute: { print("执行同步任务") }) myQueue?.async(execute: { print("执行异步任务") })
串行执行队列
myQueue?.async { for _ in 0...10 { print("aaaaaaa"); } } myQueue?.async { for _ in 0...10 { print("bbbbbbb"); } }
接下来是GCD常用的用法
开线程异步执行完耗时代码返回主线程刷新UI
func GCDTest2() { /**1. 开线程异步执行完耗时代码返回主线程刷新UI*/ DispatchQueue.global().async { print("开一条全局队列异步执行任务") DispatchQueue.main.async { print("在主队列执行任务") } } }
2.等待异步执行多个任务后, 再执行下一个任务
/**2. 等待异步执行多个任务后, 再执行下一个任务*/ func GCDTest3() { myQueue?.async {//任务一 for _ in 0...10 { print("......") } } myQueue?.async {//任务二 for _ in 0...10 { print("++++++"); } } // barrier 会等待上面执行完毕再执行下面的,会阻塞当前线程 // myQueue?.async(flags:.barrier ,execute: {//1. // print("000000") // }) myQueue?.async(group: nil, qos: .default, flags: .barrier, execute: {//2. print("000000") }) myQueue?.async { print("111111") } /* 打印的结果 ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... ++++++ ...... 000000 111111 */ }
延时提交任务
func GCDTest4() { //主队列 DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 10) { print("延时提交的任务") } //指定队列 myQueue?.asyncAfter(deadline: DispatchTime.now() + 10, execute: { print("延时提交的任务") }) }
信号量:
func GCDTest5() { //初始化信号量, 计数为三 let mySemaphore = DispatchSemaphore(value: 3) for i in 0...10 { print(i) // let _ = mySemaphore.wait() //获取信号量,信号量减1,为0时候就等待,会阻碍当前线程 let _ = mySemaphore.wait(timeout: DispatchTime.now() + 2.0) //阻碍时等两秒信号量还是为0时将不再等待, 继续执行下面的代码 myQueue?.async { for j in 0...4 { print("有限资源\(j)") sleep(UInt32(3.0)) } print("-------------------") mySemaphore.signal() } } }
信号量的说明:
GCD 信号量控制并发 (dispatch_semaphore)
当我们在处理一系列线程的时候,当数量达到一定量,在以前我们可能会选择使用NSOperationQueue来处理并发控制,但如何在GCD中快速的控制并发呢?答案就是dispatch_semaphore。
信号量是一个整形值并且具有一个初始计数值,并且支持两个操作:信号通知和等待。当一个信号量被信号通知,其计数会被增加。当一个线程在一个信号量上等待时,线程会被阻塞(如果有必要的话),直至计数器大于零,然后线程会减少这个计数。
在GCD中有三个函数是semaphore的操作,分别是:
1、dispatch_semaphore_create 创建一个semaphore
2、dispatch_semaphore_signal 发送一个信号
3、dispatch_semaphore_wait 等待信号
下面我们逐一介绍三个函数: (1)dispatch_semaphore_create的声明为: dispatch_semaphore_t dispatch_semaphore_create(long value); 传入的参数为long,输出一个dispatch_semaphore_t类型且值为value的信号量。值得注意的是,这里的传入的参数value必须大于或等于0,否则dispatch_semaphore_create会返回NULL。 (2)dispatch_semaphore_signal的声明为: long dispatch_semaphore_signal(dispatch_semaphore_t dsema)这个函数会使传入的信号量dsema的值加1;(至于返回值,待会儿再讲) (3) dispatch_semaphore_wait的声明为: long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); 这个函数会使传入的信号量dsema的值减1。这个函数的作用是这样的,如果dsema信号量的值大于0,该函数所处线程就继续执行下面的语句,并且将信号量的值减1;如果desema的值为0,那么这个函数就阻塞当前线程等待timeout(注意timeout的类型为dispatch_time_t,不能直接传入整形或float型数),如果等待的期间desema的值被dispatch_semaphore_signal函数加1了,且该函数(即dispatch_semaphore_wait)所处线程获得了信号量,那么就继续向下执行并将信号量减1。如果等待期间没有获取到信号量或者信号量的值一直为0,那么等到timeout时,其所处线程自动执行其后语句。 (4)dispatch_semaphore_signal的返回值为long类型,当返回值为0时表示当前并没有线程等待其处理的信号量,其处理的信号量的值加1即可。当返回值不为0时,表示其当前有(一个或多个)线程等待其处理的信号量,并且该函数唤醒了一个等待的线程(当线程有优先级时,唤醒优先级最高的线程;否则随机唤醒)。 dispatch_semaphore_wait的返回值也为long型。当其返回0时表示在timeout之前,该函数所处的线程被成功唤醒。当其返回不为0时,表示timeout发生。 (5)关于信号量,一般可以用停车来比喻。 停车场剩余4个车位,那么即使同时来了四辆车也能停的下。如果此时来了五辆车,那么就有一辆需要等待。信号量的值就相当于剩余车位的数目,dispatch_semaphore_wait函数就相当于来了一辆车,dispatch_semaphore_signal就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了(dispatch_semaphore_create(long value)),调用一次dispatch_semaphore_signal,剩余的车位就增加一个;调用一次dispatch_semaphore_wait剩余车位就减少一个;当剩余车位为0时,再来车(即调用dispatch_semaphore_wait)就只能等待。有可能同时有几辆车等待一个停车位。有些车主没有耐心,给自己设定了一段等待时间,这段时间内等不到停车位就走了,如果等到了就开进去停车。而有些车主就像把车停在这,所以就一直等下去。
重复提交任务(定时器)
func GCDTest6() { // 秒 毫秒 微秒 纳秒 // 1 seconds = 1000 milliseconds = 1000,000 microseconds = 1000,000,000 nanoseconds myTimer = DispatchSource.makeTimerSource(flags: [], queue: myQueue) myTimer?.scheduleRepeating(deadline: .now(), interval: .seconds(1) ,leeway:.milliseconds(100)) myTimer?.setEventHandler { print("fff") } myTimer?.resume() // myTimer?.cancel() // myTimer?.activate() }
接下来就是Group的用法
notify(依赖任务)//MARK: - notify(依赖任务) func GCDTest7() { let group = DispatchGroup() myQueue?.async(group: group, qos: .default, flags: [], execute: { for _ in 0...10 { print("耗时任务一") } }) myQueue?.async(group: group, qos: .default, flags: [], execute: { for _ in 0...10 { print("耗时任务二") } }) //执行完上面的两个耗时操作, 回到myQueue队列中执行下一步的任务 group.notify(queue: myQueue!) { print("回到该队列中执行") } }
2 . wait(任务等待)
func GCDTest8() { let group = DispatchGroup() myQueue?.async(group: group, qos: .default, flags: [], execute: { for _ in 0...10 { print("耗时任务一") } }) myQueue?.async(group: group, qos: .default, flags: [], execute: { for _ in 0...10 { print("耗时任务二") sleep(UInt32(3)) } }) //等待上面任务执行,会阻塞当前线程,超时就执行下面的,上面的继续执行。可以无限等待 .distantFuture let result = group.wait(timeout: .now() + 2.0) switch result { case .success: print("不超时, 上面的两个任务都执行完") case .timedOut: print("超时了, 上面的任务还没执行完执行这了") } print("接下来的操作") }
3. enter leave 手动管理group计数,enter和leave必须配对
func GCDTest9() { let group = DispatchGroup() group.enter()//把该任务添加到组队列中执行 myQueue?.async(group: group, qos: .default, flags: [], execute: { for _ in 0...10 { print("耗时任务一") group.leave()//执行完之后从组队列中移除 } }) group.enter()//把该任务添加到组队列中执行 myQueue?.async(group: group, qos: .default, flags: [], execute: { for _ in 0...10 { print("耗时任务二") group.leave()//执行完之后从组队列中移除 } }) //当上面所有的任务执行完之后通知 group.notify(queue: .main) { print("所有的任务执行完了") } }
最后来说说dispatch_set_target_queue的具体用法
首先这个OC中的API在Swift中已经发生变化,具体请看下图:
可以看到更新后的API,那么这个方法到底有什么用呢?
(一),使用dispatch_set_target_queue更改Dispatch Queue的执行优先级
dispatch_queue_create函数生成的DisPatch Queue不管是Serial DisPatch Queue还是Concurrent Dispatch Queue,执行的优先级都与默认优先级的Global Dispatch queue相同,如果需要变更生成的Dispatch Queue的执行优先级则需要使用dispatch_set_target_queue函数
func GCDTest10() { let serialQueue = DispatchQueue(label: "testQueue") //设置优先级的队列 let globalQueue = DispatchQueue.global() // 参照队列 serialQueue.setTarget(queue: globalQueue) // 将两个队列的优先级设置为一致 }
(二),使用dispatch_set_target_queue修改用户队列的目标队列,使多个serial queue在目标queue上一次只有一个执行
首先,我们需要阐述一下生成多个Serial DisPatch Queue时的注意事项
Serial DisPatch Queue是一个串行队列,只能同时执行1个追加处理(即任务),当用Dispatch_queue_create函数生成多个Serial DisPatch Queue时,每个Serial DisPatch Queue均获得一个线程,即多个Serial DisPatch Queue可并发执行,同时处理添加到各个Serial DisPatch Queue中的任务,但要注意如果过多地使用多线程,就会消耗大量内存,引起大量的上下文切换,大幅度降低系统的响应性能,所以我们只在为了避免多个线程更新相同资源导致数据竞争时,使用Serial DisPatch Queue
第一种情况:使用dispatch_set_target_queue(Dispatch Queue1, Dispatch Queue2)实现队列的动态调度管理
func GCDTest11() {
// 创建串行队列1
let serialQueue1 = DispatchQueue(label: "queue1")
// 创建串行队列2
let serialQueue2 = DispatchQueue(label: "queue2")
// 使用setTarget实现队列的动态调度管理
serialQueue1.setTarget(queue: serialQueue2)
// 此时,serialQueue1上还未运行的block会在serialQueue2上运行,这时如果暂停serialQueue1运行:
// serialQueue1.suspend()
// 这时只会暂停serialQueue1上原来的block的执行,serialQueue2的block不受影响,而如果暂停serialQueue2的运行,则会暂停serialQueue1的运行
// 另外DispatchQueue不支持cancel,没有实现dispatch_cancel,不想NSOperationQUeue,这可以说是个小缺憾。。。
serialQueue1.async {
for i in 0..<10 {
print("serialQueue1:\(Thread.current)\(i)")
Thread.sleep(forTimeInterval: 0.5)
if i == 5 {
serialQueue1.suspend()
}
}
}
serialQueue1.async {
for i in 0..<100 {
print("serialQueue1:\(Thread.current)\(i)")
}
}
serialQueue2.async {
for i in 0..<100 {
print("serialQueue2:\(Thread.current)\(i)")
}
}
}
第二种情况:使用dispatch_set_target_queue将多个串行的queue指定到了同一目标,那么着多个串行queue在目标queue上就是同步执行的,不再是并行执行。
func GCDTest12() {
// 创建目标队列
let targetQueue = DispatchQueue(label: "test.target.queue")
// 创建三个串行队列
let queue1 = DispatchQueue(label: "test.1")
let queue2 = DispatchQueue(label: "test.2")
let queue3 = DispatchQueue(label: "test.3")
// 将三个串行队列分别添加到目标队列
queue1.setTarget(queue: targetQueue)
queue2.setTarget(queue: targetQueue)
queue3.setTarget(queue: targetQueue)
queue1.async {
print("1 in")
Thread.sleep(forTimeInterval: 3.0)
print("1 out")
}
queue2.async {
print("2 in")
Thread.sleep(forTimeInterval: 2.0)
print("2 out")
}
queue3.async {
print("3 in")
Thread.sleep(forTimeInterval: 1.0)
print("3 out")
}
}
以上就是个人对swift 3.0 GCD 的理解. 欢迎大家留言补充.
相关文章推荐
- 八 Swift3.0之 字符串常用方法
- Swift3 GCD的基本用法(二) - 队列的循环/挂起/恢复、其他常用方法
- iOS GCD集汇(三)GCD常用方法总结
- GCD 延时方法 (Swift)
- swift 字典常用方法
- [IOS 开发] GCD常用方法
- 多线程的常用方法及GCD
- 善用 C# 3.0 Extensions 方法 -- 以及常用辅助方法集
- swift UIView常用添加方法
- swift UIView常用添加方法
- ios GCD一些常用的方法
- GCD常用方法
- Swift中的GCD——常见的dispatch方法
- GCD常用方法
- swift 字典常用方法
- iOS 开发中,多线程编程GCD的常用方法总结
- GCD常用方法
- iOS-线程之GCD---之GCD的几种常用常用的方法
- GCD一些常用的方法
- GCD的常用方法