主要总结一下平时iOS开发中用到的GCD内容，和没有用到的相关API，以备日后开发中使用。昨天面试时候被问到多线程的一些内容，比如线程间的依赖，回答的不是太好！在一些业务不是太复杂或者用户量较少的项目中，很少有地方需要太复杂的GCD操作。
队列和任务
队列（Dispatch Queue）
这里的队列跟数据结构里提到的队列概念一样，一种特殊的线性表，（FIFO）先进先出。在GCD中主要用来存放任务，从队头读取任务，从队尾加入新的任务。
- 串行队列
每次只能执行一个任务。 - 并行队列
可以同时执行多个任务，同时开启多个线程执行任务。只有被添加到async中才会这样执行
// dispatch_queue_create 创建队列
- (void)GCD_queue
{
// 串行队列
dispatch_queue_t serialQueue = dispatch_queue_create("serial_queue_Identifier", DISPATCH_QUEUE_SERIAL);
_serialQueue = serialQueue;
// 并行队列
dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrent_queue_identifier", DISPATCH_QUEUE_CONCURRENT);
_concurrentQueue = concurrentQueue;
NSLog(@"%s -------------- dispatch_queue_create", __func__);
}
任务:sync(同步执行)、async(异步执行)
- sync（同步执行）
不具备开线程的能力，只能在当前线程执行
// sync + 串行队列 = 不会开线程、任务顺序执行
- (void)CGD_sync_serialQueue
{
for (int i = 0; i < 5; i++) {
dispatch_sync(_serialQueue, ^{
NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
});
}
}
// sync + 并行队列 = 不会开线程、任务顺序执行
- (void)GCD_sync_concurrentQueue
{
for (int i = 0; i < 5; i++) {
dispatch_sync(_concurrentQueue, ^{
NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
});
}
}
- async（异步执行）
具备开线程的能力，但是不一定会开辟新的线程，这和任务添加的队列有关，任务的执行不需要等待
// async + 串行队列 = 只开一个线程、在此线程中顺序执行
- (void)GCD_async_serialQueue
{
for (int i = 0; i < 5; i++) {
dispatch_async(_serialQueue, ^{
NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
});
}
}
// async + 并行队列 = 开多个线程、任务并行执行
- (void)GCD_async_concurrentQueue
{
for (int i = 0; i < 5; i++) {
dispatch_async(_concurrentQueue, ^{
NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
});
}
}
- 另外两种特殊的组合
sync + dispatch_get_main_queue() : 在主线程会造成死锁，相互等待造成死锁，在子线程不会造成死锁
- (void)GCD_sync_mainQueue_in_subThread
{
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"%s ---Thread：%@---", __func__, [NSThread currentThread]);
for (int i = 0; i < 5; i++) {
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
});
}
});
}
async + dispatch_get_main_queue() : 任务在主线程中顺序执行
- (void)GCD_async_mainQueue
{
for (int i = 0; i < 5; i++) {
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
});
}
}
任务依赖：dispatch_barrier_async
GCD 栅栏方法：dispatch_barrier_async：
在有些情况下，我们需要任务A必须在任务B之前执行，这时候在GCD里我们就用到dispatch_barrier_async函数，他保证dispatch_barrier_async之前的任务先执行，然后再执行dispatch_barrier_async 的任务，最后执行dispatch_barrier_async之后的任务。
//- GCD 栅栏方法：dispatch_barrier_async
- (void)GCD_barrier_async
{
// A任务
for (int i = 0; i < 3; i++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"Thread：%@--- A任务 --- %d", [NSThread currentThread], i);
});
}
// Barrier任务
dispatch_barrier_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"Thread：%@--- Barrier任务", [NSThread currentThread]);
});
// B任务
for (int i = 0; i < 3; i++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"Thread：%@--- B任务 --- %d", [NSThread currentThread], i);
});
}
}
切记是在同一任务队列中，否则达不到我们的要求
dispatch_group + dispatch_group_notify 组合
在有些情况下，我们需要执行完任务A、任务B ·····，然后才得到通知，再去做某个任务：
首先用 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中，异步执行。
然后调用 dispatch_group_notify 方法回到指定线程，完成剩下的操作。
- (void)GCD_async_gounp_notify
{
dispatch_group_t group = dispatch_group_create();
for (int i = 0; i < 3; i++) {
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"Thread：%@--- A任务 --- %d", [NSThread currentThread], i);
});
}
for (int i = 0; i < 3; i++) {
dispatch_group_async(group, _concurrentQueue, ^{
NSLog(@"Thread：%@--- B任务 --- %d", [NSThread currentThread], i);
});
}
// 任务A 任务B都完成之后，执行notify的任务
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"Thread：%@--- 任务A 任务B 执行之后的操作", [NSThread currentThread]);
});
}
可以是不同的任务队列，都会加入到dispatch_group_t组中
GCD的信号量机制(dispatch_semaphore）
开发中可以利用信号量控制GCD线程的最大并发数
dispatch_semaphore_t是一个整型值，create的时候设置一个初始值，该值即为线程的最大并发数（如果初始值小于0则会返回NULL）；开始任务时发送等待信号，信号量-1；当信号量减到0时，会发生线程阻塞，知道信号量大于0；任务结束时发送信号量通知信号，信号量+1。
// 创建信号量,设置最大并发数为2 dispatch_semaphore_create(2)
dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
for (int i = 0; i < 10; i++) {
// 异步函数+串行队列，开一个线程顺序执行任务
dispatch_async(_serialQueue, ^{
// 等待降低信号量，信号量-1 dispatch_semaphore_wait（信号量，等待时间）
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// 异步函数+并行队列，开多个线程并发执行任务
dispatch_async(_concurrentQueue, ^{
NSLog(@"%@--------开始——任务%d", [NSThread currentThread], i);
sleep(1);
NSLog(@"%@--------结束——任务%d", [NSThread currentThread], i);
// 提高信号量，信号量+1 dispatch_semaphore_signal(信号量)
dispatch_semaphore_signal(semaphore);
});
});
}
// 下边的循环虽然能利用信号量控制最大并发数，但由于是在主线程中执行，会阻塞主线程
/*
for (int i = 0; i < 10; i++) {
// 等待降低信号量，信号量-1 dispatch_semaphore_wait（信号量，等待时间）
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_async(_concurrentQueue, ^{
NSLog(@"%@--------开始——任务%d", [NSThread currentThread], i);
sleep(1);
NSLog(@"%@--------结束——任务%d", [NSThread currentThread], i);
// 任务执行完提高信号量，信号量+1 dispatch_semaphore_signal(信号量)
dispatch_semaphore_signal(semaphore);
});
}
*/
在主线程使用信号量时，会造成主线程阻塞
其他一些API
dispatch_once
平常写单例会用到
// dispatch_once_t 保证代码块中只执行一次
- (void)GCD_once
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"%s -------------- dispatch_once", __func__);
});
}
dispatch_after
延迟执行
// dispatch_after 保证代码延迟执行，设定一个时间
- (void)GCD_after
{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%s -------------- dispatch_after", __func__);
});
}
附上demo，如果帮到你了请给个
GitHub
963.png