基本概念了解：
线程：程序执行任务的最小调到单位；
任务：其实就是一段代码(在线程中执行的那段代码)，GCD中，任务就是block中要执行的内容；
队列：就是用来放’任务’的地方，即任务队列，采用FIFO(先进先出)的原则；
异步执行：可以在新的线程中执行任务，具备开启新线程的能力。就是多个任务情况下，任务A正在执行，同时可以执行另一个任务B。任务B不用等待任务A结束才执行。存在多条线程。
同步执行：只能在当前线程中执行任务，不具备开启新线程的能力。就是多个任务情况下，任务A执行结束，才可以执行另一个任务B。
并发队列：多个任务并发(同时)执行(自动开启多个线程同时执行任务)。就是指两个或多个事件在同一时间间隔内发生。注意并发只有在异步—dispatch_async下才有效。
并行队列：又称为串行队列，任务一个接着一个地执行(一个任务执行完成后，在执行下一个任务)。即指两个或多个时间在同一时刻发生。多核CUP同时开启多条线程供多个任务同时执行，互不干扰。
需注意：
使用GCD最大的目的是在新线程中同时执行多个任务，所以需要以下条件：
能开启新的线程
任务可以同时执行
以上两个条件=“开启新线程的能力+任务同步执行的权利”，只有满足能力与权利的前提下，才可以同时执行多个任务。
几种情况组合:
GCD使用：
创建队列
将任务添加到队列中，系统根据任务类型执行任务—同步执行或异步执行
队列创建：使用dispatch_queue_create来创建，可以传2个参数，第一个参数表示队列唯一的标识符，用于debug，当然也可为空；第二个参数用来识别是并发还是串行队列。DISPATCH_QUEUE_SERIAL是串行队列，DISPATCH_QUEUE_CONCURRENT是并发队列。对于并发队列还可以使用dispatch_get_global_queue创建全局并发队列。也要传2个参数，第一个表示队列优先级，默认是DISPATCH_QUEUE_PRIORITY_DEFAULT(也可用0表示)，第二个用0即可。
// 串行队列的创建方法
dispatch_queue_tqueue= dispatch_queue_create("serial.queue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_tqueue= dispatch_queue_create("conc.queue", DISPATCH_QUEUE_CONCURRENT);
任务的创建：
// 同步执行任务创建方法
dispatch_sync(queue, ^{
NSLog(@"%@",[NSThreadcurrentThread]);// 这里放任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
NSLog(@"%@",[NSThreadcurrentThread]);// 这里放任务代码
});
exam：后台两个线程并行执行，然后两个线程执行结束后，汇总执行结果
dispatch_group group = dispatch_group_create();
dispatch_group_async(group,dispatch_get_global_queue(0,0),^{//并行执行的线程1});
dispatch_group_async(group,dispatch_get_global_queue(0,0),^{//并行执行的线程2});
dispatch_group_notify(group,dispatch_get_global_queue(0,0),^{//汇总结果});
组合使用：
1. 并发队列 + 同步执行
不会开启新线程，执行完一个任务，再执行下一个任务
- (void) syncConcurrent
{
NSLog(@"syncConcurrent---begin");
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"syncConcurrent---end");
}
2. 并发队列 + 异步执行
可同时开启多线程，任务交替执行
- (void) asyncConcurrent
{
NSLog(@"asyncConcurrent---begin");
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"asyncConcurrent---end");
}
3. 串行队列 + 同步执行
不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务
- (void) syncSerial
{
NSLog(@"syncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"syncSerial---end");
}
在串行队列 + 同步执行可以看到，所有任务都是在主线程中执行的，并没有开启新的线程。而且由于串行队列，所以按顺序一个一个执行。
4. 串行队列 + 异步执行
会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务
- (void) asyncSerial
{
NSLog(@"asyncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"asyncSerial---end");
}
输出结果为：
GCD[11648:1905817] asyncSerial---begin
GCD[11648:1905817] asyncSerial---end
GCD[11648:1905895] 1------{number = 2, name = (null)}
GCD[11648:1905895] 1------{number = 2, name = (null)}
GCD[11648:1905895] 2------{number = 2, name = (null)}
GCD[11648:1905895] 2------{number = 2, name = (null)}
GCD[11648:1905895] 3------{number = 2, name = (null)}
GCD[11648:1905895] 3------{number = 2, name = (null)}
在串行队列 + 异步执行可以看到，开启了一条新线程，但是任务还是串行，所以任务是一个一个执行。
另一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所 有任务添加到队列之后才开始同步执行。
下边讲讲刚才我们提到过的特殊队列——主队列。
主队列：GCD自带的一种特殊的串行队列
所有放在主队列中的任务，都会放到主线程中执行
可使用dispatch_get_main_queue()获得主队列
我们再来看看主队列的两种组合方式。
5. 主队列 + 同步执行
互等卡住不可行(在主线程中调用)
- (void)syncMain
{
NSLog(@"syncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"syncMain---end");
}
输出结果
GCD[11670:1908306] syncMain---begin
这时候，我们惊奇的发现，在主线程中使用主队列 + 同步执行，任务不再执行了，而且syncMain---end也没有打印。这是为什么呢？
这是因为我们在主线程中执行这段代码。我们把任务放到了主队列中，也就是放到了主线程的队列中。而同步执行有个特点，就是对于任务是立马执行的。那么当我们把第一个任务放进主队列中，它就会立马执行。但是主线程现在正在处理syncMain方法，所以任务需要等syncMain执行完才能执行。而syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务。
那么，现在的情况就是syncMain方法和第一个任务都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain---end也没有打印。
要是如果不再主线程中调用，而在其他线程中调用会如何呢？
不会开启新线程，执行完一个任务，再执行下一个任务（在其他线程中调用）
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[self syncMain];
});
在其他线程中使用主队列 + 同步执行可看到：所有任务都是在主线程中执行的，并没有开启新的线程。而且由于主队列是串行队列，所以按顺序一个一个执行。
同时我们还可以看到，所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间，这说明任务是添加到队列中马上执行的。
6. 主队列 + 异步执行
只在主线程中执行任务，执行完一个任务，再执行下一个任务
- (void)asyncMain
{
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"asyncMain---end");
}
5. GCD线程之间的通讯
在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
// 回到主线程
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"2-------%@",[NSThread currentThread]);
});
});
GCD的延时执行方法 dispatch_after
当我们需要延迟执行一段代码时，就需要用到GCD的dispatch_after方法。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后异步执行这里的代码...
NSLog(@"run-----");
});
GCD的一次性代码(只执行一次) dispatch_once
我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
GCD的队列组 dispatch_group
有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。
我们可以先把任务放到队列中，然后将队列放入队列组中。
调用队列组的dispatch_group_notify回到主线程执行操作。
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程...
});