iOS——GCD再学习

news2024/9/20 2:18:44

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.coloradmin.cn/o/2107810.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

面试软件测试需要掌握的技能有哪些？

面试软件测试需要掌握的技能有哪些？

一、测试用例的编写 1、在测试中最重要的文档，他是测试工作的核心，是一组在测试时输入输出的标准，是软件需求的具体对照。编写测试用例，是测试人员的基本功，真正能写好的人并不多。 测试用例包含的内容： …
阅读更多...
windows手工杀毒-寻找可疑进程之进程模块

windows手工杀毒-寻找可疑进程之进程模块

上篇回顾：windows手工杀毒-寻找可疑进程之进程启动文件-CSDN博客 上篇我们介绍了如何通过进程启动文件寻找可疑进程，首先我们查看文件的数字签名，如果签名是合法的，且是正规公司的证书。基本可疑排除进程是可疑进程&#…
阅读更多...
建议收藏！分享7款AI免费写论文学术工具

建议收藏！分享7款AI免费写论文学术工具

在当前的学术写作领域，AI工具已经成为许多研究人员和学生的重要助手。这些工具不仅能够帮助用户快速生成高质量的论文初稿，还能在一定程度上简化学术写作流程，提高写作效率。以下是七款免费且功能强大的AI写论文学术工具推荐： 一…
阅读更多...
如何使用树莓派构建 LoRa 网关?

如何使用树莓派构建 LoRa 网关?

顾名思义，远距离广域网或LoRaWAN技术广泛用于物联网（IoT）中的远距离、低功耗通信。 在本文中，我们将指导您如何将SX130x 868M LoRaWAN网关模块通过硬件附加在顶部（HAT）的方式连接到Raspberry Pi4。此设置创…
阅读更多...
上手一个RGBD深度相机：从原理到实践--ROS noetic+Astra S（上）：解读深度测距原理和内外参推导

上手一个RGBD深度相机：从原理到实践--ROS noetic+Astra S（上）：解读深度测距原理和内外参推导

前言 最近在做项目的时候，项目组丢给了我一个深度相机，今天我们来尝试上手一个实体深度相机。 本教程设计基础相机的原理，使用，标定，和读取。(注：本教程默认大家有ROS1基础，故不对程序进行详细…
阅读更多...
Camelyon16数据集切块批量预处理

Camelyon16数据集切块批量预处理

参考自： Camelyon16数据集切块预处理 区别是这里做了批量处理 数据集目录格式： ** main.py** # !/usr/bin/python3 # -*- coding: utf-8 -*- # Time : 2024/9/4 20:21 # Author : 猫娜Lisa # File : camelyon16_get_patch.py # Software: PyC…
阅读更多...
Linux从0到1——基础IO（下）【磁盘/文件系统/软硬链接/动静态库】

Linux从0到1——基础IO（下）【磁盘/文件系统/软硬链接/动静态库】

Linux从0到1——基础IO（下） 0. 前言1. 磁盘1.1 物理存储结构1.2 磁盘的逻辑存储结构 2. 文件系统2.1 文件系统的管理思想2.2 详解块组2.3 文件名和inode2.4 挂载 3. 软硬链接3.1 引入3.2 软链接3.3 硬链接 4. 动静态库4.1 静态库4.2 动态库 0. 前言 前面…
阅读更多...
强化学习之PPO算法

强化学习之PPO算法

PPO算法 什么是PPO算法PPO算法的原理PPO-Clip的目标函数 什么是PPO算法 PPO算法，全称为Proximal Policy Optimization（近端策略优化），是一种强化学习算法。它由OpenAI在2017年提出，旨在解决策略梯度方法中的一些问题&…
阅读更多...
带你0到1之QT编程：六、打地基QList的高效用法

带你0到1之QT编程：六、打地基QList的高效用法

此为QT编程的第六谈！关注我，带你快速学习QT编程的学习路线！ 每一篇的技术点都是很很重要！很重要！很重要！但不冗余！ 我们通常采取总-分-总和生活化的讲解方式来阐述一个知识点！ 码…
阅读更多...
【系统架构设计师-2012年】综合知识-答案及详解

【系统架构设计师-2012年】综合知识-答案及详解

更多内容请见： 备考系统架构设计师-核心总结索引 文章目录 【第1~2题】【第3~4题】【第5题】【第6题】【第7题】【第8题】【第9题】【第10~11题】【第12~13题】【第14~19题】【第20~21题】【第22~24题】【第25~26题】【第27~31题】【第32~33题】【第34~36题】【第37…
阅读更多...
南京大学机试试题合集

南京大学机试试题合集

🍰🍰🍰hello宝子们，今天我们来练习南京大学的机试题目，这些题目的缺点就是太老了，都是18或19年的题，大家就练练手。加油！fighting！( •̀ ω •́ )✧ 🍩1161…
阅读更多...
geodatatool（地图资源工具）3.8

geodatatool（地图资源工具）3.8

geodatatool（地图资源工具）3.8（新）修复更新，修复更新包括： 1.优化在线地图多线程下载及用户体验。 注意：在线地图下载与背景地图显示用的是同样的源，所以在线地图是否能下载&#x…
阅读更多...
通过Jflash合并程序以 BOOT + APP 合并为例

通过Jflash合并程序以 BOOT + APP 合并为例

打开【jflash】新建一个JFash工程 建好后界面如下 打开【File】下面的【Open data file…】 找到Boot程序所在位置 打开后界面如下，可以看到hex中的数据 点击【File】下面的【Merge data file…】 打开应用程序 查看APP地址区域是否有数据&#xff0c…
阅读更多...
备战秋招60天算法挑战，Day32

备战秋招60天算法挑战，Day32

题目链接： https://leetcode.cn/problems/house-robber-ii/ 视频题解： https://www.bilibili.com/video/BV1WRYKeKEQE/ LeetCode 213. 打家劫舍 II 题目描述 你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。…
阅读更多...
京东的AIGC革新之旅：通过JoyCoder实现研发提效 | 新程序员

京东的AIGC革新之旅：通过JoyCoder实现研发提效 | 新程序员

【导读】从需求分析、设计编码到测试运维，AI已经逐步渗透到软件开发的各个环节，如何切实针对研发场景进行提效，是业内每个企业都在思考的问题。本文作者详细分析了AI在研发中的实际应用，并分享了JoyCoder与京东内部工具结合的实际…
阅读更多...
一款可以替代Notepad++的免费高级文本编辑器

一款可以替代Notepad++的免费高级文本编辑器

Kate 文本编辑器是一款跨平台的免费高级文本编辑器，具有丰富的功能和特性。它支持标签页、代码高亮、多文件查找、垂直/水平视图、侧边栏、颜色主题等特性，类似于Notepad。它以其多功能性和易用性广受好评。Kate 支持多文档界面（MDI&#xff…
阅读更多...
加密技术.

加密技术.

基本保密通信模型 密码学发展 古典密码学 主要特点：数据的安全基于算法的保密 经典的加密⽅法包括凯撒密码（Caesar Cipher）（替代密码）、维吉尼亚密码（Vigenre Cipher） 主要分类 替代密码&…
阅读更多...
OCR技术视角：智能文档管理中的票据自动化识别与处理

OCR技术视角：智能文档管理中的票据自动化识别与处理

在数字化转型的浪潮中，企业对于高效、自动化的文档管理需求日益增长。票据作为企业运营中不可或缺的部分，其识别与管理的智能化成为了提升工作效率的关键。本文将深入探讨智能文档系统中票据识别功能的原理、技术优势以及在不同行业中的应用实践&#xf…
阅读更多...
【报错已解决】`Solving environment: failed`

【报错已解决】`Solving environment: failed`

🎬 鸽芷咕：个人主页 🔥 个人专栏: 《C干货基地》《粉丝福利》 ⛺️生活的理想，就是为了理想的生活! 文章目录 引言：一、问题描述：1.1 报错示例：1.2 报错分析：1.3 解决思路&#xff…
阅读更多...
智能指针，QT，C++语言的关键字总结

智能指针，QT，C++语言的关键字总结

八、C中关键字总结 1> C中一共有63个关键字，如上图所示，其中标红的为c语言中的关键字，有32个 2> 数据类型相关的关键字 bool、true、false：对于bool类型数据的相关处理，值为true和false char、wchar_t:char是…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023