GCD简单使用

延迟调用(dispatch_after)

//系统定义
typedef uint64_t dispatch_time_t;
typedef unsigned long long uint64_t;

//dispatch_time(dispatch_time_t when, int64_t delta)

    /*
     *  获取某一个时间点
     *
     *  @param when    参照时间   DISPATCH_TIME_NOW = 当前时间点
     * 
     *  @param delta   时间差,单位纳秒  NSEC_PER_SEC = 1秒 NSEC_PER_MSEC = 1毫秒 NSEC_PER_USEC = 1微秒
     * 
     *  @return 时间点
     */
     //time:延迟时间
     //dispatch_get_main_queue() 在哪个队列里延迟
    dispatch_after(time, dispatch_get_main_queue(), ^{

        ... ...
    });
    //performSelector延迟
    [self performSelector:@selector(test1) withObject:nil afterDelay:3];

     dispatch_after 和 performSelector:withObject:afterDelay: 的区别
     1. 调用方式，前者使用block形式来调用，后者只能使用Selector
     2. 后者能够通过cancel来取消还未开始的方法，但是dispatch_after需要通过非常复杂的方法才能够来取消延迟任务。
     3. dispatch_after的精确度比后者高很多

设置队列优先级(dispatch_set_target_queue)

    //创建三个队列
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", NULL);
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", NULL);
    dispatch_queue_t queue3 = dispatch_queue_create("queue3", NULL);
    //创建参照队列
    dispatch_queue_t queue4 = dispatch_queue_create("queue4", DISPATCH_QUEUE_CONCURRENT);
    //将三个队列的优先级，设置为和参照队列的优先级相同,若是目标队列为并发队列,则三个队列并发执行
    dispatch_set_target_queue(queue1, queue4);
    dispatch_set_target_queue(queue2, queue4);
    dispatch_set_target_queue(queue3, queue4);

队列挂起与恢复(dispatch_suspend dispatch_resume)

//将队列处于悬停状态，对悬停时已开始执行的任务无效,悬停时未执行的任务将会悬停
    dispatch_queue_t queue4 = dispatch_queue_create("queue4", DISPATCH_QUEUE_SERIAL);
    //队列挂起
    dispatch_suspend(queue4);
    //任务恢复一般与队列延迟调用合用,第二个参数为要恢复的队列所在的队列,下面设置的是主队列
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC*5), dispatch_get_main_queue(), ^{
        dispatch_resume(queue4);
    });

一次任务(dispatch_once)多用于单例对象

//选择这个,这是一整个代码快,将只执行一次的代码放进去即可
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            <#code to be executed once#>
        });

以下是代码示例

//静态变量只被初始化一次
static Person *p;
//自定义单例方法
+ (instancetype)sharedPerson {
    if (p == nil) {
        //dispatch_once 一次任务多用于单例对象
        //使用dispatch_once执行的代码，在整个程序的运行过程中，一共只能执行一次
        //onceToken 表示执行的标记
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            p = [[super allocWithZone:nil] init];
        });
    }
    return p;
}
//确保进行alloc时也是一个对象
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    if (p == nil) {
        p = [Person sharedPerson];
    }

    return p;
}
//确保复制时也是同一个对象
- (id)copy {
    return self;
}