当前位置：首页 > news >正文

【iOS】GCD

news 2026/2/10 1:24:43

参考文章：GCD函数和队列原理探索

之前写项目的时候，进行耗时的网络请求使用GCD处理过异步请求，但对一些概念都很模糊，这次就来系统学习一下GCD相关

GCD中的队列

主队列

The main queue：系统自带的一个队列，放到这个队列中的代码会被系统分配到主线程中执行。Main queue可以调用dispatch_get_main_queue()来获得。因为main queue是与主线程相关的，所以这是一个串行队列，交至其中的任务顺序执行(一个任务执行完毕后，再执行下一个任务)
```
dispatch_queue_t mainQueue = dispatch_get_main_queue();
```

全局队列

Global queues：整个应用程序存在4个全局队列(系统已经创建好，只需获得即可)：高、中(默认)、后台三个优先级队列，可以调用dispatch_get_global_queue函数传入有下级来访问队列。全局队列是并行队列，可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)，并发功能只有在异步(dispatch_async)函数下才有效

dispatch_queue_t globalQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_queue_t globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t globalQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_queue_t globalQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

自定义队列

用户自己创建队列：dispatch_queue_create创建的队列可以是串行的，也可以是并行的，因为系统已经给我们供了并行、串行队列，所以一般情况下我们不再需要在创建自己的队列。用户创建的队列可以有任意多个

注意: 分线程不能刷新UI，刷新UI只能在主线程。如果每个线程都刷新UI，将会很容易造成UI冲突，会出现不同步的情况，所以只有主线程中能刷新UI系统是为了降低编程的复杂程度，最大程度的避免冲突

GCD线程间通信

在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯

void communicateAmongThread(void) {dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{for (int i = 0; i < 6; ++i) {NSLog(@"1 --- %@", [NSThread currentThread]);}// 回到主线程dispatch_async(dispatch_get_main_queue(), ^{NSLog(@"2 --- %@", [NSThread currentThread]);});});
}

运行结果：

在这里插入图片描述

可以看到在其他线程中先执行操作，执行完了之后回到主线程执行主线程的相应操作

GCD的栅栏方法

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏

这是没添加栅栏函数之前的结果，顺序不确定：

在这里插入图片描述

void barrierFunc(void) {dispatch_queue_t queue = dispatch_queue_create("666", DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue, ^{NSLog(@"1 --- %@", [NSThread currentThread]);});dispatch_async(queue, ^{NSLog(@"2 --- %@", [NSThread currentThread]);});dispatch_barrier_async(queue, ^{NSLog(@"----barrier-----%@", [NSThread currentThread]);});dispatch_async(queue, ^{NSLog(@"3 --- %@", [NSThread currentThread]);});dispatch_async(queue, ^{NSLog(@"4 --- %@", [NSThread currentThread]);});
}

栅栏函数可保证异步操作的执行顺序，这里保证了1或2先执行，3或4后执行：

在这里插入图片描述

GCD的延时方法

当我们需要延迟执行一段代码时，就需要用到GCD的dispatch_after方法

void delayExec(void) {NSLog(@"run -- 0");dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{// 3秒后异步执行这里的代码...NSLog(@"run -- 2");});
}

运行结果：

在这里插入图片描述

GCD的一次性代码（只执行一次）

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次

void onceExec(void) {static dispatch_once_t onceToken;dispatch_once(&onceToken, ^{// 只执行一次的代码（这里面是默认线程安全的）NSLog(@"Hhhhhhhh");});
}onceExec();
onceExec();

调用两次只会执行一次：

在这里插入图片描述

GCD的队列组

有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。

我们可以先把任务放到队列中，然后将队列放入队列组中
调用队列组的dispatch_group_notify回到主线程执行操作

void queueGroup(void) {// GCD的队列组dispatch_group_t group = dispatch_group_create();dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{// 执行1个耗时的异步操作int i = 0;while (i < 100) {NSLog(@"1");i++;}});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{// 执行1个耗时的异步操作int i = 0;while (i < 100) {NSLog(@"2");i++;}});dispatch_group_notify(group, dispatch_get_main_queue(), ^{// 等前面的异步操作都执行完毕后，回到主线程...NSLog(@"3");});
}

运行结果：

在这里插入图片描述

dispatch_set_target_queue

这个函数有两个作用：

改变队列的优先级
防止多个串行队列的并发执行

改变队列的优先级

dispatch_queue_create函数生成的串行队列和并发队列，都使用与默认优先级的Global Dispatch Queue 相同执行优先级的线程

void serialBackgroundQueue(void) {// 需求：生成一个后台的串行队列dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);dispatch_queue_t globalQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);// 第1个参数：需要改变优先级的队列// 第2个参数：目标队列dispatch_set_target_queue(serialQueue, globalQueueBackground);
}

防止多个串行队列的并发执行

如果是将任务追加到3个串行队列中，那么这些任务就会并发执行。因为每个串行队列都会创建一个线程，这些线程会并发执行
如果将多个串行的queue使用dispatch_set_target_queue指定到了同一目标，那么这多个串行queue在目标queue上就是同步执行的，不再是并行执行
将串行队列加入指定优先级队列，会按照加入优先级队列的顺序依次执行串行队列

未加入优先级队列：

在这里插入图片描述

void abandonSerialQueuesToConcurrent(void) {dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);dispatch_queue_t queue3 = dispatch_queue_create("test.3", 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 in");[NSThread sleepForTimeInterval:3.f];NSLog(@"1 out");});dispatch_async(queue2, ^{NSLog(@"2 in");[NSThread sleepForTimeInterval:2.f];NSLog(@"2 out");});dispatch_async(queue3, ^{NSLog(@"3 in");[NSThread sleepForTimeInterval:1.f];NSLog(@"3 out");});
}

加入后：

在这里插入图片描述

dispatch_suspend/dispatch_resume

dispatch_suspend并不会立即暂停正在运行的block，而是在当前block执行完成后，暂停后续的block执行

挂起指定队列：dispatch_suspend(serialQueue);
恢复指定队列：dispatchp_resume(serialQueue);

void suspendOrResumeQueue(void) {dispatch_queue_t queue = dispatch_queue_create("com.test.gcd", DISPATCH_QUEUE_SERIAL);//提交第一个block，延时5秒打印。dispatch_async(queue, ^{sleep(5);NSLog(@"After 5 seconds...");});//提交第二个block，也是延时5秒打印dispatch_async(queue, ^{sleep(5);NSLog(@"After 5 seconds again...");});//延时一秒NSLog(@"sleep 1 second...");sleep(1);//挂起队列NSLog(@"suspend...");dispatch_suspend(queue);//延时10秒NSLog(@"sleep 17 second...");sleep(17);//恢复队列NSLog(@"resume...");dispatch_resume(queue);
}

线程安全

为了保证线程安全，我们之前了解过互斥锁，在书上给了我们dispatch_semaphore方法，我们总结为三点：

synchronized加锁，属于互斥锁，当有线程执行锁住的代码的时候，其他线程会进入休眠，需要唤醒后才能继续执行，性能较低

- (void)synchronizedSecurity {dispatch_async(dispatch_get_global_queue(0, 0), ^{// 加锁保证block中执行完成才会执行其他的@synchronized (self) {NSLog(@"1开始");sleep(2);NSLog(@"1结束");}});dispatch_async(dispatch_get_global_queue(0, 0), ^{@synchronized (self) {NSLog(@"2开始");sleep(2);NSLog(@"2结束");}});
}

信号量semaphore加锁，属于自旋锁，当有线程执行锁住的代码的时候，其他线程会进入死循环的等待，当解锁后会立即执行，性能较高
提供了三种函数：
- dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量（同时有几个线程可以执行，一般是1）
- dispatch_semaphore_wait：可以使总信号量减1，当信号总量小于0时就会一直等待（阻塞所在线程），否则就可以正常执行，这个放在要执行的代码的前面。
- dispatch_semaphore_signal：发送一个信号，让信号总量加1，代码执行完成之后使用，使其他线程可以继续执行
```
void semaphoreSecurity(void) {dispatch_semaphore_t semalook = dispatch_semaphore_create(1);dispatch_async(dispatch_get_global_queue(0, 0), ^{dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);NSLog(@"1开始");sleep(2);NSLog(@"1结束");dispatch_semaphore_signal(semalook);});dispatch_async(dispatch_get_global_queue(0, 0), ^{dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);NSLog(@"2开始");sleep(2);NSLog(@"2结束");dispatch_semaphore_signal(semalook);});
}
```

NSLock

void lockSecurity(void) {NSLock *lock = [[NSLock alloc]init];dispatch_async(dispatch_get_global_queue(0, 0), ^{[lock lock];NSLog(@"1开始");sleep(2);NSLog(@"1结束");[lock unlock];});dispatch_async(dispatch_get_global_queue(0, 0), ^{[lock lock];NSLog(@"2开始");sleep(2);NSLog(@"2结束");[lock unlock];});
}

运行结果：

在这里插入图片描述

相关概念

什么是GCD？

「任务」

「队列」

队列与函数组合

GCD中的队列

相关案例分析

六种情况示例

主队列添加同步任务

主队列添加异步任务

并发队列添加异步任务

并发队列添加同步任务

串行队列添加异步任务

串行队列添加同步任务

串行队列添加同步和异步任务混合

并发队列多任务

GCD线程间通信

GCD的栅栏方法

GCD的延时方法

GCD的一次性代码（只执行一次）

GCD的队列组

dispatch_set_target_queue

dispatch_suspend/dispatch_resume

线程安全

相关文章：