GCD好处
GCD 可用于多核的并行运算
GCD 会自动利用更多的 CPU 内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码
1、同步和异步
执行任务有两种方式：同步执行（sync）和异步执行（async）。
两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。
同步执行（sync）：
同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
只能在当前线程中执行任务，不具备开启新线程的能力。
异步执行（async）：
异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
可以在新的线程中执行任务，具备开启新线程的能力。
虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关
2、队列
在 GCD 中有两种队列：串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。
串行队列（Serial Dispatch Queue）：
每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
并发队列（Concurrent Dispatch Queue）：
可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）
队列的创建方法
// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
对于串行队列，GCD 提供了的一种特殊的串行队列：主队列（Main Dispatch Queue）。
所有放在主队列中的任务，都会放到主线程中执行。
可使用dispatch_get_main_queue()获得主队列。
// 主队列的获取方法
dispatch_queue_t queue = dispatch_get_main_queue();
对于并发队列，GCD 默认提供了全局并发队列（Global Dispatch Queue）。
可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。
// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
- 同步执行 + 并发队列
在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
所有任务都是在当前线程（主线程）中执行的，没有开启新的线程 都在main函数里 - 异步执行 + 并发队列
可以开启多个线程，任务交替（同时）执行。
除了当前线程（主线程），系统又开启了3个线程，并且任务是交替/同时执行的。（异步执行具备开启新线程的能力。且并发队列可开启多个线程，同时执行多个任务）。 - 同步执行 + 串行队列
不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（同步执行不具备开启新线程的能力）。
任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。 - 异步执行 + 串行队列
会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务
开启了一条新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）
任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行） - 同步执行 + 主队列
互相等待卡住不可行 - 在其他线程中调用同步执行 + 主队列
不会开启新线程，执行完一个任务，再执行下一个任务
// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行
selector 任务
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
- 异步执行 + 主队列
只在主线程中执行任务，执行完一个任务，再执行下一个任务。
**
所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然异步执行具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。
任务是按顺序执行的（因为主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。
** - GCD 栅栏方法：dispatch_barrier_async
在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。 - GCD 延时执行方法：dispatch_after
dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。 - dispatch_once 用作单例
dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。
/**
* 一次性代码（只执行一次）dispatch_once
*/
- (void)once {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
}
dispatch_apply快速迭代
无论是在串行队列，还是异步队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。
/**
* 快速迭代方法 dispatch_apply
*/
- (void)apply {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"apply---begin");
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd---%@",index, [NSThread currentThread]);
});
NSLog(@"apply---end");
}
dispatch_group 队列组
分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。
调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合 来实现
dispatch_group_async。
调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。
55431520496712_.pic_hd.jpg
以上均属于网络，若有侵权问题，请私聊
- (void)testFunction2 {
dispatch_semaphore_t semapA = dispatch_semaphore_create(1);
dispatch_semaphore_t semapB = dispatch_semaphore_create(0);
dispatch_semaphore_t semapC = dispatch_semaphore_create(0);
NSThread *thread1 = [[NSThread alloc] initWithBlock:^{
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semapA, DISPATCH_TIME_FOREVER);
NSLog(@"A -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapB);
}
}];
NSThread *thread2 = [[NSThread alloc] initWithBlock:^{
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semapB, DISPATCH_TIME_FOREVER);
NSLog(@"B -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapC);
}
}];
NSThread *thread3 = [[NSThread alloc] initWithBlock:^{
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semapC, DISPATCH_TIME_FOREVER);
NSLog(@"C -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapA);
}
}];
[thread1 start];
[thread2 start];
[thread3 start];
}
- (void)testFunction3 {
dispatch_semaphore_t semapA = dispatch_semaphore_create(1);
dispatch_semaphore_t semapB = dispatch_semaphore_create(0);
dispatch_semaphore_t semapC = dispatch_semaphore_create(0);
dispatch_queue_t backqueue = dispatch_get_global_queue(0, 0 );
dispatch_async(backqueue, ^{
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semapA, DISPATCH_TIME_FOREVER);
NSLog(@"A -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapB);
}
});
dispatch_async(backqueue, ^{
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semapB, DISPATCH_TIME_FOREVER);
NSLog(@"B -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapC);
}
});
dispatch_async(backqueue, ^{
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semapC, DISPATCH_TIME_FOREVER);
NSLog(@"C -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapA);
}
});
}
- (void)testFunction {
// dispatch_semaphore_t sema = dispatch_semaphore_create(1);
//
// dispatch_queue_t backqueue = dispatch_get_global_queue(0, 0 );
//
// for (int i = 0; i < 10; i++) {
// dispatch_async(backqueue, ^{
// dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
// NSLog(@"A -- %@",[NSThread currentThread]);
// dispatch_semaphore_signal(sema);
//
// });
//
// dispatch_async(backqueue, ^{
// dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
// NSLog(@"B -- %@",[NSThread currentThread]);
// dispatch_semaphore_signal(sema);
// });
// dispatch_async(backqueue, ^{
// dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
// NSLog(@"C -- %@",[NSThread currentThread]);
// dispatch_semaphore_signal(sema);
// });
// }
dispatch_semaphore_t semapA = dispatch_semaphore_create(1);
dispatch_semaphore_t semapB = dispatch_semaphore_create(0);
dispatch_semaphore_t semapC = dispatch_semaphore_create(0);
dispatch_queue_t backqueue = dispatch_get_global_queue(0, 0 );
for (int i = 0; i < 10; i++) {
dispatch_async(backqueue, ^{
dispatch_semaphore_wait(semapA, DISPATCH_TIME_FOREVER);
NSLog(@"A -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapB);
});
dispatch_async(backqueue, ^{
dispatch_semaphore_wait(semapB, DISPATCH_TIME_FOREVER);
NSLog(@"B -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapC);
});
dispatch_async(backqueue, ^{
dispatch_semaphore_wait(semapC, DISPATCH_TIME_FOREVER);
NSLog(@"C -- %@",[NSThread currentThread]);
dispatch_semaphore_signal(semapA);
});
}
}