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

iOS——GCD再学习

news 来源：原创 2024/9/21 2:31:16

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执行完才能执行，因此发生了死锁，跟那个主队列+同步执行差不多。

相关文章：

  • 北京网站建设多少钱？
  • 辽宁网页制作哪家好_网站建设
  • 高端品牌网站建设_汉中网站制作
  • rexroth拧紧系统
  • 使用EDM邮件群发营销管理平台发送推广邮件在什么时间段发信效果最好
  • 【C++ Primer Plus习题】14.1
  • pytest压力测试:不断发送数据，直到发现数据丢失
  • 【AcWing】861. 二分图的最大匹配(匈牙利算法)
  • python-网页自动化（二）
  • 强烈推荐！分享5款ai论文生成软件
  • 修改密码模块中对轮询接口响应用户失效问题的处理
  • Android13 Hotseat客制化--Hotseat修改布局、支持滑动、去掉开机弹动效果、禁止创建文件夹
  • GitHub图床
  • pytorch pyro 贝叶斯神经网络 bnn beyesean neure network svi ​定制SVI目标和培训循环，变更推理
  • 经验笔记：前端堆栈分配
  • 批量下载，控制并发（利用promise 做需求池队列）
  • 如何理解基于架构的软件设计（ABSD）
  • TMS320F28335芯片及使用介绍
  • @jsonView过滤属性
  • [case10]使用RSQL实现端到端的动态查询
  • 【JavaScript】通过闭包创建具有私有属性的实例对象
  • 5分钟即可掌握的前端高效利器：JavaScript 策略模式
  • Git初体验
  • Git同步原始仓库到Fork仓库中
  • iBatis和MyBatis在使用ResultMap对应关系时的区别
  • java B2B2C 源码多租户电子商城系统-Kafka基本使用介绍
  • java中具有继承关系的类及其对象初始化顺序
  • Koa2 之文件上传下载
  • MySQL几个简单SQL的优化
  • SpiderData 2019年2月13日 DApp数据排行榜
  • 工作踩坑系列——https访问遇到“已阻止载入混合活动内容”
  • 关于 Linux 进程的 UID、EUID、GID 和 EGID
  • ------- 计算机网络基础
  • 京东美团研发面经
  • 强力优化Rancher k8s中国区的使用体验
  • 使用Tinker来调试Laravel应用程序的数据以及使用Tinker一些总结
  • 在Docker Swarm上部署Apache Storm：第1部分
  • 在Mac OS X上安装 Ruby运行环境
  • 正则表达式-基础知识Review
  • # 日期待t_最值得等的SUV奥迪Q9：空间比MPV还大，或搭4.0T，香
  • # 再次尝试 连接失败_无线WiFi无法连接到网络怎么办【解决方法】
  • #数学建模# 线性规划问题的Matlab求解
  • #微信小程序（布局、渲染层基础知识）
  • #我与Java虚拟机的故事#连载07：我放弃了对JVM的进一步学习
  • （7）摄像机和云台
  • （Arcgis）Python编程批量将HDF5文件转换为TIFF格式并应用地理转换和投影信息
  • (cljs/run-at (JSVM. :browser) 搭建刚好可用的开发环境!)
  • （超简单）使用vuepress搭建自己的博客并部署到github pages上
  • （二）JAVA使用POI操作excel
  • （附源码）spring boot智能服药提醒app 毕业设计 102151
  • （附源码）springboot社区居家养老互助服务管理平台 毕业设计 062027
  • （力扣）1314.矩阵区域和
  • (一)、python程序--模拟电脑鼠走迷宫
  • (一)、软硬件全开源智能手表，与手机互联，标配多表盘，功能丰富(ZSWatch-Zephyr)
  • (转)为C# Windows服务添加安装程序
  • .net 7 上传文件踩坑
  • .Net Core 中间件与过滤器
  • .NET DevOps 接入指南 | 1. GitLab 安装