主要总结一下平时iOS开发中用到的GCD内容，和没有用到的相关API，以备日后开发中使用。昨天面试时候被问到多线程的一些内容，比如线程间的依赖，回答的不是太好！在一些业务不是太复杂或者用户量较少的项目中，很少有地方需要太复杂的GCD操作。
1、队列和任务
队列（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);
});
}
}
2、任务依赖：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);
});
}
}
切记是在同一任务队列中，否则达不到我们的要求
3、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组中
4、dispatch_group + dispatch_group_notify 组合，配合dispatch_group_enter、dispatch_group_leave
-(void)DownLoadImage:(void(^)(UIImage *image1,UIImage *image2,UIImage *image3))downLoadSuccess{
__weak typeof(self) weakSelf = self;
// 创建分组
dispatch_group_t group = dispatch_group_create();
// 创建队列
dispatch_queue_t queue = dispatch_queue_create("downLoadImage", DISPATCH_QUEUE_CONCURRENT);
// 往分组中添加任务1
// 请求依次执行 与 dispatch_group_leave 配对使用
dispatch_group_enter(group);
__block UIImage *image1 = nil;
dispatch_group_async(group, queue, ^{
NSLog(@"第1张图片开始下载");
//处理耗时的操作
image1 = [weakSelf imageWithUrl:@"http://img0.imgtn.bdimg.com/it/u=3272199364,3404297250&fm=26&gp=0.jpg"];
dispatch_group_leave(group);
NSLog(@"第1张图片下载完成");
});
// 往分组中添加任务2
// 请求依次执行 与 dispatch_group_leave 配对使用
dispatch_group_enter(group);
__block UIImage *image2 = nil;
dispatch_group_async(group, queue, ^{
NSLog(@"第2张图片开始下载");
//处理耗时的操作
image2 = [weakSelf imageWithUrl:@"http://img.redocn.com/200906/2/321782_124390997641aY.jpg"];
dispatch_group_leave(group);
NSLog(@"第2张图片下载完成");
});
// 往分组中添加任务3
// 请求依次执行 与 dispatch_group_leave 配对使用
dispatch_group_enter(group);
__block UIImage *image3 = nil;
dispatch_group_async(group, queue, ^{
NSLog(@"第3张图片开始下载");
//处理耗时的操作
image3 = [weakSelf imageWithUrl:@"http://img5.imgtn.bdimg.com/it/u=2083600987,3767582702&fm=26&gp=0.jpg"];
NSLog(@"第3张图片下载完成");
dispatch_group_leave(group);
});
// 分组中任务完成后通知该block执行
dispatch_group_notify(group, queue, ^{
dispatch_async(dispatch_get_main_queue(), ^{
// 通知主线程刷新UI
downLoadSuccess(image1,image2,image3);
});
});
}
5、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);
});
}
*/
在主线程使用信号量时，会造成主线程阻塞
6、其他一些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
