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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/420079.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

华为手机找不到wifi调试？不急，没有wifi调试一样可以进行局域网模式调试

华为手机找不到wifi调试？不急，没有wifi调试一样可以进行局域网模式调试

最近小黄在使用uniapp启动无线调试的时候突然发现华为的手机突然找不到wifi调试了，那么我们怎么进行无线调试呢？ 其实他只是找不到开关而已，正常使用就行。 1.使用数据线连接手机。 打开cmd命令行执行：adb tcpip 5555 2.再执行ad…
阅读更多...
物联网之Arduino开发环境的下载与安装、ESP32开发环境的下载与安装、常见环境配置问题的解决办法、COM端口不可用的解决方法

物联网之Arduino开发环境的下载与安装、ESP32开发环境的下载与安装、常见环境配置问题的解决办法、COM端口不可用的解决方法

MENU 前言下载和安装Arduino安装ESP32开发环境常见问题JSON下载失败和下载速度慢配置解释器没有发现端口检测到端口，但是有警告图标，端口无法使用 前言 想玩开发板必须得写代码，要不然Arduino不知道怎么运行，Arduino的开发语言是C…
阅读更多...
❤《实战纪录片 1 》原生开发小程序中遇到的问题和解决方案

❤《实战纪录片 1 》原生开发小程序中遇到的问题和解决方案

《实战纪录片 1 》原生开发小程序中遇到的问题和解决方案 文章目录 《实战纪录片 1 》原生开发小程序中遇到的问题和解决方案1、问题一：原生开发中 request请求中返回 的数据无法 使用this传递给 data{}中怎么办？2、刚登录后如何将token信息保存&#xf…
阅读更多...
用于客户支持的 GenAI：探索 Elastic Support Assistant

用于客户支持的 GenAI：探索 Elastic Support Assistant

作者：Chris Blaisure, Cory Mangini 我们很高兴地宣布推出 Elastic 的支持助手。本博客将带你了解我们最新的生成式 AI 工具以及它可以帮助你使用 Elastic 技术的一些常见场景。 Elastic 支持助手现已在 Support Hub 上可用 今天，我们宣布 Elastic 支持…
阅读更多...
每日一题，力扣leetcode Hot100之206反转链表

每日一题，力扣leetcode Hot100之206反转链表

原来的链表是1-2-3-4-5-null 反转后是5-4-3-2-1-null 只需要循环遍历，并且借一个temp便可以完成反转 class Solution:def reverseList(self, head: ListNode) -> ListNode:cur, pre head, Nonewhile cur:tmp cur.next # 暂存后继节点 cur.nextcur.next pre…
阅读更多...
【软件测试】盒木进销存管理系统 需求说明书

【软件测试】盒木进销存管理系统 需求说明书

目录 1 引言 2 项目概述 3 平台、角色和权限 3.1 Web端 4 Web端需求 4.1 登录/注册页面 4.1.1 业务描述 4.1.2 需求描述 4.1.3 行为人 4.1.4 UI页面 4.1.5 业务规则 4.2 首页 4.2.1 业务描述 4.2.2 需求描述 4.2.3 行为人 4.2.4 UI界面 4.2.5 业务规则 4.3报…
阅读更多...
回归预测 | Matlab基于贝叶斯算法优化XGBoost(BO-XGBoost/Bayes-XGBoost)的数据回归预测+交叉验证

回归预测 | Matlab基于贝叶斯算法优化XGBoost(BO-XGBoost/Bayes-XGBoost)的数据回归预测+交叉验证

回归预测 | Matlab基于贝叶斯算法优化XGBoost(BO-XGBoost/Bayes-XGBoost)的数据回归预测交叉验证 目录 回归预测 | Matlab基于贝叶斯算法优化XGBoost(BO-XGBoost/Bayes-XGBoost)的数据回归预测交叉验证效果一览基本介绍程序设计参考资料 效果一览 基本介绍 Matlab实现基于贝叶…
阅读更多...
第144天：内网安全-Linux权限维持OpenSSHPAM后门SSH软链接公私钥登录

第144天：内网安全-Linux权限维持OpenSSHPAM后门SSH软链接公私钥登录

目录 案例一： 权限维持-Linux-替换版本-OpenSSH 后门 案例二： 权限维持-Linux-更改验证-SSH-PAM 后门 案例三： 权限维持-Linux-登录方式-软链接&公私钥&新帐号 ssh软链接 公私钥 新帐号 案例一： 权限维持-Linux-替换…
阅读更多...
记录｜C#的软件图标更换

记录｜C#的软件图标更换

目录 前言一、软件界面的图标二、软件外的图标更新时间 前言 参考文章： 自己开发出的软件，肯定要更换图标，无论是软件打开前还是软件上的。如下图： 一、软件界面的图标 直接在Form的属性中进行icon的更换【如下图：】…
阅读更多...
android kotlin 基础复习 继承 inherit

android kotlin 基础复习 继承 inherit

1、新建文件kt 2、代码： /**用户基类**/ open class Person1(name:String){/**次级构造函数**/constructor(name:String,age:Int):this(name){//初始化println("-------基类次级构造函数---------")println("name:${name},age:${age}")} }/**子…
阅读更多...
线程的状态（java）

线程的状态（java）

“苦？ 何止是苦~~~~~” 本期内容来分享一下线程状态相关的知识哦！！！ 对于进程来说，进程是有两种状态的。 一种是就绪状态：正在CPU上执行，或者随时可以去CPU上执行的。 另一种是阻塞状态&…
阅读更多...
PDF 全文多语言 AI 摘要 API 数据接口

PDF 全文多语言 AI 摘要 API 数据接口

PDF 全文多语言 AI 摘要 API 数据接口 PDF / 文本摘要 AI 生成 PDF 文档摘要 AI 处理 / 智能摘要。 1. 产品功能 支持多语言摘要生成；支持 formdata 格式 PDF 文件流传参；快速处理大文件；基于 AI 模型，持续迭代优化；…
阅读更多...
自己动手实现mybatis的底层框架(不用动态代理直接用执行器、用动态代理自己实现。图文分析！)

自己动手实现mybatis的底层框架(不用动态代理直接用执行器、用动态代理自己实现。图文分析！)

目录 一.原生mybits框架图分析 自己实现Mybatis框架的分析 两种框架操作数据库的方法： 二.搭建开发环境 1.先创建一个maven项目 2.加入依赖(mysql dom4j junit lombok) 三.mybatis框架的设计思路 具体实现过程 3.1实现任务阶段 1- 完成读取配置文件&#x…
阅读更多...
【Linux修行路】线程安全和死锁

【Linux修行路】线程安全和死锁

目录 ⛳️推荐 一、线程安全 1.1 常见的线程不安全情况 1.2 常见的线程安全情况 1.3 常见的不可重入情况 1.4 常见可重入的情况 1.5 可重入与线程安全的联系 1.6 可重入与线程安全的区别 二、死锁 2.1 死锁的四个必要条件 2.2 如何避免产生死锁？ ⛳️推荐…
阅读更多...
西门子PLC与HMI之间的时间同步工控小周

西门子PLC与HMI之间的时间同步工控小周

HMI 时间同步功能工控人加入PLC工业自动化精英社群 HMI 设备具有时间同步功能，利用 HMI 设备的该功能，可实现 PLC 和 HMI 之间的时间同步，进而实现多个 PLC 之间的时间同步。 HMI 设备时间同步的属性： 1.HMI 设备既可作为主站对…
阅读更多...
Unity Addressables 使用说明（五）在运行时使用 Addressables（Use Addressables at Runtime）

Unity Addressables 使用说明（五）在运行时使用 Addressables（Use Addressables at Runtime）

一旦你将 Addressable assets 组织到 groups 并构建到 AssetBundles 中，就需要在运行时加载、实例化和释放它们。 Addressables 使用引用计数系统来确保 assets 只在需要时保留在内存中。 Addressables 初始化 Addressables 系统在运行时第一次加载 Addressable …
阅读更多...
PLSQL-将一份excel数据导入到一张物理表(Oracle)

PLSQL-将一份excel数据导入到一张物理表(Oracle)

–>> 很简单~ 平时用惯了DBeaver，突然要用PLSQL Developer，确实很生疏。 –>> 我的场景，将一份.csv文件数据手动导入到Oracle下的一张物理表中去。 研究了半天，看网上说的可以用：Tools → ODBC Importer &…
阅读更多...
视频监控接入平台web客户端有时无法登录，有时打开实时视频出现黑屏的问题解决

视频监控接入平台web客户端有时无法登录，有时打开实时视频出现黑屏的问题解决

目录 一、背景说明 二、解决过程 1、问题产生 2、命令介绍 ①基本用法 ②常用选项 ③示例 3、问题解决 三、最终结果 一、背景说明 在本地登录视频监控平台的服务器进行测试时，发现客户端登录不上。 检查服务器的服务和数据库，运行状况正常&#xff0c…
阅读更多...
opencv 实现两个图片的拼接去重功能

opencv 实现两个图片的拼接去重功能

基础知识介绍 cv::Mat 是OpenCV库中用来表示图像和矩阵数据的核心类之一。它是一个多维数组，可以存储图像像素数据、矩阵数据以及其他类型的数据。以下是关于 cv::Mat 类的一些详细解释： 构造函数：cv::Mat 类有多个构造函数，可以用…
阅读更多...
【Linux】常用的命令

【Linux】常用的命令

文章目录 lsls -l / touchcdpwdcatechovim打开文件编辑内容保存退出 mkdirrmmvcpmangreppsnetstat总结 ： ls ls > list 列出当前目录下都有哪些内容（文件/目录） 直接输入 ls，是查看当前目录的情况；输入 ls/ 就是看…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023