OC-多线程 1.线程和进程 1.1 线程的定义线程是资源分配的最小单位，也是处理器调度的基本单位；线程是进程的基本

本文已参与新人创作礼活动，一起开启掘金创作之路。

参考文章： GCD 、NSOperation

1.线程和进程

1.1 线程的定义

线程是资源分配的最小单位，也是处理器调度的基本单位；
线程是进程的基本执行单元，一个进程的所有任务都在线程中执行；
进程要想执行任务，必须得有线程，进程至少要有一条线程；
程序启动会默认开启一条线程，这条线程被称为主线程或者 UI 线程。

1.2 进程的定义

进程是资源分配和拥有的单位，同一个进程内的线程共享进程里的资源；
进程是指系统中正在运行的一个应用程序；
每个进程之间是独立的，每个进程均运行在其专用的且受保护的内存。

1.3 线程与进程的区别

地址空间：同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间；
资源拥有：进程是资源分配和拥有的单位，同一个进程内的线程共享进程里的资源，如内存、I/O、CPU等，但是进程之间的资源是独立的；
一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮；
进程切换时，消耗的资源大，效率高。所以涉及到频繁的切换时，使用线程要好于进程。同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程；
执行过程：每个独立的进程有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制；
线程是处理器调度的基本单位，但是进程不是；
多进程，允许多个任务同时运行；多线程，允许单个任务分为不同的部分运行。

1.4 为什么要在主线程更新UI？

安全+效率：因为 UIKit 框架不是线程安全的框架，当在多个线程进行 UI 操作，有可能出现资源抢夺，导致问题。

2.多线程

2.1 多线程的意义

优点：

能适当提高程序的执行效率；
能适当提高资源的利用率（CPU，内存）；
线程上的任务执行完成后，线程会自动销毁；
可以解决程序阻塞的问题。

缺点：

开启线程需要占用一定的内存空间（默认情况下，每一个线程都占 512 KB）；
如果开启大量的线程，会占用大量的内存空间，降低程序的性能；
线程越多，CPU 在调用线程上的开销就越大；
程序设计更加复杂，比如线程间的通信、多线程的数据共享。

2.2 多线程的执行原理

（单核CPU）同一时间，CPU 只能处理一个线程，只有一个线程在执行；
多线程同时执行：是 CPU 在单位时间片里快速在多个线程之间切换；
CPU 调度线程的时间足够快，就造成了多线程“同时”执行；
如果线程数非常多， CPU 会在 n 个线程之间切换，消耗大量的 CPU 资源。每个线程被调度的次数会降低，线程的执行效率降低。

转存失败，建议直接上传图片文件

2.3 iOS中的多线程技术方案

技术方案	简介	语言	线程生命周期	使用频率
pthread	● 一套通用的多线程API ● 适用于Unix\Linux\Windows等系统 ● 跨平台\可移植 ● 使用难度大	C	程序员管理	几乎不用
NSThread	● 使用更加面向对象 ● 简单易用，可直接操作线程对象	OC	程序员管理	偶尔使用
GCD	● 旨在替代NSThread等线程技术 ● 充分利用设备的多核	C	自动管理	经常使用
NSOperation	● 基于GCD（底层是GCD） ● 比GCD多了一些更简单实用的功能 ● 使用更加面向对象	OC	自动管理	经常使用

3. 线程与RunLoop的关系

苹果官方文档：线程编程指南——RunLoop
从苹果官方文档可以看到，RunLoop的相关介绍写在线程编程指南中，可见RunLoop和线程的关系不一般。

RunLoop对象和线程是一一对应关系
RunLoop保存在一个全局的Dictionary里，线程作为key，RunLoop作为value
RunLoop创建时机：线程刚创建时并没有RunLoop对象，RunLoop会在第一次获取它时创建
RunLoop销毁时机：RunLoop会在线程结束时销毁
主线程的RunLoop已经自动获取（创建），子线程默认没有开启RunLoop
主线程的RunLoop对象是在UIApplicationMain中通过[NSRunLoop currentRunLoop]获取，一旦发现它不存在，就会创建RunLoop对象

4.CCD

为什么要用 GCD 呢？

因为 GCD 有很多好处啊，具体如下：

GCD 可用于多核的并行运算
GCD 会自动利用更多的 CPU 内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

4.1 GCD 任务和队列

学习 GCD 之前，先来了解 GCD 中两个核心概念：任务和队列。

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

同步执行（sync）：
- 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
- 只能在当前线程中执行任务，不具备开启新线程的能力。
异步执行（async）：
- 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
- 可以在新的线程中执行任务，具备开启新线程的能力。

举个简单例子：你要打电话给小明和小白。

同步执行就是，你打电话给小明的时候，不能同时打给小白，等到给小明打完了，才能打给小白（等待任务执行结束）。而且只能用当前的电话（不具备开启新线程的能力）。

而异步执行就是，你打电话给小明的时候，不等和小明通话结束，还能直接给小白打电话，不用等着和小明通话结束再打（不用等待任务执行结束）。除了当前电话，你还可以使用其他所能使用的电话（具备开启新线程的能力）。

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关（下面会讲）。

队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。

在 GCD 中有两种队列：串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

串行队列（Serial Dispatch Queue）：

     每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

并发队列（Concurrent Dispatch Queue）：

    可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）

注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效

4.1.1同步任务和异步任务的区别

是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关（下面会讲）。

同步执行（sync）：
- 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
- 只能在当前线程中执行任务，不具备开启新线程的能力。
异步执行（async）：
- 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
- 可以在新的线程中执行任务，具备开启新线程的能力。同步（sync）和异步（async）的主要区别在于会不会阻塞当前线程

如果是同步（sync）操作，它会阻塞当前线程并等待 Block 中的任务执行完毕，然后当前线程才会继续往下运行。

如果是异步（async）操作，当前线程会直接往下执行，它不会阻塞当前线程。

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关（下面会讲）。

同步+串行：未开辟新线程，串行执行任务；
同步+并行：未开辟新线程，串行执行任务；
异步+串行：新开辟一条线程，串行执行任务；
异步+并行：开辟多条新线程，并行执行任务；
在主线程中同步使用主队列执行任务，会造成死锁。

4.1.2 `dispatch_sync`的核心风险：死锁

一、`dispatch_sync`的核心风险：死锁

dispatch_sync的作用是将任务同步提交到队列中，当前线程会被阻塞，直到任务执行完毕。若提交到当前正在执行的串行队列，会立即引发死锁。这与调用线程是主线程还是子线程无关，关键在于队列是否正在被当前线程占用。

示例 1：主线程死锁

objective-c

// 在主线程中执行
dispatch_sync(dispatch_get_main_queue(), ^{
    NSLog(@"任务"); // 死锁！主线程被阻塞，等待任务执行，但任务无法在主线程被阻塞时执行
});

示例 2：子线程死锁

objective-c

// 在子线程中创建并使用串行队列
dispatch_queue_t serialQueue = dispatch_queue_create("com.example.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(serialQueue, ^{
    // 当前子线程正在执行serialQueue的任务
    dispatch_sync(serialQueue, ^{
        NSLog(@"任务"); // 死锁！子线程被阻塞，等待任务执行，但任务无法在队列被占用时执行
    });
});

二、子线程调用`dispatch_sync`的风险分析

子线程调用dispatch_sync本身不会直接导致问题，但以下场景需特别注意：

1. 同步提交到当前串行队列（无论主线程还是子线程）

风险：死锁。
原因：当前线程正在执行队列中的任务，同步提交新任务会阻塞线程，导致原任务无法完成，新任务也无法执行。

2. 同步提交到主队列（无论调用线程是主线程还是子线程）

风险：可能死锁。
原因：若主队列当前有任务正在执行（如 UI 渲染），子线程同步提交到主队列会阻塞主队列，导致原任务无法完成，形成死锁。

示例 3：子线程同步提交到主队列（可能死锁）

objective-c

// 在子线程中执行
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    // 假设此时主线程正在执行某个耗时任务
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"更新UI"); // 若主线程被阻塞，此处会导致死锁
    });
});

3. 同步提交到并行队列（相对安全）

风险：较低，但可能导致线程资源耗尽。
原因：并行队列允许多任务同时执行，通常不会死锁，但大量同步提交会阻塞调用线程，可能导致线程池耗尽。

三、安全使用`dispatch_sync`的原则

永远不要同步提交任务到当前正在执行的串行队列
- 若在主队列中，避免同步提交到主队列。
- 若在自定义串行队列中，避免同步提交到该队列。
同步提交到主队列时需确保主队列未被阻塞
- 若需要在子线程中更新 UI，优先使用dispatch_async而非dispatch_sync。
优先使用dispatch_async
- 同步操作会阻塞线程，影响性能，甚至导致死锁。若非必要（如获取任务返回值），应使用异步提交。
使用屏障函数（Barrier）处理并行队列中的读写冲突
- 若需要在并行队列中执行互斥操作，使用dispatch_barrier_async或dispatch_barrier_sync。

四、替代方案：避免死锁的常用方法

使用dispatch_async异步提交

objective-c

dispatch_async(dispatch_get_main_queue(), ^{
    // 更新UI（安全）
});

使用信号量（dispatch_semaphore）获取返回值

objective-c

__block NSString *result = nil;
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    // 执行耗时操作
    result = [self fetchData];
    dispatch_semaphore_signal(semaphore);
});

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// 使用result（主线程会被阻塞，但避免了死锁）

使用 completion block 回调

objective-c

[self fetchDataWithCompletion:^(NSString *result) {
    // 在回调中处理结果（异步，无死锁风险）
}];

五、总结

死锁核心条件：当前线程持有队列锁，同时尝试同步提交任务到该队列。
子线程调用风险：子线程调用dispatch_sync本身不会直接导致问题，但需注意队列的占用情况。
安全建议：尽量避免使用dispatch_sync，尤其是在不清楚队列状态时。若必须使用，确保任务不会提交到当前正在执行的队列。

1.信号量Dispatch Semaphore

Dispatch Semaphore 在实际开发中主要用于：

dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加1 （解锁）
dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。（加锁）

Dispatch Semaphore 在实际开发中主要用于：

保持线程同步，将异步执行任务转换为同步执行任务我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。比如说：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通过引入信号量的方式，等待异步执行任务结果，获取到 tasks，然后再返回该 tasks。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {

__block NSArray *tasks = nil;

dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

[self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {

if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {

tasks = dataTasks;

} elseif ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {

tasks = uploadTasks;

} elseif ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {

tasks = downloadTasks;

} elseif ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {

tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];

}

\


dispatch_semaphore_signal(semaphore);

}];

\


dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

\


return tasks;

}

保证线程安全，为线程加锁

`/**`

`* 售卖火车票(线程安全)`

`*/`

- (void)saleTicketSafe {

while (1) {

// 相当于加锁

dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);

if (self.ticketSurplusCount > 0) { //如果还有票，继续售卖self.ticketSurplusCount--;

NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);

[NSThread sleepForTimeInterval:0.2];

} else { //如果已卖完，关闭售票窗口NSLog(@"所有火车票均已售完");

// 相当于解锁

dispatch_semaphore_signal(semaphoreLock);

break;

}

// 相当于解锁

dispatch_semaphore_signal(semaphoreLock);

}

}

2.dispatch_barrier_async

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。

dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。

3.GCD 延时执行方法：dispatch_after

我们经常会遇到这样的需求：在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。

4.GCD 一次性代码（只执行一次）：dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 函数。使用dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。

5.GCD 快速迭代方法：dispatch_apply

通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。

我们可以利用并发队列进行异步执行。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以在多个线程中同时（异步）遍历多个数字。

还有一点，无论是在串行队列，还是异步队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

`/**`

`* 快速迭代方法 dispatch_apply`

`*/`

- (void)apply {

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

}

6.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 中，并执行任务。

当所有任务都执行完成之后，才执行dispatch_group_notify block 中的任务。

dispatch_group_wait

暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

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

5. NSOperation

NSOperation、NSOperationQueue 是苹果提供给我们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。

为什么要使用 NSOperation、NSOperationQueue？

可添加完成的代码块，在操作完成后执行。
添加操作之间的依赖关系，方便的控制执行顺序。
设定操作执行的优先级。
可以很方便的取消一个操作的执行。
使用 KVO 观察对操作执行状态的更改：isExecuteing、isFinished、isCancelled。

NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue 我们能更好的实现异步执行。

5.1. NSOperation、NSOperationQueue 操作和操作队列

既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作） 和队列（操作队列） 的概念。

操作（Operation）：
- 执行操作的意思，换句话说就是你在线程中执行的那段代码。
- 在 GCD 中是放在 block 中的。NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作。我们有三种方式来封装操作。

使用子类 NSInvocationOperation
使用子类 NSBlockOperation
自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。

操作队列（Operation Queues）：
- 这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
- 操作队列通过设置最大并发操作数（maxConcurrentOperationCount） 来控制并发、串行。
- NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。
NSOperationQueue 一共有两种队列：主队列、自定义队列。
主队列

凡是添加到主队列中的操作，都会放到主线程中执行
自定义队列（非主队列）
- 添加到这种队列中的操作，就会自动放到子线程中执行。
- 同时包含了：串行、并发功能。

最大并发操作数：maxConcurrentOperationCount

maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
maxConcurrentOperationCount 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。

NSOperation 实现多线程的使用步骤分为三步：

创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
创建队列：创建 NSOperationQueue 对象。
将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。

之后呢，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操作。

5.2NSOperation 操作依赖

- (void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
- (void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

当然，我们经常用到的还是添加依赖操作。现在考虑这样的需求，比如说有 A、B 两个操作，其中 A 执行完操作，B 才能执行操作。

如果使用依赖来处理的话，那么就需要让操作 B 依赖于操作 A。

/**
 * 操作依赖
 * 使用方法：addDependency:
 */
- (void)addDependency {

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.创建操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];

    // 3.添加依赖
    [op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2

    // 4.添加操作到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];
}

OC-多线程

1.线程和进程

1.1 线程的定义

1.2 进程的定义

1.3 线程与进程的区别

1.4 为什么要在主线程更新UI？

2.多线程

2.1 多线程的意义

优点：

缺点：

2.2 多线程的执行原理

2.3 iOS中的多线程技术方案

3. 线程与RunLoop的关系

4.CCD

4.1 GCD 任务和队列

4.1.1同步任务和异步任务的区别

4.1.2 dispatch_sync的核心风险：死锁

一、dispatch_sync的核心风险：死锁

示例 1：主线程死锁

示例 2：子线程死锁

二、子线程调用dispatch_sync的风险分析

1. 同步提交到当前串行队列（无论主线程还是子线程）

2. 同步提交到主队列（无论调用线程是主线程还是子线程）

示例 3：子线程同步提交到主队列（可能死锁）

3. 同步提交到并行队列（相对安全）

三、安全使用dispatch_sync的原则

四、替代方案：避免死锁的常用方法

五、总结

4.2 GCD 的具体使用

1.信号量Dispatch Semaphore

2.dispatch_barrier_async

3.GCD 延时执行方法：dispatch_after

4.GCD 一次性代码（只执行一次）：dispatch_once

5.GCD 快速迭代方法：dispatch_apply

6.GCD 队列组：dispatch_group

dispatch_group_notify

dispatch_group_wait

dispatch_group_enter、dispatch_group_leave

5. NSOperation

5.1. NSOperation、NSOperationQueue 操作和操作队列

5.2NSOperation 操作依赖

4.1.2 `dispatch_sync`的核心风险：死锁

一、`dispatch_sync`的核心风险：死锁

二、子线程调用`dispatch_sync`的风险分析

三、安全使用`dispatch_sync`的原则