基于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，不能无限制挂起。否则，会崩溃。