Swift GCD线程

队列

   //MARK: ---队列---
    func testData() {
        //串行队列的创建方法
         let queue0 = DispatchQueue(label: "test.queue0")
        //并发队列的创建方法
         let queue1 = DispatchQueue(label: "test.queue1", attributes: .concurrent)
    
    }
    
    func testData2() {
        //获取主队列的方法
        let queue = DispatchQueue.main
        //主队列其实并不特殊。
        //主队列的实质上就是一个普通的串行队列，只是因为默认情况下，当前代码是放在主队列中的，
        //然后主队列中的代码，有都会放到主线程中去执行，所以才造成了主队列特殊的现象
     }
    
    func testData3() {
        //获取主队列的方法
        let queue = DispatchQueue.global(qos: .default)
     }

线程组合

   //MARK: ---线程---
   /**
   * 同步执行 + 并发队列
   * 特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
   */
   func syncConcurent() {
       
       let queue1 = DispatchQueue(label: "test.queue1", attributes: .concurrent)
       
       queue1.sync {
           //追加任务1
       }
       
       queue1.sync {
           //追加任务2
       }
       
       queue1.sync {
            //追加任务3
       }
   }
   
   /**
   * 异步执行 + 并发队列
   * 特点：可以开启多个线程，任务交替（同时）执行。
   */
   func asyncConcurrent() {
       let queue1 = DispatchQueue(label: "test.queue1", attributes: .concurrent)
       queue1.async {
           //追加任务1
       }
       
       queue1.async {
           //追加任务2
       }
       
       queue1.async {
            //追加任务3
       }
   }
   
   /**
   * 同步执行 + 串行队列
   * 特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
   */
   func syncSerial() {
       //串行队列的创建方法
       let queue0 = DispatchQueue(label: "test.queue0")

       queue0.sync {
           //追加任务1
       }
       
       queue0.sync {
           //追加任务2
       }
       
       queue0.sync {
           //追加任务3
       }
       
   }
   
   /**
   * 异步执行 + 串行队列
   * 特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。
   */
   func asyncSerial() {
       //串行队列的创建方法
       let queue0 = DispatchQueue(label: "test.queue0")
       
       queue0.async {
           //追加任务1
       }
       
       queue0.async {
           //追加任务2
       }
       
       queue0.async {
           //追加任务3
       }
   }

线程控制

   //MARK: ---线程控制---
   /**
   * 栅栏方法 dispatch_barrier_async
   */
   func barrier() {
       let queue1 = DispatchQueue(label: "test.queue1", attributes: .concurrent)
       queue1.async {
           //追加任务1
       }
       
       queue1.async {
           //追加任务2
       }
       
       queue1.async {
           //追加任务3
       }
       
       queue1.async(group: nil, qos: .default, flags: .barrier) {
           //栏杆方法
       }
       
       queue1.async {
           //追加任务4
       }
       
       queue1.async {
           //追加任务5
       }
       
   }
   
   /**
   * 线程间通信
   */
   func communication() {
       let queue = DispatchQueue.global(qos: .default)
       let mainQueue = DispatchQueue.main
       queue.async {
           // 异步追加任务1
           
           // 回到主线程
           mainQueue.async {
               // 追加在主线程中执行的任务
           }
       }
   }
   
   /**
   * 延时执行方法 dispatch_after
   */
   func after() {
       let queue = DispatchQueue.main
       queue.asyncAfter(deadline: DispatchTime.now() + 1) {
            // 2.0 秒后异步追加任务代码到主队列，并开始执行
       }
       //需要注意的是：dispatch_after
        //方法并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。
        //严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after 方法是很有效的
   }