iOS——GCD再学习

2024-09-06 20:20
文章标签 学习 ios gcd

本文主要是介绍iOS——GCD再学习，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

GCD

使用GCD好处，具体如下：

  • GCD 可用于多核的并行运算；
  • GCD 会自动利用更多的 CPU 内核（比如双核、四核）；
  • GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）；
  • 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码。

任务与队列

概念

**任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。**在 GCD 中是放在 block 中的。执行任务有两种方式：同步执行 和 异步执行。
两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

  • 同步执行（sync）：
    同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
    只能在当前线程中执行任务，不具备开启新线程的能力。

  • 异步执行（async）：
    异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
    可以在新的线程中执行任务，具备开启新线程的能力。

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关。
队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。
队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。

GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async

串行队列和并发队列

在 GCD 中有两种队列：串行队列 和 并发队列。
两者都符合 FIFO（先进先出）的原则。
两者的主要区别是：执行顺序不同，以及开启线程数不同。

  • 串行队列（Serial Dispatch Queue）：
    每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

  • 并发队列（Concurrent Dispatch Queue）：
    可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）

DISPATCH_QUEUE_SERIAL 表示串行队列。
DISPATCH_QUEUE_CONCURRENT 表示并发队列。

并发队列 的并发功能只有在异步（dispatch_async）方法下才有效。

主队列

主队列是一种特殊的 串行队列，在libdispatch_init 初始化时就创建了主队列，并且完成了与主线程的绑定。这些都是在程序main()函数之前就已完成的。
也就是说程序完成启动之时就已经有了主队列，并且所有放在主队列中的任务都是在主线程中执行的。==不管是同步还是异步都不会开辟新线程，任务只会在主线程执行。==这也是通常在主线程刷新UI时会将任务放到主队列的原因。
可通过dispatch_get_main_queue()获取主队列。

全局并发队列

全局并发队列 本质上是一个并发队列，由系统提供，方便编程，不用创建就可使用。
可通过dispatch_get_global_queue(long indentifier.unsigned long flags)获取全局并发队列。
该函数提供了两个参数，第一个参数表示队列优先级，通常写0，也就是默认优先级。可以通过服务质量类值来获取不同优先级的全局并发队列。

六种组合方式

请添加图片描述

同步执行+并发队列

有如下代码：

- (void)syncConcurrent {//打印syncConcurrent最开始执行的线程NSLog(@"%@", [NSThread currentThread]);//使用CONCURRENT并发队列dispatch_queue_t queue = dispatch_queue_create("elevenTest.queue", DISPATCH_QUEUE_CONCURRENT);dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1--%@", [NSThread currentThread]);});dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"2--%@", [NSThread currentThread]);});dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"3--%@", [NSThread currentThread]);});
}

执行结果：
请添加图片描述
所有任务都是在当前线程（主线程）中执行的，没有开启新的线程（同步执行不具备开启新线程的能力）。
按顺序执行的原因：虽然 并发队列 可以开启多个线程，并且同时执行多个任务。
但是因为本身不能创建新线程，只有当前线程这一个线程（同步任务 不具备开启新线程的能力），所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后，才能继续接着执行下面的操作（同步任务 需要等待队列的任务执行结束）。
所以任务只能一个接一个按顺序执行，不能同时被执行。

同步执行+串行队列

- (void)syncConcurrent {//打印syncConcurrent最开始执行的线程NSLog(@"%@", [NSThread currentThread]);//使用SERIAL串行队列dispatch_queue_t queue = dispatch_queue_create("elevenTest.queue", DISPATCH_QUEUE_SERIAL);dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1--%@", [NSThread currentThread]);});dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"2--%@", [NSThread currentThread]);});dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"3--%@", [NSThread currentThread]);});
}

运行结果：
在这里插入图片描述

所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（同步执行 不具备开启新线程的能力）。

任务是按顺序执行的（串行队列 每次只有一个任务被执行，任务一个接一个按顺序执行）。

异步执行+串行队列

- (void)syncConcurrent {//打印syncConcurrent最开始执行的线程NSLog(@"%@", [NSThread currentThread]);NSLog(@"start");dispatch_queue_t queue = dispatch_queue_create("elevenTest.queue1", DISPATCH_QUEUE_SERIAL);dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1--%@", [NSThread currentThread]);});dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"2--%@", [NSThread currentThread]);});dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"3--%@", [NSThread currentThread]);});NSLog(@"end");
}

执行结果：
在这里插入图片描述

开启了一条新线程（异步执行 具备开启新线程的能力，串行队列 只开启一个线程）。

任务是按顺序执行的（串行队列 每次只有一个任务被执行，任务一个接一个按顺序执行）。

异步执行+并发队列

- (void)syncConcurrent {//打印syncConcurrent最开始执行的线程NSLog(@"%@", [NSThread currentThread]);NSLog(@"start");dispatch_queue_t queue = dispatch_queue_create("elevenTest.queue1", DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1--%@", [NSThread currentThread]);});dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"2--%@", [NSThread currentThread]);});dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"3--%@", [NSThread currentThread]);});NSLog(@"end");
}

执行结果：
在这里插入图片描述

除了当前线程（主线程），系统又开启了 3 个线程，并且任务是交替/同时执行的。（异步执行 具备开启新线程的能力。且 并发队列 可开启多个线程，同时执行多个任务）。
说明当前线程没有等待，而是直接开启了新线程，在新线程中执行任务（异步执行 不做等待，可以继续执行任务）。

同步执行+主队列

- (void)syncConcurrent {//打印syncConcurrent最开始执行的线程NSLog(@"%@", [NSThread currentThread]);NSLog(@"start");dispatch_queue_t queue = dispatch_get_main_queue();dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1--%@", [NSThread currentThread]);});dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"2--%@", [NSThread currentThread]);});dispatch_sync(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"3--%@", [NSThread currentThread]);});NSLog(@"end");
}

执行结果：
在这里插入图片描述

同步执行 + 主队列在主线程中调用会发生死锁问题，而在其他线程中调用则不会。
这是因为我们在主线程中执行 syncConcurrent 方法，相当于把 syncConcurrent 任务放到了主线程的队列中。而 同步执行 会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把 任务 1 追加到主队列中，任务 1 就在等待主线程处理完 syncConcurrent 任务。而syncConcurrent 任务需要等待 任务 1 执行完毕，才能接着执行。
那么，现在的情况就是 syncConcurrent 任务和 任务 1 都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且 send 也没有打印。

为什么放到其他线程中就不会卡住了呢？
因为当任务放到了其他线程里，而 任务 1、任务 2、任务3 都在追加到主队列中，这三个任务都会在主线程中执行。
syncConcurrent任务在其他线程中执行到追加 任务 1 到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的 任务1，等 任务1 执行完毕，再接着执行 任务 2、任务 3。所以这里不会卡住线程，也就不会造成死锁问题。

异步执行+主队列

/*** 异步执行 + 主队列* 特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务*/
- (void)asyncMain {NSLog(@"currentThread---%@",[NSThread currentThread]);  NSLog(@"asyncMain---begin");dispatch_queue_t queue = dispatch_get_main_queue();dispatch_async(queue, ^{// 追加任务 1[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程});dispatch_async(queue, ^{// 追加任务 2[NSThread sleepForTimeInterval:2];// 模拟耗时操作NSLog(@"2---%@",[NSThread currentThread]);// 打印当前线程});dispatch_async(queue, ^{// 追加任务 3[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"3---%@",[NSThread currentThread]);// 打印当前线程});NSLog(@"asyncMain---end");
}打印：
[17521:4243690] currentThread—-{number = 1, name = main}
[17521:4243690] asyncMain—-begin
[17521:4243690] asyncMain—-end
[17521:4243690] 1—-{number = 1, name = main}
[17521:4243690] 2—-{number = 1, name = main}
[17521:4243690] 3—-{number = 1, name = main}

所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然 异步执行 具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。

任务是按顺序执行的（因为主队列是 串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

为什么一定要在主线程更新UI呢？
首先，UIKit不是线程安全的，当多个线程同时操作UI时，抢夺资源，有可能导致崩溃，UI异常等问题。假如在两个线程中设置了同一张背景图片，很有可能就会由于背景图片被释放两次，使得程序崩溃。或者某一个线程中遍历找寻某个subView，然而在另一个线程中删除了该subView，那么就会造成错乱。

子线程到底能不能更新UI呢？
有时也可以，但是会有问题。在子线程能更新的UI是一个假象，其实是子线程代码执行完毕了，又自动进入到了主线程，执行了子线程中的UI更新的函数栈，这中间的时间非常的短，就让大家误以为分线程可以更新UI。如果子线程一直在运行，则子线程中的UI更新的函数栈，主线程就无法获知，那就无法更新直到子线程结束。

GCD的一些函数

栅栏函数：dispatch_barrier_async/sync

dispatch_barrier_async方法:

  1. 在调用 dispatch_barrier_async 之前，所有被添加到并发队列中的任务都会并发执行。
  2. 当 dispatch_barrier_async添加的任务开始执行时，会等待之前所有添加到队列中的任务执行完毕。
  3. dispatch_barrier_async中添加的任务独占地执行，确保在执行任务时，没有其他任务在执行。
  4. 栅栏中的任务执行完毕后，队列恢复正常的并发行为，后续添加的任务可以并发执行。

有如下代码：

- (void)syncConcurrent {//打印syncConcurrent最开始执行的线程NSLog(@"%@", [NSThread currentThread]);NSLog(@"start");dispatch_queue_t queue = dispatch_queue_create("eleven", DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1--%@", [NSThread currentThread]);});dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"2--%@", [NSThread currentThread]);});dispatch_barrier_async(queue, ^{[NSThread sleepForTimeInterval:2];NSLog(@"barrier--%@", [NSThread currentThread]);NSLog(@"barrier start");sleep(5);NSLog(@"barrier end");});dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"3--%@", [NSThread currentThread]);});dispatch_async(queue, ^{[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"4--%@", [NSThread currentThread]);});NSLog(@"end");
}

执行结果：
请添加图片描述

dispatch_barrier_async：不会阻塞调用它的线程，屏障任务在并发队列中独占执行，但调用它的线程可以继续执行其他任务。对于自定义的并发队列，会按照上面的顺序执行，但是如果是系统的全局并发队列dispatch_queue_t queue = dispatch_get_global_queue(0, 0);，就不是这个顺序了,他们四个任务的顺序是不确定的；

dispatch_barrier_sync：会阻塞调用它的线程，直到屏障任务完成，调用线程才会继续执行。

GCD 延时执行方法：dispatch_after

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{// 2.0 秒后异步追加任务代码到主队列，并开始执行NSLog(@"after---%@",[NSThread currentThread]);  });

GCD 一次性代码（只执行一次）：dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 方法。
使用 dispatch_once 方法能保证某段代码在程序运行过程中只被执行 1 次，并且即使在多线程的环境下，dispatch_once 也可以保证线程安全。

- (void)once {static dispatch_once_t onceToken;dispatch_once(&onceToken, ^{// 只执行 1 次的代码（这里面默认是线程安全的）});
}

GCD 快速迭代方法：dispatch_apply

通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的方法 dispatch_apply。
dispatch_apply 按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。但是这样就体现不出快速迭代的意义了。
我们可以利用并发队列进行异步执行。比如说遍历 0~5 这 6 个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以 在多个线程中同时（异步）遍历多个数字。
还有一点，无论是在串行队列，还是并发队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

- (void)syncConcurrent {dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);NSLog(@"apply---begin");dispatch_apply(6, queue, ^(size_t index) {NSLog(@"%zd---%@",index, [NSThread currentThread]);});NSLog(@"apply---end");}

执行结果：
请添加图片描述

GCD 队列组：dispatch_group

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

调用队列组的 dispatch_group_async先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的dispatch_group_enter、dispatch_group_leave组合来实现 dispatch_group_async。

调用队列组的dispatch_group_notify回到指定线程执行任务。或者使用dispatch_group_wait回到当前线程继续向下执行（会阻塞当前线程）。

dispatch_group_notify

监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务

- (void)viewDidLoad {[super viewDidLoad];//打印syncConcurrent最开始执行的线程NSLog(@"%@", [NSThread currentThread]);NSLog(@"start");dispatch_group_t group = dispatch_group_create();dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{[NSThread sleepForTimeInterval:2];NSLog(@"1--%@", [NSThread currentThread]);});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{[NSThread sleepForTimeInterval:2];NSLog(@"2--%@", [NSThread currentThread]);});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{[NSThread sleepForTimeInterval:2];NSLog(@"3--%@", [NSThread currentThread]);});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{[NSThread sleepForTimeInterval:2];NSLog(@"4--%@", [NSThread currentThread]);});dispatch_group_notify(group, dispatch_get_main_queue(), ^{[NSThread sleepForTimeInterval:2];NSLog(@"5--%@", [NSThread currentThread]);});dispatch_group_wait(group, DISPATCH_TIME_FOREVER);NSLog(@"end");
}

执行结果：
请添加图片描述

dispatch_group_wait

暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。
当所有任务执行完成之后，才执行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 会阻塞当前线程。

dispatch_group_enter、dispatch_group_leave

dispatch_group_enter标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数 +1
dispatch_group_leave标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数 -1。
当 group 中未执行完毕任务数为0的时候，才会使 dispatch_group_wait 解除阻塞，以及执行追加到 dispatch_group_notify 中的任务。

- (void)viewDidLoad {[super viewDidLoad];NSLog(@"currentThread---%@",[NSThread currentThread]);NSLog(@"group---begin");dispatch_group_t group = dispatch_group_create();dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);dispatch_group_enter(group);dispatch_async(queue, ^{// 追加任务 1[NSThread sleepForTimeInterval:2];  // 模拟耗时操作NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程dispatch_group_leave(group);});dispatch_group_enter(group);dispatch_async(queue, ^{// 追加任务 2[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"2---%@",[NSThread currentThread]);// 打印当前线程dispatch_group_leave(group);});dispatch_group_notify(group, dispatch_get_main_queue(), ^{// 等前面的异步操作都执行完毕后，回到主线程.[NSThread sleepForTimeInterval:2];   // 模拟耗时操作NSLog(@"3---%@",[NSThread currentThread]);// 打印当前线程NSLog(@"group---end");});
}

这里的dispatch_group_enter、dispatch_group_leave 组合，其实等同于dispatch_group_async。

GCD 信号量：dispatch_semaphore

GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。

在 Dispatch Semaphore 中，使用计数来完成这个功能，计数小于 0 时等待，不可通过。计数为 0 或大于 0 时，计数减 1 且不等待，可通过。

Dispatch Semaphore 提供了三个方法：

dispatch_semaphore_create：创建一个 Semaphore 并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加 1
dispatch_semaphore_wait：可以使总信号量减 1，信号总量小于 0 时就会一直等待（阻塞所在线程），否则就可以正常执行。

注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。

  • Dispatch Semaphore 在实际开发中主要用于：
  1. 保持线程同步，将异步执行任务转换为同步执行任务
  2. 保证线程安全，为线程加锁

但是使用信号量可能会造成线程优先级反转，且无法避免。

有如下代码：

- (void)viewDidLoad {[super viewDidLoad];NSLog(@"currentThread---%@",[NSThread currentThread]);NSLog(@"semaphore---begin");dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);__block int number = 0;dispatch_async(queue, ^{// 追加任务 1[NSThread sleepForTimeInterval:2]; // 模拟耗时操作NSLog(@"1---%@",[NSThread currentThread]);// 打印当前线程number = 100;dispatch_semaphore_signal(semaphore);});dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);NSLog(@"semaphore---end,number = %d",number);}

执行结果：
请添加图片描述

执行顺序如下：

  1. semaphore 初始创建时计数为 0。
  2. 异步执行 将 任务 1 追加到队列之后，不做等待，接着执行 dispatch_semaphore_wait 方法，semaphore 减 1，此时 semaphore == -1，当前线程进入等待状态。
  3. 然后，异步任务 1 开始执行。任务 1 执行到 dispatch_semaphore_signal 之后，总信号量加 1，此时 semaphore == 0，正在被阻塞的线程（主线程）恢复继续执行。
  4. 最后打印 semaphore—end,number = 100。

线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。

线程池

线程池流程图如下：

请添加图片描述

线程池（Thread Pool）是一种多线程管理机制，用于提高应用程序的性能和资源利用率。线程池通过预先创建一定数量的线程，并在需要执行任务时重复使用这些线程，而不是每次都创建和销毁线程，从而减少线程创建和销毁的开销。

通常使用GCD（Grand Central Dispatch）和NSOperationQueue来实现线程池的功能。

死锁问题

场景一：

- (void)viewDidLoad {[super viewDidLoad];[self test1];
}- (void)test1 {NSLog(@"任务1------");dispatch_queue_t queue = dispatch_get_main_queue();dispatch_sync(queue, ^{NSLog(@"任务2------");});NSLog(@"任务3--------");
}

主队列+同步执行：主队列是串行队列，任务test1在主队列中，在test1中同步执行了任务2。同步执行的队列中，当前任务执行完之前会阻塞线程。而主线程每次只能执行一个任务，因此test1任务要等待任务2执行完才能完成执行，而任务2要等待test1执行完才能执行，因此两个任务互相卡住了，发生了死锁。

场景二：

- (void)test2 {NSLog(@"任务1------");// 创建一个串行队列dispatch_queue_t queue = dispatch_queue_create("com.longchi", DISPATCH_QUEUE_SERIAL);dispatch_async(queue, ^{  // 异步任务NSLog(@"任务2------");dispatch_sync(queue, ^{NSLog(@"任务3------");});NSLog(@"任务4--------");});NSLog(@"任务5--------");
}

在这段代码中，queue是一个串行队列。向其中异步执行一个任务，因为异步不会阻塞当前线程，因此任务1和5都可以执行。在异步方法内又同步执行了一个方法，又因为同步执行中的方法执行完成前会阻塞当前线程，因此任务3执行完成前会一直阻塞线程，但是这个同步方法是处于串行队列的，因此要执行任务3要等待任务4执行完，但是任务4又要等任务3执行完才能执行，因此发生了死锁，跟那个主队列+同步执行差不多。

这篇关于iOS——GCD再学习的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1143027。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...
学习hash总结

学习hash总结

2014/1/29/   最近刚开始学hash，名字很陌生，但是hash的思想却很熟悉，以前早就做过此类的题，但是不知道这就是hash思想而已，说白了hash就是一个映射，往往灵活利用数组的下标来实现算法，hash的作用：1、判重；2、统计次数；
阅读更多...
安卓链接正常显示，ios#符被转义%23导致链接访问404

安卓链接正常显示，ios#符被转义%23导致链接访问404

原因分析： url中含有特殊字符 中文未编码 都有可能导致URL转换失败，所以需要对url编码处理  如下： guard let allowUrl = webUrl.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {return} 后面发现当url中有#号时，会被误伤转义为%23，导致链接无法访问
阅读更多...
零基础学习Redis(10) -- zset类型命令使用

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合，内部除了存储元素外，还会存储一个score，存储在zset中的元素会按照score的大小升序排列，不同元素的score可以重复，score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]
阅读更多...
【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程（Gaussian Process，简称GP）是一种概率模型，用于描述一组随机变量的联合概率分布，其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数（或核函数） 1.3 核函数1.4 高斯过程回归（Gauss
阅读更多...
【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

系列文章目录 监督学习：参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归（SAheart.csv） 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学
阅读更多...
系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

本章知识考点：         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识
阅读更多...
线性代数|机器学习-P36在图中找聚类

线性代数|机器学习-P36在图中找聚类

文章目录 1. 常见图结构2. 谱聚类 感觉后面几节课的内容跨越太大，需要补充太多的知识点，教授讲得内容跨越较大，一般一节课的内容是书本上的一章节内容，所以看视频比较吃力，需要先预习课本内容后才能够很好的理解教授讲解的知识点。 1. 常见图结构 假设我们有如下图结构： Adjacency Matrix:行和列表示的是节点的位置，A[i,j]表示的第 i 个节点和第 j 个
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2