iOS多线程 - GCD 详解

作者: Ostkaka丶 | 来源:发表于2016-10-15 15:19 被阅读0次

前言

嘿嘿嘿，精品。

之前写了一篇iOS多线程汇总，地址如下
http://www.jianshu.com/p/2642138d6bef
这里对GCD进行详细补充

概述

全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”。
纯C语言，提供了非常多强大的函数。

优势

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

任务和队列

GCD中有两个核心概念

任务：执行什么操作
队列：用来存放任务

使用GCD两个步骤

定制任务
- 确定想做的事
确定想做的事情,将任务添加到队列中
- GCD会自动将队列中的任务取出，放到对应的线程中执行。

GCD会自动将队列中的任务取出，放到对应的线程中执行
任务的取出遵循队列的FIFO原则：先进先出，后进后出

执行任务

GCD中有两个用来执行任务的函数
- 用同步的方式执行任务

// queue：队列
// block：任务

dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

用异步的方式执行任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

同步和异步的区别
- 同步：只能在当前线程中执行任务，不具备开启新线程的能力
- 异步：可以在新的线程中执行任务，具备开启新线程的能力

添加队列

GCD的队列可以分为两大类型
- 并发队列（Concurrent Dispatch Queue）
  - 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
  - 并发功能只有在异步（dispatch_async）函数下才有效
- 串行队列（Serial Dispatch Queue）
  - 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

易混术语

有4个术语比较容易混淆：同步、异步、并发、串行
同步和异步主要影响：能不能开启新的线程
- 同步：在当前线程中执行任务，不具备开启新线程的能力
- 异步：在新的线程中执行任务，具备开启新线程的能力
并发和串行主要影响：任务的执行方式
- 并发：多个任务并发（同时）执行
- 串行：一个任务执行完毕后，再执行下一个任务

并发队列

GCD默认已经提供了全局的并发队列，供整个应用使用，不需要手动创建
使用dispatch_get_global_queue函数获得全局的并发队列

dispatch_queue_t dispatch_get_global_queue(
dispatch_queue_priority_t priority, // 队列的优先级
unsigned long flags); // 此参数暂时无用，用0即可
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 获得全局并发队列

手动创建并发队列
- 参数1：队列标识
- 参数2：队列类型

dispatch_queue_t concurrentQueue = dispatch_queue_create("CONCURRENT", DISPATCH_QUEUE_CONCURRENT);

全局并发队列的优先级

#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

串行队列

GCD中获得串行有两种途径
- 手动创建串行队列
- 使用dispatch_queue_create函数创建串行队列

// "SERIAL" 是一个标识符，可以自己填写，通常填写com.公司的域名
dispatch_queue_t serialQueue = dispatch_queue_create("SERIAL", DISPATCH_QUEUE_SERIAL);
// 或者
dispatch_queue_t serialQueue = dispatch_queue_create("SERIAL", NULL);
dispatch_release(queue); // 非ARC需要释放手动创建的队列


- 使用主队列（跟主线程相关联的队列）

- 主队列是GCD自带的一种特殊的串行队列

- 放在主队列中的任务，都会放到主线程中执行

- 使用dispatch_get_main_queue()获得主队列

dispatch_queue_t queue = dispatch_get_main_queue();


####各种队列的执行效果

![](https://img.haomeiwen.com/i2595997/971676ca92a8a6fa.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

![](https://img.haomeiwen.com/i2595997/cf291e35f32f7629.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 小知识：同步函数立刻执行，异步函数会等待自身所存在方法结束后才执行。

- 注意：
  - 使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列,叫做死锁（有些像把串行队列嵌套）(下面会做详细说明).。

#死锁
------
#### 搞清线程（Thread）和队列（Queue）的区别
网上一些讲解关于GCD死锁的文章，有一些非常明显的错误，比如：认为死锁的原因是线程阻塞造成的，这是非常大的误解，GCD死锁的原因是队列阻塞，而不是线程阻塞！


![](https://img.haomeiwen.com/i2595997/e0dbda73028aa1b7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

在开发中，我们会把block，也就是我们想做的任务，交给GCD函数。GCD函数会把任务放进我们指定的队列（Queue），当然GCD函数内部不止是把任务放进队列，还包括一些其他不为我们所知的操作。队列遵循严格的先进先出原则，同一个Queue中，最早入列的block，会最早被分配给线程执行。系统（“系统”指所有被苹果黑盒封装，未公开源码，我们不能得知的操作，下同）会依据顺序从队列中取出block，并且交由线程执行。GCD队列只是组织待执行任务的一个数据结构封装，而线程，才是执行任务的人。

#### 程序执行顺序

要往下面讲，不得不回顾一个再基础不过的知识点，我想，这是每一个程序员，入门就知道的超级简单的知识。虽然它非常基础，但是，这正是造成我们GCD死锁的重要因素。很多困难的问题，它们背后隐藏的东西往往非常简单，因为事物永远不会脱离本质。

让我们来看看下面的这个C程序：

include <stdio.h>

void printFiveNumbers(){
printf("开始执行printFiveNumbers函数了\n");
for (int i = 0; i < 5; i++) {
printf("printFiveNumbers - %d\n",i);
}
printf("执行完printFiveNumbers函数了\n");
}

//main函数是程序的入口
int main(){
printf("main函数开始执行了\n");
printFiveNumbers();
printf("main函数执行完了\n");
return 0;
}



![](https://img.haomeiwen.com/i2595997/4579d283d6031841.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

大家都知道，运行的结果是怎么样了，程序的入口是main函数，于是Run这个程序后，马上就会进入main函数执行，执行了第一句打印后，会跳入printFiveNumbers这个函数执行，直到printFiveNumbers执行完，才会返回到main函数继续执行下一句。重点是：外层方法会等待内层方法返回后，再执行下一句指令。就好像把printFiveNumbers函数的所有语句，都复制粘贴到了main方法里一样。

#### GCD死锁的本质

让我们看看下面这个程序：

override func viewDidLoad() {
super.viewDidLoad()
print("Start (NSThread.currentThread())")
//GCD同步函数
dispatch_sync(dispatch_get_main_queue(), {
for i in 0...100{
print("(i) (NSThread.currentThread())")
}
})
print("End (NSThread.currentThread())")
}


![](https://img.haomeiwen.com/i2595997/3b6780b255265357.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)


这个程序就是典型的死锁，可以看到，只打印了“Start”一行，就再也没有响应了，已经造成了GCD死锁。为什么会这样呢？让我们来解读一下这段程序的运行顺序：首先会打印“Start”，然后将主队列和一个block传入GCD同步函数dispatch_sync中，等待sync函数执行，直到它返回，才会执行打印“End”的语句。可是，竟然没有反应了？block中的101个数字没有被打印出来任何一个，viewDidLoad()中的End也没有被打印出来。也就是说，block没有得到执行的机会，viewDidLoad也没有继续执行下去。为什么block不执行呢？因为viewDidLoad也是执行在主队列的，它是正在被执行的任务，也就是说，viewDidLoad()是主队列的队头。主队列是串行队列，任务不能并发执行，同时只能有一个任务在执行，也就是队头的任务才能被出列执行。我们现在被执行的任务是viewDidLoad()，然后我们又将block入列到同一个队列，它比viewDidLoad()后入列，遵循先进先出的原理，它必须等到viewDidLoad()执行完，才能被执行。但是，dispatch_sync函数的特性是，等待block被执行完毕，才会返回，因此，只要block一天不被执行，它就一天不返回。我们知道，内部方法不返回，外部方法是不会执行下一行命令的。不等到sync函数返回，viewDidLoad打死也不会执行print End的语句，因此，viewDidLoad()一直没有执行完毕。block在等待着viewDidLoad(）执行完毕，它才能上，sync函数在等待着block执行完毕，它才能返回，viewDidLoad(）在等待着sync函数返回，它才能执行完毕。这样的三方循环等待关系，就造成了死锁。


也许文字描述比较抽象，我们再来配一幅图：

![](https://img.haomeiwen.com/i2595997/8ee6429e8fef13b6.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

可以这么理解：每一个队列，有自己的执行室，串行队列的执行室，只能容纳一个任务，并发队列的执行室，可以同时容纳若干个任务。队头的任务，只要执行室有空位，就会被放入执行室执行。viewDidLoad任务在执行中，我们的主队列又是串行队列，执行室只能容纳一个任务，那么队头的block就需要等待viewDidLoad执行完毕才能进入执行室，那么就造成了，viewDidLoad永远不会执行完毕，block永远不能执行。

![](https://img.haomeiwen.com/i2595997/9ab1702b34fc39b9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

sync函数永远不能返回，最终，就是GCD死锁。

- 那么我们可以总结出GCD被阻塞（blocking）的原因有以下两点：
    1. GCD函数未返回，会阻塞正在执行的任务

    2. 队列的执行室容量太小，在执行室有空位之前，会阻塞同一个队列中在等待的任务

- 注意：阻塞（blocking）和死锁（deadlock）是不同的意思，阻塞表示需要等待A事件完成后才能完成B事件，称作A会阻塞B，通俗来讲就是强制等待的意思。而死锁表示由于某些互相阻塞，也就是互相的强制等待，形成了闭环，导致大家永远互相阻塞下去了，Always and Forever，也就是死锁。

#### 解决GCD死锁
我们已经有结论，造成GCD死锁，是由于同时具备以下两点因素：
1. GCD函数未返回，会阻塞正在执行的任务

2. 队列的执行室容量太小，在执行室有空位之前，会阻塞同一个队列中在等待的任务

死锁是由于阻塞闭环造成的，那么我们只用消除其中一个因素，就能打破这个闭环，避免死锁。

#######方法1: 解决GCD函数未返回造成的阻塞

- 先提出下面两个知识点:
  - dispatch_sync是同步函数，不具备开启新线程的能力，交给它的block，只会在当前线程执行，不论你传入的是串行队列还是并发队列，并且，它一定会等待block被执行完毕才返回。
  - dispatch_async是异步函数，具备开启新线程的能力，但是不一定会开启新县城，交给它的block，可能在任何线程执行，开发者无法控制，是GCD底层在控制。它会立即返回，不会等待block被执行。



- 注意：以上两个知识点，有例外，那就是当你传入的是主队列，那两个函数都一定会安排block在主线程执行。记住，主队列是最特殊的队列

只要看懂了以上两个知识点，大家就知道，sync函数未返回会造成阻塞，只要换成aysnc函数，就会立即返回，而不会等待block执行，那么GCD函数未返回这个阻塞因素就会被解决掉。不用大家也不要盲目的换函数，毕竟两个函数是有不同之处的，要考虑实际期望。


#######方法2: 解决队列（Queue）阻塞
解决队列阻塞，有两种方法：

1. 为队列的执行室扩容，让它可以并发执行多个任务，那么就不会因为A任务，造成B任务被阻塞了。
2. 把A和B任务放在两个不同的队列中，A就再也没有机会阻塞B了。因为每个队列都有自己的执行室。

首先来说第一个思路，如何为队列的执行室扩容呢？我们当然没有办法为执行室扩容，但是我们可以选择用容量大的队列。使用并发队列替代串行队列。因为并发队列的执行室可以同时容纳若干任务


再来说第二个思路，我们来看代码：

override func viewDidLoad() {
super.viewDidLoad()
print("Start (NSThread.currentThread())")
let serialQueue = dispatch_queue_create("这是一个串行队列", DISPATCH_QUEUE_SERIAL)
dispatch_sync(serialQueue, {
for i in 0...100{
print("(i) (NSThread.currentThread())")
}
})
print("End (NSThread.currentThread())")
}


![](https://img.haomeiwen.com/i2595997/85381d8d2ab036b5.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

我们自己新建了一个串行队列，将block放入自己的串行队列，不再和viewDidLoad()处于一个队列，解决了队列阻塞，因此避免了死锁问题。
网上有一些帖子说“在主线程使用sync函数就会造成死锁”或者“在主线程使用sync函数，同时传入串行队列就会死锁”，都是非常错误的观念，希望大家能够真正理解GCD死锁的原理，而不是死记硬背。


# 其他
-----

 GCD还有一些其他用法，这里也都提一下。

####  线程间通信示例


从子线程回到主线程

dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行耗时的异步操作...
dispatch_async(dispatch_get_main_queue(), ^{
// 回到主线程，执行UI刷新操作
});
});


#### 快速迭代
快速遍历，当我们需要遍历一些耗时操作，需要它们同时进行，可以使用dispatch_apply，比如下面的例子是把一个文件夹中的所有文件剪切到另一个文件夹中，所有文件近乎同时剪切。

(void)apply
{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSString *from = @"/Users/Ostkaka/Desktop/From";
NSString *to = @"/Users/Ostkaka/Desktop/To";

NSFileManager *mgr = [NSFileManager defaultManager];
NSArray *subpaths = [mgr subpathsAtPath:from];

dispatch_apply(subpaths.count, queue, ^(size_t index) {
NSString *subpath = subpaths[index];
NSString *fromFullpath = [from stringByAppendingPathComponent:subpath];
NSString *toFullpath = [to stringByAppendingPathComponent:subpath];
// 剪切
[mgr moveItemAtPath:fromFullpath toPath:toFullpath error:nil];
```
  NSLog(@"%@---%@", [NSThread currentThread], subpath);
```
});
}


#### 栅栏
如果不加dispatch_barrier_async()这行代码，会开辟四条线程无序执行，添加之后会先执行它之前的，结束后执行它之后的。

不过注意一点，这里一定要创建新的并发队列，用global是不可以的。

(void)barrier
{
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{
NSLog(@"----1-----%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"----2-----%@", [NSThread currentThread]);
});

dispatch_barrier_async(queue, ^{
NSLog(@"----barrier-----%@", [NSThread currentThread]);
});

dispatch_async(queue, ^{
NSLog(@"----3-----%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"----4-----%@", [NSThread currentThread]);
});
}



#### 延时执行

- iOS常见的延时执行有3种方式

  - 调用NSObject的方法

[self performSelector:@selector(run) withObject:nil afterDelay:2.0];
// 2秒后再调用self的run方法

- 使用GCD函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后异步执行这里的代码...
});

- NSTimer

[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(run) userInfo:nil repeats:NO];




#### 队列组

- 有这么1种需求

- 首先：分别异步执行2个耗时的操作

- 其次：等2个异步操作都执行完毕后，再回到主线程执行操作

- 如果想要快速高效地实现上述需求，可以考虑用队列组

dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程...
});


#### 一次性代码

使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次

static dispatch_once_t onceToken; //记录是否被执行
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});


#### 单例模式

- 作用
    - 可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问，从而方便地控制了实例个数，并节约系统资源

- 使用场合

    - 在整个应用程序中，共享一份资源（这份资源只需要创建初始化1次）

- 单例模式在ARC\MRC环境下的写法有所不同，需要编写2套不同的代码

- 可以用宏判断是否为ARC环境

if __has_feature(objc_arc)

// ARC

else

// MRC

endif


#### 单例模式（ARC）

// 在.m中保留一个全局的static的实例
static id _instance;

// 重写allocWithZone:方法，在这里创建唯一的实例（注意线程安全）

(id)allocWithZone:(struct _NSZone *)zone
{
@synchronized(self) {
if (!_instance) {
_instance = [super allocWithZone:zone];
}
}
return _instance;
}


提供1个类方法让外界访问唯一的实例

(instancetype)sharedSoundTool
{
@synchronized(self) {
if (!_instance) {
_instance = [[self alloc] init];
}
}
return _instance;
}


实现copyWithZone:方法

(id)copyWithZone:(struct _NSZone *)zone
{
return _instance;
}


#### 单例模式 – MRC

- MRC里，单例模式的实现（比ARC多了几个步骤）

- 实现内存管理方法

(id)retain { return self; }
(NSUInteger)retainCount { return 1; }
(oneway void)release {}
(id)autorelease { return self; }


# 心灵鸡汤
------

禅房里，这个整日被嫉妒、浮躁、忧虑所困扰的年轻人面对慈祥、超然的禅师，一股脑儿倒出了自己的不幸。禅师笑笑，伸出右手，握成拳头，“你试试看。”年轻人照做。“再握得紧一些。”“再紧一些······”于是年轻人把拳头握得越来越紧。“感觉如何？”禅师慈祥的问道。年轻人茫然的摇了摇头。禅师说：好，现在可以上下动了。


海的平凡是因为它源于一点一滴,海的伟大是因为它能容纳千江万河,还有海鲜. 

![](https://img.haomeiwen.com/i2595997/bc7155a7fa32a65b.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

iOS多线程 - GCD 详解

前言

概述

优势

任务和队列

GCD中有两个核心概念

使用GCD两个步骤

执行任务

添加队列

易混术语

并发队列

串行队列

include <stdio.h>

if __has_feature(objc_arc)

else

endif

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOS Developer

程序员