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，也就是默认优先级。可以通过服务质量类值来获取不同优先级的全局并发队列。

六种组合方式

同步执行+并发队列

有如下代码：

objc 复制代码

- (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]);
    });
}

执行结果：

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

按顺序执行的原因：虽然并发队列可以开启多个线程，并且同时执行多个任务。

但是因为本身不能创建新线程，只有当前线程这一个线程（同步任务不具备开启新线程的能力），所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后，才能继续接着执行下面的操作（同步任务需要等待队列的任务执行结束）。

所以任务只能一个接一个按顺序执行，不能同时被执行。

同步执行+串行队列

objc 复制代码

- (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]);
    });
}

运行结果：

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

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

异步执行+串行队列

objc 复制代码

- (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");
}

执行结果：

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

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

异步执行+并发队列

objc 复制代码

- (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 个线程，并且任务是交替/同时执行的。（异步执行具备开启新线程的能力。且并发队列可开启多个线程，同时执行多个任务）。

说明当前线程没有等待，而是直接开启了新线程，在新线程中执行任务（异步执行不做等待，可以继续执行任务）。

同步执行+主队列

objc 复制代码

- (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。所以这里不会卡住线程，也就不会造成死锁问题。

异步执行+主队列

objc 复制代码

/**
 * 异步执行 + 主队列
 * 特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务
 */
- (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方法:

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

有如下代码：

objc 复制代码

- (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

objc 复制代码

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 也可以保证线程安全。

objc 复制代码

- (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方法。

objc 复制代码

- (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 中，并执行任务

objc 复制代码

- (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 中的任务。

objc 复制代码

- (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 在实际开发中主要用于：

保持线程同步，将异步执行任务转换为同步执行任务
保证线程安全，为线程加锁

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

有如下代码：

objc 复制代码

- (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);
    
}

执行结果：

执行顺序如下：

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

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

线程池

线程池流程图如下：

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

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

死锁问题

场景一：

objc 复制代码

- (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执行完才能执行，因此两个任务互相卡住了，发生了死锁。

场景二：

objc 复制代码

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