Objective-C多线程开发之GCD（最全总结）

什么是CGD呢？以下摘自苹果的官方说明。

  Grand Central Dispatch (GCD) 是异步执行任务的技术之一。应用程序中记述的线程管理用的代码是在系统级中实现的。开发者只需要定义想要执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并执行任务。
  也就是说，GCD用我们难以置信的非常简洁的方法，实现了极为复杂的多线程编程。本文将罗列GCD的API及其用法实例来帮助大家了解GCD。

1. GCD的队列和任务

GCD中有两个核心的概念：任务和队列

1.1 任务 (Dispatch Block)

任务： 就是你想让系统执行的操作，GCD中通常是放在dispatch_block_t中的代码。任务分为同步执行(sync)和异步执行(async)两种执行方式。

同步执行(sync) : 任务被同步添加到指定的队列中，在该任务执行结束前会一直等待。不具备开启线程的能力，只能在当前线程中同步执行任务。

异步执行(async) : 任务被异步添加到指定队列中，不会等待该任务执行。具备开启线程的能力，可在新线程中执行任务。

注: 异步执行虽然具有开启新线程的能力，但只有该任务追加到并发队列才会开启新线程。

1.2 队列 (Dispatch Queue)

队列 (Dispatch Queue) : 是执行任务的的等待队列。开发者通过 dispatch_async或dispatch_sync函数等API，在dispatch_block_t中记述想要执行的任务并将其追加到Dispatch Queue中。Dispatch Queue按照追加的顺序（先进先出FIFO，First-In-First-Out）执行任务。队列分为 串行队列(Serial Dispatch Queue) 和 并发队列(Concurrent Dispatch Queue) 。

串行队列(Serial Dispatch Queue) : 只开启一条新的线程，追加到该队列中的任务会依次按顺序执行。

并发队列(Concurrent Dispatch Queue) : 会开辟多条新的线程，追加到该队列中的任务会并行执行。

注: 
1. 并发队列虽然有开启多条新线程的能力，但是只有在异步执行任务时才会开启新线程。
2. 并发队列开启的新线程个数并不等同于任务个数，取决于队列的任务数、CPU核数、以及CPU负荷等当前系统状态。

2. GCD任务的创建、队列的获取和创建

2.1 创建同步及异步任务

dispatch_async(queue, ^{
    //创建异步任务
});
dispatch_sync(queue, ^{
    //创建同步任务
});

或者这样创建：

dispatch_block_t block = ^{
     //任务
};
dispatch_async(queue, block); //异步执行
dispatch_sync(queue, block);  //同步执行

2.2 获取系统主队列

主队列为特殊的串行队列，只有一个线程，即为主线程。主线程用于界面UI更新、用户事件交互等操作。所以比较耗时的操作(如查询数据库，数据请求等)都不应放在主线程中执行，会造成页面卡顿，影响用户体验。

dispatch_queue_t queue = dispatch_get_main_queue();

2.3 获取全局并发队列

系统为我们提供了四个全局的并发队列，我们可以直接获取，用来执行任务。

CPU执行任务处理时按照队列的优先级来分配资源，决定任务执行的先后顺序。但是苹果通过XUN内核用于Global Dispatch Queue 的线程并不能保证实时性 (Why? I don't know.)，因此执行优先级只是大致的判断。

//第一个参数为队列优先级，第二个参数没用到，传0就行。

dispatch_queue_t queue =
 dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

全局并发队列的优先级：

DISPATCH_QUEUE_PRIORITY_HIGH //高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT //默认优先级
DISPATCH_QUEUE_PRIORITY_LOW //低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND //后台级

2.4 创建 串行队列(Serial Dispatch Queue)

//1.第一个参数为队列名称，推荐使用工程ID这种逆序命名方式，便于管理和调试。
//2.第二个参数传NULL或DISPATCH_QUEUE_SERIAL，表示串行队列。

    dispatch_queue_t queue =
     dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_SERIAL);

2.5 创建 并发队列(Concurrent Dispatch Queue)

//1.第一个参数为队列名称，推荐使用工程ID这种逆序命名方式，便于管理和调试。
//2.第二个参数传DISPATCH_QUEUE_CONCURRENT，表示并发队列。

    dispatch_queue_t queue =
     dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_CONCURRENT);

3. 不同队列及任务的不同执行方式对比

GCD	串行队列(Serial Dispatch Queue)	并发队列(Concurrent Dispatch Queue)	主队列
同步执行(sync)	不会开启新线程，任务同步执行	不会开启新线程，任务同步执行	主线程发生死锁
异步执行(async)	开启一条新线程，任务同步执行	会开启新线程，任务并发执行	不会开启新线程，任务同步执行

由上我们可以看出：要想并发执行某些任务，只有使用 〖并发队列 + 异步执行〗这种组合方式。
这也是我们开发中最常用的组合方式。

下面我们来具体试试这几种组合的应用：

3.1 串行队列 + 同步执行

- (void)serialAndSync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = \
    dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_SERIAL);
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_sync(queue, block1);
    dispatch_sync(queue, block2);
    dispatch_sync(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
2     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}

• 结论:

1. 所有任务都在主线程中执行(【串行+同步】不会开启新线程)。
2. 所有任务按照追加顺序依次执行。
3. 任务执行在begin和end之间，同步执行任务会阻塞主线程。

3.2 串行队列 + 异步执行

- (void)serialAndAsync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = \
    dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_SERIAL);
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    dispatch_async(queue, block3);

    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d0078800>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d0078800>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1c0073200>{number = 3, name = (null)}
2     ==== >>: <NSThread: 0x1c0073200>{number = 3, name = (null)}
3     ==== >>: <NSThread: 0x1c0073200>{number = 3, name = (null)}

• 结论:

1. 【串行+异步】只开启一条新线程，所有任务按照追加顺序依次执行。
2. 任务执行在end之后，异步执行任务不会阻塞主线程。

3.3 并发队列 + 同步执行

- (void)concurrentAndSync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = \
    dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_sync(queue, block1);
    dispatch_sync(queue, block2);
    dispatch_sync(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
2     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}

• 结论:

1. 所有任务都在主线程中执行(同步执行不会开启新线程)。
2. 所有任务按照追加顺序依次执行。
3. 任务执行在begin和end之间，同步执行任务会阻塞主线程。

3.4 并发队列 + 异步执行

- (void)concurrentAndAsync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = \
    dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_CONCURRENT);
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    dispatch_async(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d0263e00>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d0263e00>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4269fc0>{number = 3, name = (null)}
2     ==== >>: <NSThread: 0x1c007f140>{number = 4, name = (null)}
1     ==== >>: <NSThread: 0x1c807e740>{number = 5, name = (null)}

• 结论:

1. 任务执行在end之后 (不在主线程中执行，开启多条新线程执行)。不会阻塞主线程
2. 所有任务并发执行，不会等待。

3.5 主队列 + 同步执行

- (void)mainAndSync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = \
    dispatch_get_main_queue();
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_sync(queue, block1);
    dispatch_sync(queue, block2);
    dispatch_sync(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d0263e00>{number = 1, name = main}

• 结论:

发生死锁，任务不会执行。由于主队列为串行队列，主线程在执行mainAndSync 函数，而 mainAndSync 在等待主线程执行结束，就造成了互相等待，均不会执行。(开发中要极力避免这种情况)

3.6 主队列 + 异步执行

- (void)mainAndAsync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = \
    dispatch_get_main_queue();
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    dispatch_async(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
2     ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}

• 结论:

1. 由于主队列为串行队列(不会开启新线程)，所有任务都在主线程中执行。
2. 任务在end之后执行，主队列中开启异步任务，不会开启新线程，会降低异步任务的优先级，在CPU空闲时才会执行该任务。

4. GCD中的 dispatch_set_target_queue 的用法及作用

4.1 更改Dispatch Queue 的执行优先级

通过 dispatch_queue_create 函数生成的GCD队列，不管是 Serial Dispatch Queue 还是 Concurrent Dispatch Queue，其优先级都为系统默认优先级，若想改变创建队列的优先级，则可以使用 dispatch_set_target_queue 函数。

    // 第一个参数为需要更改优先级的queue, 第二个参数为参照队列，
    // 将参照队列的优先级设为目标队列的优先级

dispatch_queue_t queue = \
    dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_SERIAL);
    
    dispatch_queue_t globalQueue = \
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    
    dispatch_set_target_queue(queue, globalQueue);

4.2 设置多个 Dispatch Queue 的层级

由上我们知道，通过 dispatch_queue_create 函数创建的 Serial Dispatch Queue 任务执行是同步的，同时只能执行一个任务，虽然GCD队列受到系统资源的限制，但通过 dispatch_queue_create 函数可以生成任意多个 Dispatch Queue。

当生成多个 Serial Dispatch Queue时，各个 Serial Dispatch Queue将并行执行。

如下代码：

- (void)setTargetQueue {
    
    dispatch_queue_t queue1 = dispatch_queue_create("com.example.gcd.queue1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("com.example.gcd.queue2", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue3 = dispatch_queue_create("com.example.gcd.queue3", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue1, ^{
        NSLog(@"1 ==== >>: %@",[NSThread currentThread]);
        sleep(3);
        NSLog(@"2 ==== >>: %@",[NSThread currentThread]);
    });

    dispatch_async(queue2, ^{
        NSLog(@"3 ==== >>: %@",[NSThread currentThread]);
        sleep(2);
        NSLog(@"4 ==== >>: %@",[NSThread currentThread]);
    });

    dispatch_async(queue3, ^{
        NSLog(@"5 ==== >>: %@",[NSThread currentThread]);
        sleep(1);
        NSLog(@"6 ==== >>: %@",[NSThread currentThread]);
    });
}

执行结果:

3 ==== >>: <NSThread: 0x1d0066180>{number = 5, name = (null)}
5 ==== >>: <NSThread: 0x1d4468e80>{number = 4, name = (null)}
1 ==== >>: <NSThread: 0x1d0066700>{number = 3, name = (null)}
6 ==== >>: <NSThread: 0x1d4468e80>{number = 4, name = (null)}
4 ==== >>: <NSThread: 0x1d0066180>{number = 5, name = (null)}
2 ==== >>: <NSThread: 0x1d0066700>{number = 3, name = (null)}

多次运行发现: 其中1、3、5的输出顺序不固定，多个任务并发执行。

假如此时我想让多个同步队列中的任务还是依次同步执行，或者让多个并发队列中的任务同步执行，我该怎么办呢？对，使用 dispatch_set_target_queue ，将三个队列指定到同一串行目标队列上，此时多个队列任务就会同步执行，不再是并发执行了。

如下代码:

- (void)setTargetQueue {
    
    dispatch_queue_t queue1 = dispatch_queue_create("com.example.gcd.queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue2 = dispatch_queue_create("com.example.gcd.queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue3 = dispatch_queue_create("com.example.gcd.queue3", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_queue_t targetQueue = dispatch_queue_create("com.example.gcd.targetQueue", DISPATCH_QUEUE_SERIAL);

    //指定到同一串行队列
    dispatch_set_target_queue(queue1, targetQueue);
    dispatch_set_target_queue(queue2, targetQueue);
    dispatch_set_target_queue(queue3, targetQueue);
    
    dispatch_async(queue1, ^{
        NSLog(@"1 ==== >>: %@",[NSThread currentThread]);
        sleep(3);
        NSLog(@"2 ==== >>: %@",[NSThread currentThread]);
    });

    dispatch_async(queue2, ^{
        NSLog(@"3 ==== >>: %@",[NSThread currentThread]);
        sleep(2);
        NSLog(@"4 ==== >>: %@",[NSThread currentThread]);
    });

    dispatch_async(queue3, ^{
        NSLog(@"5 ==== >>: %@",[NSThread currentThread]);
        sleep(1);
        NSLog(@"6 ==== >>: %@",[NSThread currentThread]);
    });
}

执行结果:

1 ==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
2 ==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
3 ==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
4 ==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
5 ==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
6 ==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}

在必须将不可并行执行的多个任务追加到多个 Serial Dispatch Queue 中时，可使用 dispatch_set_target_queue函数，防止任务并发执行。

注: 一旦生成 Serial Dispatch Queue 并追加任务处理，系统对于一个 Serial Dispatch Queue 
就会生成一条线程。假如生成 1000个 Serial Dispatch Queue ，那么就生成了 1000 条线程。
此时会大量消耗内存，大幅度降低系统的响应性能。

5. GCD时间: dispatch_time_t

dispatch_time_t 为GCD的时间类，用于获取距离某个目标时间间隔的时间

计算相对时间：

   dispatch_time_t time = \
    dispatch_time(<#dispatch_time_t when#>, <#int64_t delta#>)

//第一个参数为某个目标时间，常用 DISPATCH_TIME_NOW,表示现在时间。
//第二个参数表示具体的时间长度，不能直接传 int或者float，需 (int64_t)3* NSEC_PER_SEC 这种形式。

注: delta单位是纳秒！

NSEC_PER_SEC  1000000000ull  每秒有1000000000纳秒
NSEC_PER_MSEC 1000000ull     每毫秒有1000000纳秒
USEC_PER_SEC  1000000ull     每秒有1000000微秒
NSEC_PER_USEC 1000ull        每微秒有1000纳秒

"ull"是C语言的数值字面量，是显示表明类型时使用的字符串（表示“unsigned long long”）。

例如 dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC) 表示距离当前时间 3秒后的时间。

计算绝对时间:

dispatch_time_t time = \
    dispatch_walltime(<#const struct timespec * _Nullable when#>, <#int64_t delta#>)
    
/* 第一个参数是一个 timespec 的结构体, 计算的是一个绝对的时间点,比如 2016年10月10日8点30分30秒, 
如果你不需要自某一个特定的时刻开始,可以传 NUll,表示自动获取当前时区的当前时间作为开始时刻，
第二个参数同上。*/

例如 dispatch_walltime(NULL, 3*NSEC_PER_SEC)表示距离当前时间 3秒后的时间。

struct timespec 类型的时间可以通过NSDate对象生成:

// 通过指定日期获取一个 dispatch_time_t 对象
- (dispatch_time_t)getDispatchTimeByDate:(NSDate *)date {
    NSTimeInterval interval;
    double second, subsecond;
    struct timespec time;
    dispatch_time_t milestone = 0;
    
    interval = [date timeIntervalSince1970];
    subsecond = modf(interval, &second);
    time.tv_sec = second;
    time.tv_nsec = dispatch_walltime(&time, 0);
    return milestone;
}

6. GCD延时操作: dispatch_after

我们可能经常会有这样的需求，想在3秒后执行某项操作，可能不限于3秒，总之，这种想在指定时间后执行操作的情况，可用 dispatch_after 来实现。

例如:

//第一个参数是 dispatch_time_t 的值(详见5)。
//第二个参数是执行的 Dispatch Queue 。
//第三个参数是要追加的操作。

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);
    
    dispatch_after(time, dispatch_get_main_queue(), ^{
        NSLog(@"Three seconds later...");
    });

注: dispatch_after 函数并不是在指定的时间过后执行操作，而只是在指定时间后追加操作到 Dispatch Queue 中。

因为 Mian Dispatch Queue 在主线程的RunLoop 中执行，假如主线程的刷新频率为 60 帧，则追加的操作最快在3秒后执行，最慢则在 3 + 1/60 秒后执行，并且假如在Mian Dispatch Queue 中有大量操作要执行或者主线程本身有延迟的话，这个时间会更长。

7. Dispatch Group

7.1 dispatch_group_notify

假如在追加到 Dispatch Queue 中的多个操作全部结束后想要执行某项操作，假如只使用一个 Serial Dispatch Queue时，只需将结束操作追加到所有任务的最后即可实现。但是在使用 Concurrent Dispatch Queue或同时使用多个 Dispatch Queue时，实现起来就比较复杂了。

这时我们就可以使用 Dispatch Group 。下面我们来看一段代码:

- (void)dispatchGroup {
    NSLog(@"begin  ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 1 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 2 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 3 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
    });
    NSLog(@"end    ==== >>: %@",[NSThread currentThread]);
}

执行结果:

begin  ==== >>: <NSThread: 0x1d006f940>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d006f940>{number = 1, name = main}
Task 2 ==== >>: <NSThread: 0x1d0473700>{number = 3, name = (null)}
Task 3 ==== >>: <NSThread: 0x1c806cd00>{number = 4, name = (null)}
Task 1 ==== >>: <NSThread: 0x1c406c740>{number = 5, name = (null)}
Done!  ==== >>: <NSThread: 0x1c806cd00>{number = 4, name = (null)}

因为Global Dispatch Queue 为 Concurrent Dispatch Queue ，多个线程并发执行任务，所以任务执行顺序不定，但是执行结果 Done 一定是最后执行的。无论使用的是什么类型的 Dispatch Queue，Dispatch Group 都可以监测到这些任务执行的结束。

通过 dispatch_group_create() 函数生成 Dispatch Group .

dispatch_group_async与 dispatch_async 相同，都是追加 Block操作到指定 Dispatch Queue中。不同的是 dispatch_group_async 多了一个 Group 参数。

7.2 dispatch_group_wait

如上情况我们也可以使用 dispatch_group_wait 函数去实现，如下代码:

- (void)dispatchGroup {
    NSLog(@"begin  ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        sleep(3);
        NSLog(@"Task 1 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        sleep(1);
        NSLog(@"Task 2 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 3 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
    
    NSLog(@"end    ==== >>: %@",[NSThread currentThread]);
}

执行结果:

begin  ==== >>: <NSThread: 0x1d4262fc0>{number = 1, name = main}
Task 3 ==== >>: <NSThread: 0x1d026f040>{number = 3, name = (null)}
Task 2 ==== >>: <NSThread: 0x1c007ff40>{number = 4, name = (null)}
Task 1 ==== >>: <NSThread: 0x1cc07fe80>{number = 5, name = (null)}
Done!  ==== >>: <NSThread: 0x1d4262fc0>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d4262fc0>{number = 1, name = main}

从结果我们可以看出 dispatch_group_wait一样可以达到我们想要的结果。但是不同之处也非常明显，dispatch_group_wait 会阻塞当前线程。

另外 dispatch_group_wait 函数可以指定等待的时间，传入 DISPATCH_TIME_FOREVER 则表示永远等待，直到所有任务执行结束。且该函数还有 long 型的返回值，返回0则表示所有任务都执行结束。

如我们修改代码如下:

long result = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 2*NSEC_PER_SEC));
    
    if (result == 0) {
        //所有任务都执行结束
        NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
    }else {
        //有任务尚未结束
        NSLog(@"Not Done!  ==== >>: %@",[NSThread currentThread]);
    }

执行结果为:

begin  ==== >>: <NSThread: 0x1d0264f40>{number = 1, name = main}
Task 3 ==== >>: <NSThread: 0x1d066e980>{number = 3, name = (null)}
Task 2 ==== >>: <NSThread: 0x1cc07f9c0>{number = 4, name = (null)}
Not Done!  ==== >>: <NSThread: 0x1d0264f40>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d0264f40>{number = 1, name = main}
Task 1 ==== >>: <NSThread: 0x1c807fc80>{number = 5, name = (null)}

由上我们可以看出 dispatch_group_notify 与 dispatch_group_wait 两个函数的异同之处。在开发过程中可根据具体情况选择使用。

7.3 dispatch_group_enter 和 dispatch_group_leave

这两个函数配对使用，表示 Dispatch Group 开启任务和结束任务。这两种通知可以在多线程间自由穿梭，不局限于特定的某个线程。

dispatch_group_enter: 通知group，下面的任务马上要放到group中执行了。
dispatch_group_leave: 通知group，任务完成了，该任务要从group中移除了。

猜测： 可能 Dispatch Group 内部有着一个类似引用计数的存在，调用 dispatch_group_enter 会加一，调用 dispatch_group_leave会减一，当该值为0时，则调用 dispatch_group_notify 和 dispatch_group_wait 函数。

当我们异步开启一个任务，并不指定特定的队列及线程时，可使用这两个函数去通知 Dispatch Group 任务的开启和结束。

如下代码:

- (void)dispatchGroup {
    NSLog(@"begin  ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();

    [self downloadImaegWithUrl:@"http://pic10.photophoto.cn/20090224/0036036802407491_b.jpg" InGroup:group];
    [self downloadImaegWithUrl:@"http://pic25.photophoto.cn/20121220/0036036800277861_b.jpg" InGroup:group];
    [self downloadImaegWithUrl:@"http://img.taopic.com/uploads/allimg/140806/235020-140P60H10661.jpg" InGroup:group];

    dispatch_group_notify(group, queue, ^{
        NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
    });
    NSLog(@"end    ==== >>: %@",[NSThread currentThread]);
}

//利用 SDWebImage异步下载图片
- (void)downloadImaegWithUrl:(NSString *)url InGroup:(dispatch_group_t)group{
    dispatch_group_enter(group);//开启任务
    [[SDWebImageDownloader sharedDownloader] downloadImageWithURL:[NSURL URLWithString:url] options:(SDWebImageDownloaderContinueInBackground) progress:nil completed:^(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, BOOL finished) {
        NSLog(@"下载完成! ====>>: %@",[NSThread currentThread]);
        dispatch_group_leave(group);//结束任务
    }];
}

执行结果：

begin  ==== >>: <NSThread: 0x1d406ee00>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d406ee00>{number = 1, name = main}
下载完成! ====>>: <NSThread: 0x1d406ee00>{number = 1, name = main}
下载完成! ====>>: <NSThread: 0x1d406ee00>{number = 1, name = main}
下载完成! ====>>: <NSThread: 0x1d406ee00>{number = 1, name = main}
Done!  ==== >>: <NSThread: 0x1cc069cc0>{number = 3, name = (null)}

8. GCD栅栏 （dispatch_barrier_sync）

当我们在访问数据库或者文件时，使用 Serial Dispatch Queue 可避免数据竞争导致程序异常的问题(多个写入操作不可并行执行)。但是这样的话，程序的执行效率就比较低。

为了高效率的进行访问，我们使用 Concurrent Dispatch Queue，并使用 dispatch_barrier_sync函数解决数据竞争问题。

dispatch_barrier_sync俗称栅栏，顾名思义，即可以将某些操作隔绝开来，互不影响。

假如我想在4次读取操作中间加入2次写入操作， 如下代码：

- (void)dispatchBarrier {
    
    dispatch_queue_t queue = dispatch_queue_create("com.gcd.example", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"reading1 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading2 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        //写入操作
        NSLog(@"writing1 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        //写入操作
        NSLog(@"writing2 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading3 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading4 ===>>: %@",[NSThread currentThread]);
    });
}

由 Concurrent Dispatch Queue 的性质我们可知，4次读取和2次写入均会并发执行，先后顺序不定，这样必然会导致数据竞争，出现异常。

修改代码: 我们只需将写入操作替换成 dispatch_barrier_sync 函数即可解决该问题。

dispatch_barrier_sync(queue, ^{
        //写入操作
        NSLog(@"writing1 ===>>: %@",[NSThread currentThread]);
    });
dispatch_barrier_sync(queue, ^{
        //写入操作
        NSLog(@"writing2 ===>>: %@",[NSThread currentThread]);
    });

dispatch_barrier_sync 函数会等待追加到 Dispatch Queue 上的并行任务全部执行结束之后，再将指定的操作追加到 Dispatch Queue 中。该指定的操作执行完毕后，Dispatch Queue 才会恢复正常操作。开始处理其他任务。

因此修改后的代码执行顺序为 reading1和reading2并发执行在前，之后为 writing1 和 writing2 串行执行，最后 reading3和reading4并发执行。

9. GCD信号量 （dispatch_semaphore_t）

信号量(dispatch_semaphore_t)可以理解为有信号通过，无信号则等待。具体的我们慢慢来分析。

与信号量有关的主要有三个函数:

dispatch_semaphore_create(<#long value#>)
//创建一个信号量，传入一个long型的信号值.
//传入信号值为大于或者等于0的值，否则将返回 NULL.

dispatch_semaphore_wait(<#dispatch_semaphore_t  _Nonnull dsema#>, <#dispatch_time_t timeout#>)
//与 dispatch_group_wait(详见7.2)类似，会阻塞当前线程，并有返回值.
//当当前信号量等于0时，持续等待.
//当当前信号量大于0时，执行返回，并将当前信号量减一.

dispatch_semaphore_signal(<#dispatch_semaphore_t  _Nonnull dsema#>)
//该函数会将当前信号量加一.

我理解的信号量主要有三个作用:线程同步、线程锁、控制并发数.

9.1 线程同步

先看代码：

__block int count = 0;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        count = 10;
    });
    NSLog(@"%d",count);

由异步并发执行我们可知，此时输出的count值为 0。假如我想让主线程保持与任务异步线程一致，输出 count 值为10，我该怎么做呢？

修改代码：

dispatch_semaphore_t semphore = dispatch_semaphore_create(0);
    __block int count = 0;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        count = 10;
        dispatch_semaphore_signal(semphore);
    });
    dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
    NSLog(@"%d",count);

分析:
我们初始化了一个值为0信号量，执行 dispatch_semaphore_wait 函数时发现信号量为0，则会等待信号，执行完 count = 10 后，通过 dispatch_semaphore_signal 函数获得一个信号量，此时 dispatch_semaphore_wait 监测到信号量大于0，则执行返回，线程继续执行，输出 count 为10。这就保证了线程间的同步了。

9.2 线程锁

假如我想异步并发执行1000次任务，给同一块内存区间赋值，会发生什么情况呢?
先看代码:

NSMutableArray *temArr = @[].mutableCopy;
    for (int i = 0; i < 1000; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [temArr addObject:[NSString stringWithFormat:@"%d",i]];
        });
    }

运行会发现程序异常崩溃的概率相当高，这是因为我们异步并发的操作同一内存导致数据错乱引起的异常。

使用线程锁修改代码：

dispatch_semaphore_t semphore = dispatch_semaphore_create(0);
    NSMutableArray *temArr = @[].mutableCopy;
    for (int i = 0; i < 1000; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            //等待信号
            dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
            //到这里，信号量会减一
            [temArr addObject:[NSString stringWithFormat:@"%d",i]];
            dispatch_semaphore_signal(semphore);
            //信号量加一
        });
    }

通过这种方法，保证了同一时间只有一个操作去改变内存。当然在实际操作中我们不会这样去for循环使用，通常是设置一个全局的 dispatch_semaphore_t 对象，将需要加锁的操作放在，dispatch_semaphore_wait 和 dispatch_semaphore_signal 函数中间。保证唯一性。

例如：

@property (nonatomic, copy) NSString *name;
@property (nonatomic, strong) dispatch_semaphore_t semaphore;

self.semaphore = dispatch_semaphore_create(1);

- (void)setName:(NSString *)name {
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    _name = name;
    dispatch_semaphore_signal(self.semaphore);
}

9.2 控制并发数

当我们在处理大量线程时，怎么来进行并发控制呢，假如我有1000个任务要执行，但是同时执行的并发数我想控制在10个，该怎么做呢？以前我们使用NSOperationQueue可以控制并发数，在GCD中怎么简单快速的控制并发呢？那就是使用 dispatch_semaphore_t.

先看代码:

- (void)dispatchSemaphore {

    dispatch_group_t group = dispatch_group_create();
    
    dispatch_semaphore_t semphore = dispatch_semaphore_create(10);
    
    for (int i = 0; i < 100; i++) {
        dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
        
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"%d ===>>: %@",i,[NSThread currentThread]);
            sleep(2);
            dispatch_semaphore_signal(semphore);
        });
    }
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"end");
}

首先我们创建了一个值为10的信号量，每次循环会减少一个信号量，执行结束会增加一个信号量，当执行操作为10个时，此时信号量为0，dispatch_semaphore_wait 函数将会等待，如此则保证了最多同时有10个任务在执行。由此看出，通过 dispatch_semaphore_t 来控制并发数简单快速又实用。

10. dispatch_suspend / dispatch_resume

当追加大量的处理任务到 Dispatch Queue 时，有时候希望不执行某些已经追加的任务，在这种情况下，只需要挂起 Dispatch Queue即可，当可以执行时再恢复。

• dispatch_suspend : 挂起指定的 Dispatch Queue。可理解为暂停执行。
• dispatch_resume : 恢复指定的 Dispatch Queue。可理解为继续执行。

值得注意的是，dispatch_suspend 对于正在执行的任务是没有影响的，挂起后，只有 Dispatch Queue 中尚未执行的任务停止执行。而恢复则使得这些任务能够继续执行。

11. GCD快速遍历 （dispatch_apply）

dispatch_apply 函数是dispatch_sync函数和 Dispatch Group的关联API。该函数按指定次数将指定的 Block 追加到指定的 Dispatch Queue中，并等待全部处理执行结束。

如下代码:

- (void)dispatchApply {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_apply(10, queue, ^(size_t index) {
        NSLog(@"%zu",index);
    });
    NSLog(@"end");
}

执行结果:

0
2
4
3
5
6
7
8
9
1
end

因为在 Global Dispatch Queue 中执行操作，10个任务并发执行，但是最后的end一定在最后的位置上。因为 dispatch_apply 会等待全部任务执行结束。

另外，由于dispatch_apply 函数与 dispatch_sync函数一样，会等待任务结束，阻塞当前线程，因此推荐在 dispatch_async 函数中异步执行 dispatch_apply 函数。

例如:

- (void)dispatchApply {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //异步执行
    dispatch_async(queue, ^{
        dispatch_apply(10, queue, ^(size_t index) {
            NSLog(@"%zu",index);
        });
        
        //等待处理结束
        dispatch_async(dispatch_get_main_queue(), ^{
            //主线程回调，刷新UI
            NSLog(@"end");
        });
    });
    NSLog(@"main");
}

12. GCD单例 (dispatch_once)

dispatch_once函数是保证在应用程序执行中只执行一次指定处理的API。

下面这种经常出现的用来进行初始化的代码可通过 dispatch_once 函数来简化。

static int count = 0;
    if (count == 0) {
        //在这里初始化
        count = 100;
    }

使用 dispatch_once 函数：

static int count = 0;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        //在这里初始化
        count = 100;
    });

代码看起来并没有太大的变化。但是通过 dispatch_once 函数，该代码即使在复杂的多线程环境下执行，也可保证百分之百安全。之前的代码在大多数情况下也是安全的。但是在多核CPU中，读取数据时，有可能会多次执行初始化处理。而用 dispatch_once 函数就不必担心这样的问题。这就是所说的单例模式，在生成单例对象时使用。

---

以上是我对于GCD简单理解之后的总结，若有不正确之处请评论指正，我会尽快验证修改！

                                ------来自一只菜鸟iOS程序猿。