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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

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

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

《实战纪录片 1 》原生开发小程序中遇到的问题和解决方案 文章目录 《实战纪录片 1 》原生开发小程序中遇到的问题和解决方案1、问题一：原生开发中 request请求中返回 的数据无法 使用this传递给 data{}中怎么办？2、刚登录后如何将token信息保存&#xf…
阅读更多...
智汇云舟荣膺国家级专精特新“小巨人”企业称号

智汇云舟荣膺国家级专精特新“小巨人”企业称号

近日，北京市经济和信息化局发布了经工业和信息化部审核的第六批专精特新“小巨人”企业名单，智汇云舟凭借其在视频孪生领域的卓越贡献和技术实力成功入选，荣膺国家级专精特新“小巨人”企业称号。 专精特新“小巨人”，是目前全国中…
阅读更多...
PDF 全文多语言 AI 摘要 API 数据接口

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

PDF 全文多语言 AI 摘要 API 数据接口 PDF / 文本摘要 AI 生成 PDF 文档摘要 AI 处理 / 智能摘要。 1. 产品功能 支持多语言摘要生成；支持 formdata 格式 PDF 文件流传参；快速处理大文件；基于 AI 模型，持续迭代优化；…
阅读更多...
【鸿蒙开发工具报错】Build task failed. Open the Run window to view details.

【鸿蒙开发工具报错】Build task failed. Open the Run window to view details.

Build task failed. Open the Run window to view details. 问题描述 在使用deveco-studio 开发工具进行HarmonyOS第一个应用构建开发时，通过Previewer预览页面时报错，报错信息为：Build task failed. Open the Run window to view details.…
阅读更多...
哈希表，算法

哈希表，算法

一.什么是哈希表 哈希表是一种用于快速数据存取的数据结构。它通过哈希函数将键（key）映射到表中的一个位置，从而实现高效的插入、删除和查找操作。 二.哈希冲突 哈希冲突发生在多个键通过哈希函数映射到哈希表的同一位置时。由于哈希表的大…
阅读更多...
【专题】2024年中国游戏出海洞察报告合集PDF分享（附原数据表）

【专题】2024年中国游戏出海洞察报告合集PDF分享（附原数据表）

原文链接：https://tecdat.cn/?p37570 2023 年全球游戏市场规模高达 6205.2 亿美元，且预计未来持续增长，这清晰地展示了该市场的巨大潜力和良好前景。 中国游戏在全球移动游戏市场的份额于 2023 年已达 37%，产业贡献超 30% 的市场…
阅读更多...
Redis主从数据同步过程：命令传播、部分重同步、复制偏移量等

Redis主从数据同步过程：命令传播、部分重同步、复制偏移量等

请记住胡广一句话，所有的中间件所有的框架都是建立在基础之上，数据结构，计算机网络，计算机原理大伙一定得看透！！~ 1. Redis数据同步 1.1 数据同步过程 大家有没想过为什么Redis多机要进行数据同步&#…
阅读更多...
[数据集][目标检测]水面垃圾检测数据集VOC+YOLO格式2027张1类别

[数据集][目标检测]水面垃圾检测数据集VOC+YOLO格式2027张1类别

数据集格式：Pascal VOC格式YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)：2027 标注数量(xml文件个数)：2027 标注数量(txt文件个数)：2027 标注…
阅读更多...
SAP 免费学习网站推荐

SAP 免费学习网站推荐

1、https://www.guru99.com/ 可以看到有很多的开发语言可以学习。其中就有SAP。 点击SAP菜单后，可以看到每个模块的操作 每个模块下面都有操作的截图，结合翻译软件看的话很容易看懂 2、https://community.sap.com/ 这个是SAP官方的社区&#xff0c…
阅读更多...
[数据结构] 开散列法 闭散列法 模拟实现哈希结构（一）

[数据结构] 开散列法 闭散列法 模拟实现哈希结构（一）

标题：[数据结构] 开散列法 && 闭散列法 模拟实现哈希结构 个人主页：水墨不写bug 目录 一、闭散列法 核心逻辑的解决 i、为什么要设置位置状态？（伪删除法的使用） ii、哈希函数的设计 接口的实现 1、插入&a…
阅读更多...
STM32 RTC实时时钟

STM32 RTC实时时钟

RTC实时时钟 BKP可以在VBAT维持供电时，完成主电源掉电时，保存少量数据的任务。备份寄存器和VBAT引脚同时存在，更多是为了服务RTC的。 目前，Linux、Windows、安卓这些系统，底层的计时系统都是使用的Unix时间戳&#xf…
阅读更多...
网络编程（UDP）

网络编程（UDP）

UDP编程 UDP：全双工通信、面向无连接、不可靠 UDP（User Datagram Protocol）用户数据报协议，是不可靠的无连接的协议。在数据发送前，因为不需要进行连接，所以可以进行高效率的数据传输。 适用场景 发送小尺寸…
阅读更多...
Anaconda安装和环境配置教程（深度学习准备）

Anaconda安装和环境配置教程（深度学习准备）

目录 1.下载选择 2.prompt配置 3.虚拟环境配置 4.检查是不是安装成功 5.安装jupter 6.关闭anaconda重新进入 7.总结 1.下载选择 我第一次使用的这个官网上面的邮箱的方式下载的，但是这个方式真的特别慢，于是用了这个清华的镜像网站，网…
阅读更多...
基于JAVA+SpringBoot+Vue的工程教育认证的计算机课程管理平台

基于JAVA+SpringBoot+Vue的工程教育认证的计算机课程管理平台

基于JAVASpringBootVue的工程教育认证的计算机课程管理平台 前言 ✌全网粉丝20W,csdn特邀作者、博客专家、CSDN[新星计划]导师、java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ 🍅文末附源码下载链接…
阅读更多...
简单比较 http https http2，我们要如何把http升级为https

简单比较 http https http2，我们要如何把http升级为https

🧑‍💻 写在开头 点赞 收藏 学会🤣🤣🤣 什么是HTTP 超文本传输​​协议（HTTP）是用于传输诸如HTML的超媒体文档的应用层协议。它被设计用于Web浏览器和Web服务器之间的通信，但它也…
阅读更多...
合宙LuatOS开发板Core_Air780EP使用说明

合宙LuatOS开发板Core_Air780EP使用说明

Core-Air780EP 开发板是合宙通信推出的基于 Air780EP 模组所开发的， 包含电源，SIM卡，USB，天线，音频等必要功能的最小硬件系统。 以方便用户在设计前期对 Air780EP模块进行性能评估，功能调试，软…
阅读更多...
精益生产现场管理和改善的实战路径

精益生产现场管理和改善的实战路径

精益生产，作为制造业的革新利器，不仅能够帮助企业降低成本、提升质量，还能大幅度提高生产效率。但如何将这一理念从理论转化为实际行动，真正落地于生产现场，成为许多管理者面临的难题。今天，就让天行健咨询…
阅读更多...
AXI4主机测试

AXI4主机测试

前面对AXI4协议进行了比较详细的分析，本篇文章将会写一个主机代码来实现AXI4协议的时序。 设计思路：本次设计的主要目的是验证AXI4_FULL总线的时序，并且提升对AXI4_FULL总线协议的理解，因此可以采用状态机来控制，先向…
阅读更多...
免费SSL证书正在逐渐被淘汰，证书部署自动化的发展趋势即将到来！

免费SSL证书正在逐渐被淘汰，证书部署自动化的发展趋势即将到来！

目录 背景解决方案。1.使用自签证书（浏览器报警、免费）2.更换支持自签自续的CA机构（免费）3.付费选择CA机构 免费SSL证书正在逐渐被淘汰，证书部署自动化的发展趋势即将到来免费的SSL证书有以下弊端1.有效期短&#xff1…
阅读更多...
【数据结构(初阶)】——二叉树

【数据结构(初阶)】——二叉树

【数据结构】——二叉树 文章目录 【数据结构】——二叉树前言1. 树的概念及结构1.1 树的概念1.2 树的结构 2. 二叉树的概念及结构2.1 二叉树的概念2.2 二叉树的结构2.3 二叉树的性质 3. 二叉树顺序结构及概念3.1 二叉树的顺序结构3.2 堆的概念及结构3.3 堆的实现3.3.1 堆的基本…
阅读更多...
最新文章

Copyright @ 2022~2023