GCD的基础用法

什么是GCD?

全称Grand Center Dispatch，是纯C语言的，提供了非常强大的函数，是苹果公司为了解决多核的并行运算而推出的。
优点：
1.自动利用更多的CPU内核
2.自动管理线程的生命周期
3.使用简单(确定想要做的事情(任务)，然后添加到队列，按照指定的同步、异步方式执行，CGD会自动将队列中的任务取出放到对应的线程中执行，任务的取出遵循FIFO原则，先进先出)

核心概念：
1.任务：需要执行的事情
2.队列：存放任务的集合

基础用法

队列、函数知识点

串行队列：一个接一个的调度任务
并发队列：可以同时调度多个任务
主队列：全局串行队列，由主线程串行调度任务，并且只有一个
全局队列：没有名称的并发队列

同步执行(sync)：当前指令不完成，就不会执行下一条指令，不会开启新线程
异步执行(async)：当前指令不完成，同样可以执行下一条指令，会开启新线程

注意点：
主队列+ 同步执行 会产生死锁

创建队列

/// 创建串行队列
// OC
- (void)creatSerialQueue {
    /**
     label: 队列标识
     dispatch_queue_attr_t: 队列属性，DISPATCH_QUEUE_SERIAL串行，DISPATCH_QUEUE_CONCURRENT并行
     */
    dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(serialQueue, ^{
        NSLog(@"任务1");
        // 睡3秒
        [NSThread sleepForTimeInterval:3.0];
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"任务2");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"任务3");
    });
}

// Swift
func creatSerialtQueue() -> () {
        // 默认初始化方法创建的就是一个串行队列
        let serialQueue = DispatchQueue(label: "serialQueue")
        serialQueue.async {
            print("任务1")
            // 睡3秒
            sleep(3)
        }
        serialQueue.async {
            print("任务2")
        }
        serialQueue.async {
            print("任务3")
        }
    }

虽然有sleep 3秒但是依然会等待、按顺序执行
2017-04-03 11:04:21.441 OC-GCD测试[1943:158578] 任务1
2017-04-03 11:04:24.446 OC-GCD测试[1943:158578] 任务2
2017-04-03 11:04:24.446 OC-GCD测试[1943:158578] 任务3

/// 创建并行队列
// OC
- (void)creatConcurrentQueue {
    dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(concurrentQueue, ^{
        NSLog(@"任务1");
        // 睡3秒
        [NSThread sleepForTimeInterval:3.0];
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"任务2");
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"任务3");
    });
}

// Swift
func creatConcurrentQueue() -> () {
        // 创建并发的队列，在attributes中声明concurrent
        let concurrentQueue = DispatchQueue(label: "concurrentQueue", attributes: DispatchQueue.Attributes.concurrent)
        concurrentQueue.async {
            print("任务1")
            // 睡3秒
            sleep(3)
        }
        concurrentQueue.async {
            print("任务2")
        }
        concurrentQueue.async {
            print("任务3")
        }
    }

sleep 3秒不会等待、并发执行
2017-04-03 11:01:26.550 OC-GCD测试[1897:154504] 任务2
2017-04-03 11:01:26.550 OC-GCD测试[1897:154507] 任务1
2017-04-03 11:01:26.550 OC-GCD测试[1897:154505] 任务3

同步执行(不会开启线程)

// OC
- (void)synTest {
    // 获取一个全局队列
    dispatch_queue_t queque = dispatch_get_global_queue(0, 0);
    
    // 创建一个任务
    void(^task)() = ^() {
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    };
    
    // 执行任务
    dispatch_sync(queque, task);
}

// Swift
func synTest() -> () {
        // 获取一个全局队列
        let queue = DispatchQueue.global()
        
        // 创建一个任务
        let task = {
            print("当前线程：\(Thread.current)")
        }
        
        // 执行任务
        queue.sync(execute: task)
    }

控制台输出结果(同步不具备开启线程的能力，在当前线程(主线程)执行，所以输出number = 1, name = main

<NSThread: 0x6000000770c0>{number = 1, name = main}

异步执行(会开启新的线程)

// OC
- (void)asynTest {
    // 获取一个全局队列
    dispatch_queue_t queque = dispatch_get_global_queue(0, 0);
    
    // 创建一个任务
    void(^task)() = ^() {
        NSLog(@"当前线程：%@", [NSThread currentThread]);
    };
    
    // 执行任务
    dispatch_async(queque, task);
}

// Swift
func asynTest() -> () {
        // 获取一个全局队列
        let queue = DispatchQueue.global()
        
        // 创建一个任务
        let task = {
            print("当前线程：\(Thread.current)")
        }
        
        // 执行任务
        queue.async(execute: task)
    }

控制台输出结果(异步会开启新的线程的，所以输出number = 3, name = (null)

<NSThread: 0x608000267440>{number = 3, name = (null)}

异步拉回主线程

// OC
- (void)mainQueueTest {
   // 获取全局队列
   dispatch_queue_t globalQueueue = dispatch_get_global_queue(0, 0);
   dispatch_async(globalQueueue, ^{
       NSLog(@"异步执行操作");
       [NSThread sleepForTimeInterval:3];
       
       // 获取主队列
       dispatch_queue_t mainQueueue = dispatch_get_main_queue();
       dispatch_async(mainQueueue, ^{
           NSLog(@"拉回主线程更新UI");
       });
   });
}

// Swift
func mainQueueTest() -> () {
       DispatchQueue.global().async {
           print("异步执行操作")
           sleep(3)
           DispatchQueue.main.async {
               print("拉回主线程更新UI")
           }
       }
   }