GCD的简单学习

GCD，全称 Grand Central Dispatch，异步执行任务技术之一，开发者只需要定义想执行的任务并追加到适当的 Dispatch Queue 中。GCD就能生成必要的线程并执行计划任务。用于解决需要长时间处理的任务会阻塞主线程的问题。
“一个CPU执行的CPU命令列为一条无分叉路径”，即线程。

执行任务等待队列 Dispatch Queue，分为两种，一种是等待现在执行中处理的 Serial Dispatch Queue，另一种是不等待现在执行中处理的 Concurrent Dispatch Queue。在不能改变执行的处理顺序或者是不想并行执行多个处理时使用 Serial Dispatch Queue。

创建 Dispath Queue
1.通过 dispatch_queue_create 创建 Dispatch Queue：
该函数有两个参数，第一个参数指定 Dispatch Queue 的名称，推荐使用应用程序ID这种逆序全程域名（FQDN）；第二个参数为 Dispatch Queue的类型，如果需要创建的Queue为 Serial Dispatch Queue，这个参数指定为NULL，如果需要创建的Queue为 Concurrent Dispatch Queue，这个参数指定为 DISPATCH_QUEUE_CONCURRENT。该函数返回值类型为dispatch_queue_t类型。

//创建Dispath Queue
    dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.MySerialDispatchQueue", NULL);
    
    dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.example.MyConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(mySerialDispatchQueue, ^{
        NSLog(@"this is a Serial Dispatch Queue");
    });
    
    dispatch_async(myConcurrentDispatchQueue, ^{
         NSLog(@"this is a Concurrent Dispatch Queue");
    });
    
    //释放Dispath Queue，在iOS6.0 之后不需要自己手动释放。
    //dispatch_release(mySerialDispatchQueue);
    //dispatch_release(myConcurrentDispatchQueue);

iOS 6.0 之前，在queue使用结束后需要使用 dispatch_release（）将其释放。在iOS6.0 之后不需要自己手动释放

2.获取系统标准提供的 Dispatch Queue：
系统提供了标准的Dispatch Queue，Main Dispatch Queue 和 Global Dispatch Queue。其中前者的处理在主线程的RunLoop中执行，界面更新等一些操作必须追加到Main Dispatch Queue 使用。后者是所有程序都可以使用的Concurrent Dispatch Queue，无需通过dispatch_queue_create 函数逐个生成Concurrent Dispatch Queue。只要获取 Global Dispatch Queue就可以了。
获取 Global Dispatch Queue 时第一个参数为queue的优先级，Global Dispatch Queue 有四个执行优先级，分别为高优先级（High Priority），默认优先级（Default Priority），低优先级（Low Priority）和后台优先级（Background Priority）。

 /*
    //获取 Main Dispatch Queue
    dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
    //获取 Global Dispatch Queue
    dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     */
    
    //在默认优先级的 Global Dispatch Queue 中执行 Block
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //可并行执行的处理
        
        
        //返回Main Dispatch Queue 中执行Block
        dispatch_async(dispatch_get_main_queue(), ^{
            
            //只能在主线程中执行的处理
        });
    });

变更 Dispath Queue 的优先级
使用 dispatch_queue_create 生成的 Dispatch Queue 和使用 Default Priority 的 Global Dispatch Queue 拥有相同的执行优先级，如果想变更 Dispatch Queue 的优先级，需要使用 dispatch_set_target_queue 函数。该函数使第一个 Dispatch Queue 的优先级等同于第二个 Dispatch Queue。但是系统提供的 Main Dispatch Queue 和 Global Dispatch Queue 的优先级是不可变更的。

 dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.MySerialDispatchQueue", NULL);
    
    dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

    //使 mySerialDispatchQueue 的优先级等同于 globalDispatchQueue
    dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueue);

延时
当想要在若干时间后执行某处理，可以使用 dispatch_after 函数来实现。dispatch_after 函数并不是在指定时间后执行处理，而是在指定时间后追加处理到 Dispatch Queue。该函数有三个参数，第一个参数为时间，类型为 dispatch_time_t；第二个参数为指定追加处理的 Dispatch Queue；第三个函数为需要执行处理的 Block。
dispatch_time 通常用于计算相对时间，dispatch_walltime 函数通常用于计算绝对时间,其需要使用一个 timespec的结构体来得到 dispatch_time_t。

 dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
    
    //第一个参数是一个结构体, 创建的是一个绝对的时间点,比如 XX年XX月XX日XX点XX分XX秒, 如果不需要自某一个特定的时刻开始,可以传 NUll,表示自动获取当前时区的当前时间作为开始时刻,
    dispatch_time_t time1 = dispatch_walltime(NULL, 3 * NSEC_PER_SEC);
    
    dispatch_after(time, dispatch_get_main_queue(), ^{
        NSLog(@"waited at least three seconds ");
    });
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"waited at least three seconds ");
    });

Dispatch Group
想要实现在追加到 Dispatch Queue 中的多个处理全部结束后再执行结束处理的情况，如果使用的是一个 Serial Dispatch Queue，那么只要将想执行的处理全部追加到 Serial Dispatch Queue 的最后就可以实现了。但是如果使用的是 Concurrent Dispatch Queue，就需要使用 Dispatch Group。使用 dispatch_group_notify()确保是最后执行的。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"this is the first block");
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"this is the second block");
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"this is the third block");
    });
    
    dispatch_group_notify(group, queue, ^{
        NSLog(@"done");
    });

另外也可以使用 dispatch_group_wait 函数等待全部处理执行结束。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"this is the first block");
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"this is the second block");
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"this is the third block");
    });
    
    //等待直到全部处理执行结束，result一定为0
    long result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    if(result == 0){
        //属于Dispatch Group 的处理全部执行结束
        NSLog(@"done");
        
    }else{
        //属于Dispatch Group 的某一个处理还未结束
    }
    

这个场景经常在面试中被问到，除了上述方法外还可以使用NSOperation，通过添加依赖确保执行顺序。

dispatch_barrier_async
在访问数据库或者文件时，常使用 Serial Dispatch Queue 避免数据竞争的问题。写入处理不可以和其他写入处理并行执行，但是读取处理却可以与其他读取处理并行执行。即为了高效率的进行访问，读取处理追加到Concurrent Dispatch Queue中，而写入处理在没有读取处理执行的状态下，追加到Serial Dispatch Queue 中。此情况下，可以使用 dispatch_barrier_async 函数来解决。

 dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.readandwrite", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{NSLog(@"reader 1");});
    dispatch_async(queue, ^{NSLog(@"reader 2");});
    dispatch_async(queue, ^{NSLog(@"reader 3");});
    dispatch_async(queue, ^{NSLog(@"reader 4");});
    dispatch_barrier_async(queue, ^{NSLog(@"wirter");});
    dispatch_async(queue, ^{NSLog(@"reader 5");});
    dispatch_async(queue, ^{NSLog(@"reader 6");});
    dispatch_async(queue, ^{NSLog(@"reader 7");});
    dispatch_async(queue, ^{NSLog(@"reader 8");});

执行结果为reader1234随机顺序输出，之后输出writer，后面reader5678随机顺序输出。

dispatch_apply
该函数按指定次数将制定的 Block 追加到指定的 Dispatch Queue 中，并等待全部处理执行结束。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_apply(10, queue, ^(size_t index) {
        NSLog(@"%zu", index);
    });
    NSLog(@"Done");

此外常用的API还有：
dispatch_suspend：挂起指定的Dispatch Queue
dispatch_resume：恢复指定的Dispatch Queue
dispatch_once：该函数保证应用程序中只执行一次，经常用于初始化源代码。单例模式。

static Example *example = NULL;
static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{
    example = [[Example alloc] init];
});