Swift 3.0中GCD的常用方法_swift group.notify主动退出

随着苹果推出swift3.0，很多API都发生了变化，下面我就来总结下GCD的一些常用API用法。

首先为了方便先定义几个属性：

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常用的用法

1. 开线程异步执行完耗时代码返回主线程刷新UI

func GCDTest2() {
 /**1. 开线程异步执行完耗时代码返回主线程刷新UI*/
     DispatchQueue.global().async {
         print("开一条全局队列异步执行任务")

         DispatchQueue.main.async {
             print("在主队列执行任务")
         }
     }
 }

/**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的用法

1. 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("回到该队列中执行")
     }

 }

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

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)")
            }
        }
        
    }

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")
        }
    }