基于C接口的线程调度。
dispatch_queue_attr_t : 定义一个queue的时候，用于指定queue的类型，queue的类型决定了queue里面的任务执行的顺序
DISPATCH_QUEUE_SERIAL：queue里面的任务由单个线程顺序执行
DISPATCH_QUEUE_CONCURRENT：queue里面的任务并发执行，一般由多个线程负责执行。
DISPATCH_QUEUE_SERIAL_INACTIVE
DISPATCH_QUEUE_CONCURRENT_INACTIVE：INACTIVE结尾的queue，往queue里面派发任务之前，必须先调用dispatch_activate(queue);
DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL
DISPATCH_QUEUE_CONCURRENT_WITH_AUTORELEASE_POOL
dispatch_async VS dispatch_sync
dispatch_async(queue, block);不阻塞当前线程。
dispatch_sync(queue,block);阻塞当前线程，直到任务执行完毕。如果当前线程是主线程，queue又是main_queue，那么主线程会被卡死。
系统提供的两个重要的queue
dispatch_queue_t main_queue = dispatch_get_main_queue(); 主线程维护的全局可用的串行队列，这个队列与主线程的runLoop一起工作。
dispatch_queue_t global_queue = dispatch_get_global_queue(long identifier,unsigned long flags)。
identifer：可以使用qos_class_t中定义的服务质量类或dispatch_queue_priority_t中定义的优先级。
__QOS_ENUM(qos_class, unsigned int,
QOS_CLASS_USER_INTERACTIVE
__QOS_CLASS_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) =0x21,
QOS_CLASS_USER_INITIATED
QOS_CLASS_DEFAULT
QOS_CLASS_UTILITY
QOS_CLASS_BACKGROUND
QOS_CLASS_UNSPECIFIED
);
typedef long dispatch_queue_priority_t;
参数flags：现阶段暂时用不到，一般传 0。
dispatch_time_t：设定一个调度时间。
方法1： dispatch_time_t dispatchTime = dispatch_time(dispatch_time_t when, int64_t delta);
两个特殊的dispatch_time_t。
DISPATCH_TIME_NOW
DISPATCH_TIME_FOREVER
#define NSEC_PER_SEC 1000000000ull // 1s
#define NSEC_PER_MSEC 1000000ull // 1ms
#define USEC_PER_SEC 1000000ull // 1ms
#define NSEC_PER_USEC 1000ull // 1µm
//举例，表示距离现在10秒后时间点
dispatch_time_t newTime = dispatch_time(DISPATCH_TIME_NOW, 10 * NSEC_PER_SEC);
方法2：dispatch_time_t dispatch_walltime(const struct timespec *_Nullable when, int64_t delta);
举个栗子：
NSString * dateString = @"2018-08-08 08:08:08";
NSDateFormatter * formatDate = [[NSDateFormatter alloc] init];
formatDate.dateFormat = @"yyyy-MM-dd HH:mm:ss";
NSDate * yearDate = [formatDate dateFromString:dateString];
NSTimeInterval interval = [yearDate timeIntervalSince1970];
double second, subSecond;
struct timespec time;
// 将浮点数分解为整数和小数
subSecond = modf(interval, &second);
time.tv_sec = second;
time.tv_nsec = subSecond * NSEC_PER_SEC;
dispatch_time_t absoluteTime = dispatch_walltime(&time, 8 * NSEC_PER_SEC);
dispatch做延迟
dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);
dispatch_after函数不是在指定时间后执行某种处理，而只是在指定时间将某种处理追加到Dispatch Queue中，但是不一定是立即执行该处理！
dispatch_group_t:调度组。
GCD提供两种方式支持dispatch并发队列中的任务同步，即dispatch group和dispatch semaphore。
出现背景：并发队列中的多个任务，在线程池里面并发执行的时候，需要知道所有任务执行完成的时机，以便做一些处理。因此，dispatch_group_t一般作用于并发队列。而串行队列单线程顺序执行则不存在这种需求。
dispatch_group_t group =dispatch_group_create();
dispatch_group_async(dispatch_group_t _Nonnull group, dispatch_queue_t _Nonnull cocurentQueue, ^{
});
void dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);：该函数会一直等到组关联的所有任务块都已完成，然后再会将本函数将执行的Block追加到Dispatch Queue中！
int state = dispatch_group_wait(group,dispatch_time(DISPATCH_TIME_NOW,0.000000000001*NSEC_PER_SEC));
group里面的任务执行时间超过timeout后，state返回不为0，但是group里面的任务并没有撤销，而是继续执行。这个state只能反映出任务在timeout的时间内是否能够执行完，而不能够使得超时的任务撤销。
还有两个接口注意下。
下面的两种调用其实是等价的，
A) dispatch_group_async(group, queue, ^{ // 。。。 });
B) dispatch_group_enter(group);
dispatch_async(queue, ^{ //。。。 dispatch_group_leave(group); });
下面是一个例子。
dispatch_group_t newGroup = dispatch_group_create();
dispatch_queue_t queue_change = dispatch_queue_create("com.atx610.NewMTX.concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_async(newGroup, queue_change, ^{
sleep(1);
NSLog(@"test_1");
});
dispatch_group_async(newGroup, queue_change, ^{
NSLog(@"test_2");
});
dispatch_group_enter(newGroup);
dispatch_async(queue_change, ^{
NSLog(@"test_3");
dispatch_group_leave(newGroup);
});
dispatch_group_enter(newGroup);
dispatch_async(queue_change, ^{
sleep(2);
NSLog(@"test_4");
dispatch_group_leave(newGroup);
});
dispatch_group_notify(newGroup, queue_change, ^{
NSLog(@"done,and start new work");
});
// dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
// long result = dispatch_group_wait(newGroup, time);
// if (result == 0) {
// NSLog(@"在设置的时间内，组中的任务全部完成");
// }else{
// NSLog(@"在设置的时间内，组中的任务未全部完成");
// }
调度墙：Dispatch Barrier
应用场景：并发队列中有若干个任务，用户希望这些任务能够分批进行，一批结束，做一些操作或者不做任何操作，接着进行下一批。
注意事项：当提交到全局队列（global queue）或未使用DISPATCH_QUEUE_CONCURRENT属性创建的队列时，Barrier Block与其他任务中的Block的行为相同！
void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block); //异步执行障碍Block
void dispatch_barrier_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);//同步执行障碍Block
与调用次数相关的接口：
void dispatch_apply(size_t iterations, dispatch_queue_t queue, DISPATCH_NOESCAPE void (^block)(size_t));:第一个参数iterations表示重复次数，第三个参数block中有一个参数，表示该block按照重复次数添加到queue中时是第几个添加的。
void dispatch_once(dispatch_once_t *predicate, DISPATCH_NOESCAPE dispatch_block_t block);
信号量：dispatch semaphore
信号量解决的是一个车位不够用的问题：
其中有3个重要接口：
1，dispatch_samaphore_t dispatch_semaphore_create(long value);
传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。
值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL。
2，long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
消费一个车位，timeout用于设定等车位的时间，超过后就不再等待了。
3，long dispatch_semaphore_signal(dispatch_semaphore_t dsema);
增加一个车位。
dispatch_queue_t global = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semap = dispatch_semaphore_create(0);
dispatch_async(global, ^{
dispatch_semaphore_wait(semap, DISPATCH_TIME_FOREVER);
NSLog(@"first");
});
NSLog(@"second");
dispatch_semaphore_signal(semap);
output:
second
first
挂起和继续执行一个queue
dispatch_suspend(queue);
dispatch_resume(queue);
以上两个要成对出现，出现suspend，一定要有一个resume，不能无限制挂起。否则，会崩溃。
