int main(int argc, const char *argv[]) {
    //代码添加到autoreleasepool中，使用dispatch_get_global_queue系统会优化线程的创建与分配
    @autoreleasepool {
        
        //验证：dispatch_sync不会阻塞全局队列的执行流
        dispatch_queue_t glb_q = dispatch_get_global_queue(0, 0);
        dispatch_sync(glb_q, ^{ //a添加到全局队列异步执行，
            NSLog(@"a dispatch_sync 调用内部,线程：%@", NSThread.currentThread);
            dispatch_sync(glb_q, ^{ //b添加到全局队列异步执行，
                NSLog(@"b dispatch_sync 调用内部,线程：%@", NSThread.currentThread);
            });
        });
        
        /* 下面第1个数字表示执行流顺序；m表示主队列,g表示全局队列,后面的数字表示任务在队列中的位置,
         如:m2表示主队列中的第2个任务；t表示线程,t1表示主线程,t2表示其他线程。
         */
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"2_m2_t1. dispatch_async 调用内部,线程：%@", NSThread.currentThread);
        });
        NSLog(@"1_m1_t1. dispatch_async 调用后,线程：%@", NSThread.currentThread);
        [NSRunLoop.currentRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];

        dispatch_queue_t global_q = dispatch_get_global_queue(0, 0);
        dispatch_sync(global_q, ^{
            NSLog(@"3_g1_t1. dispatch_sync 调用内部,线程：%@", NSThread.currentThread);
            //因当前主线程已经加了同步锁，所以这里添加任务到主队列只能才采用异步方式添加
            dispatch_async(dispatch_get_main_queue(), ^{ 
                NSLog(@"6_m4_t1. dispatch_async 调用内部,线程：%@", NSThread.currentThread);
            });

            dispatch_async(global_q, ^{ //t7添加到全局队列异步执行
                NSLog(@"7_g3_t2. dispatch_sync 调用内部,线程：%@", NSThread.currentThread);
            });
            dispatch_sync(global_q, ^{
                NSLog(@"4_g2_t1. dispatch_sync 调用内部,线程：%@", NSThread.currentThread);
            });
        });

        dispatch_async(global_q, ^{
            //因为t7与t8都在同一个队列上，并且t7早于t8加入队列，所以如果t7与t8分本在同一个线程上的话，t7会早于t8执行；
            NSLog(@"8_g4_t2. dispatch_sync 调用内部,线程：%@", NSThread.currentThread);
        });
        NSLog(@"5_m3_t1. dispatch_sync 调用后,线程：%@", NSThread.currentThread);

        [NSRunLoop.currentRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
        
    }
    return 0;
}

dispatch_get_main_queue() //取主队列
dispatch_get_global_queue() //取全局队列,第1个参数是线程执行的优先级,第2个参数是预留参数0
dispatch_queue_create() //创建队列,第1个参数标签名,第2个参数NULL表示创建串行队列,DISPATCH_QUEUE_CONCURRENT表示创建并行队列

dispatch_async() //异步执行,即在队列里追加一个block对象的任务,不阻塞当前队列的执行流；
dispatch_sync() //同步执行,即在当主队列追加一个block对象的任务,会阻塞主队列的执行流；
dispatch_after() //延后执行
dispatch_once()  //只执行一次
dispatch_apply() //迭代执行指定次数
dispatch_barrier_async() //插入栅栏后异步执行任务
dispatch_barrier_sync()  //插入栅栏后同步执行任务

dispatch_group_create()  //创建调度组
dispatch_group_async()   //向调度组队列里添加任务
dispatch_group_enter()   //每次调用后任务向调度组列队里添加1次,并且计数+1；
dispatch_group_leave()   //每次调用后把在调度组列队里的任务计数计数-1,减到0时从队列里移出任务；
dispatch_group_notify()  //调度组列队中的任务全部执行完后通知block执行
dispatch_group_wait()    //等待整个调度组所有任务执行完

//dispatch_semaphore_t对象,参数value用于初始化 semaphore.count;
//semaphore.count小于等于0会阻塞当前线程；
dispatch_semaphore_create() 
dispatch_semaphore_wait()  //p操作,对dsema进行原子性的-1,阻塞
dispatch_semaphore_signal() //V操作,对dsema进行原子性+1,唤醒

dispatch_source_create()
dispatch_source_set_timer()
dispatch_source_set_event_handler()
dispatch_resume()
dispatch_suspend()
dispatch_source_cancel()
dispatch_source_testcancel()
dispatch_source_set_cancel_handler()

int main(int argc, const char *argv[]) {
    @autoreleasepool {
        dispatch_queue_t main_q = dispatch_get_main_queue();
        dispatch_queue_t global_q = dispatch_get_global_queue(0, 0);
        dispatch_group_t group = dispatch_group_create();

        dispatch_group_async(group, global_q, ^{NSLog(@"dispatch_async block 1"); });
        dispatch_group_async(group, global_q, ^{NSLog(@"dispatch_async block 2"); });
        dispatch_group_async(group, global_q, ^{NSLog(@"dispatch_async block 3"); });

        //只有当调用组group中的队列global_q的任务都处理完了，才会通知执行以下的这个block
        dispatch_group_notify(group, global_q, ^{NSLog(@"Done!"); });

        dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 800ull * NSEC_PER_MSEC));
        NSLog(@"dispatch_group_wait 后");


        //使用 dispatch_after 让 block1 在1秒后执行
        dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull * NSEC_PER_SEC);
        dispatch_block_t block1 = ^{NSLog(@"dispatch_after 1秒后 block1"); };
        dispatch_after(time, main_q, block1 );


        //dispatch_block_wait 用于判断block执行是否超出指定时间
        dispatch_async(dispatch_queue_create("ab.d", DISPATCH_QUEUE_CONCURRENT), ^{
            dispatch_block_t block2 = dispatch_block_create(0,^{
                NSLog(@"block2 开始执行");
                [NSThread sleepForTimeInterval:2];
                NSLog(@"block2 结束执行");
            });
            dispatch_async(global_q,block2);
            dispatch_time_t t2 = dispatch_time(DISPATCH_TIME_NOW, 1ull * NSEC_PER_SEC);
            //dispatch_block_wait 会阻塞当前线程,并判断block2 在 t2时间内是否已执行完毕；
            //dispatch_block_wait 只能作用在使用dispatch_block_create创建的block上；
            if (dispatch_block_wait(block2, t2) == 0) {
                NSLog(@"block2 执行成功");
            } else {
                NSLog(@"block2 执行超时");
            }
        });

        [NSRunLoop.currentRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:5]];
    }
}

dispatch_async block 2
dispatch_async block 1
dispatch_async block 3
Done!
dispatch_group_wait 后
block2 开始执行
block2 执行超时
dispatch_after 1秒后 block1
block2 结束执行

int main(int argc, const char *argv[]) {
    @autoreleasepool {
        dispatch_queue_t q = dispatch_queue_create("ab.c", DISPATCH_QUEUE_CONCURRENT);

        dispatch_async(q, ^{NSLog(@"a reading 1");});
        dispatch_async(q, ^{NSLog(@"a reading 2");});
        dispatch_async(q, ^{NSLog(@"a reading 3");});
        dispatch_barrier_async(q, ^{NSLog(@"a writing");});
        dispatch_async(q, ^{NSLog(@"a reading 4");});
        dispatch_async(q, ^{NSLog(@"a reading 5");});
        dispatch_async(q, ^{NSLog(@"a reading 6");});

        dispatch_sync(q, ^{NSLog(@"b reading 1");});
        dispatch_sync(q, ^{NSLog(@"b reading 2");});
        dispatch_sync(q, ^{NSLog(@"b reading 3");});
        dispatch_barrier_sync(q, ^{NSLog(@"dispatch_barrier_sync: b writing");});
        dispatch_sync(q, ^{NSLog(@"b reading 4");});
        dispatch_sync(q, ^{NSLog(@"b reading 5");});
        dispatch_sync(q, ^{NSLog(@"b reading 6");});

        //在q队列里同步迭代block任务5次
        dispatch_apply(5, q, ^(size_t it){NSLog(@"dispatch_apply %zu",it);});
        NSLog(@"Done");

        //下面模拟飞机起飞
        dispatch_queue_t q1 = dispatch_queue_create("ab.d", DISPATCH_QUEUE_CONCURRENT);
        dispatch_async(q1, ^{NSLog(@"准备");});
        dispatch_async(q1, ^{
            [NSThread sleepForTimeInterval:1];
            NSLog(@"收起落架");
            dispatch_resume(q1);
        });
        dispatch_suspend(q1); //挂起q1队列,让q1无法添加任务
        dispatch_async(q1, ^{NSLog(@"起飞");});

        for(int i=0;i<10;i++){
            static dispatch_once_t predicate;
            dispatch_once(&predicate, ^{
                NSLog(@"dispatch_once %i",i);
            });
        }

        [NSRunLoop.currentRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:5]];
    }
    return 0;
}

__block BOOL isSuccess = NO;
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
        isSuccess = YES;
        dispatch_semaphore_signal(semaphore);
    }];
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

//创建dispatch source
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,0, 0, dispatch_get_main_queue());
if (timer){
    uint64_t interval = 1ull * NSEC_PER_SEC;
    uint64_t leeway = 1ull * NSEC_PER_SEC;
     dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), interval,leeway);
     dispatch_source_set_event_handler(timer, ^{
         NSLog(@"===== timer");
     });
     dispatch_resume(timer);
 }

[NSRunLoop.currentRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:5]];