iOS并发编程

在 iOS 开发中,我们主要可以通过 Operation Queues、Dispatch Queues 和 Dispatch Sources 来提高应用的并发性,需要做的就是尽可能地提高应用的并发性,来充分利用这些多核心 CPU 的性能

  • 进程: 指的是一个正在运行中的可执行文件。每一个进程都拥有独立的虚拟内存空间和系统资源,包括端口权限等,且至少包含一个主线程和任意数量的辅助线程。另外,当一个进程的主线程退出时,这个进程就结束了
  • 线程: 指的是一个独立的代码执行路径,也就是说线程是代码执行路径的最小分支。在 iOS 中,线程的底层实现是基于 POSIX threads API 的,也就是我们常说的 pthreads
  • 任务: 指的是我们需要执行的工作,是一个抽象的概念,用通俗的话说,就是一段代码

串行 – 并发

队列的特点:先进先出,排在前面的任务最先执行.
从本质上来说,串行和并发的主要区别在于允许同时执行的任务数量。串行,指的是一次只能执行一个任务,必须等一个任务执行完成后才能执行下一个任务;并发,则指的是允许多个任务同时执行,并发功能只有在异步(dispatch_async)函数下才有效。

同步 – 异步

同样的,同步和异步操作的主要区别在于是否等待操作执行完成,亦即是否阻塞当前线程。同步操作会等待操作执行完成后再继续执行接下来的代码,而异步操作则恰好相反,它会在调用后立即返回,不会等待操作的执行结果。

同步执行(dispatch_sync):只能在当前线程中执行任务,不具备开启新线程的能力

异步执行(dispatch_async):可以在新的线程中执行任务,具备开启新线程的能力

队列 – 线程

在 iOS 中,有两种不同类型的队列,分别是串行队列和并发队列。正如我们上面所说的,串行队列一次只能执行一个任务,而并发队列则可以允许多个任务同时执行。iOS 系统就是使用这些队列来进行任务调度的,它会根据调度任务的需要和系统当前的负载情况动态地创建和销毁线程,而不需要我们手动地管理。

NSOperation有两个常用子类用于创建线程操作:NSInvocationOperation和NSBlockOperation,两种方式本质没有区别,但是是后者使用Block形式进行代码组织,使用相对方便。

GCD:是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务
GCD的其他方法:

  1. GCD的栅栏方法dispatch_barrier_async
  2. GCD的延时执行方法dispatch_after
  3. GCD的一次性代码(只执行一次)dispatch_once
  4. GCD的快速迭代方法dispatch_apply
  5. GCD的队列组dispatch_group

  6. 创建一个队列(串行队列或并发队列)

  7. 将任务添加到队列中,然后系统就会根据任务类型执行任务(同步执行或异步执行)

队列的创建方法

  • 可以使用dispatch_queue_create来创建对象,需要传入两个参数,
    1. 第一个参数表示队列的唯一标识符,用于DEBUG,可为空;
    2. 第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL表示串行队列,DISPATCH_QUEUE_CONCURRENT表示并发队列
1
2
3
4
// 串行队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
3. 对于并发队列,还可以使用dispatch_get_global_queue来创建全局并发队列。GCD默认提供了全局的并发队列,需要传入两个参数。第一个参数表示队列优先级,一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用,用0即可
  • 任务的创建方法
1
2
3
4
5
6
7
8
// 同步执行任务创建方法
dispatch_sync(queue, ^{
NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码
});

虽然使用GCD只需两步,但是既然我们有两种队列,两种任务执行方式,那么我们就有了四种不同的组合方式。这四种不同的组合方式是

并发队列 + 同步执行

并发队列 + 异步执行

串行队列 + 同步执行

串行队列 + 异步执行

实际上,我们还有一种特殊队列是主队列

主队列 + 同步执行

主队列 + 异步执行

主队列:专门用来在主线程调度任务的队列,所以主队列的任务都要在主线程来执行,主队列会随着程序的启动一起创建,我们只需get即可

全局队列:是系统为了方便程序员开发提供的,其工作表现与并发队列一致

pic

GCD实现原理

GCD有一个底层线程池,这个池中存放的是一个个的线程。之所以称为“池”,很容易理解出这个“池”中的线程是可以重用的,当一段时间后这个线程没有被调用胡话,这个线程就会被销毁

并发队列 + 同步执行

  • 不会开启新线程,执行完一个任务,再执行下一个任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (void) syncConcurrent
{
NSLog(@"syncConcurrent---begin");
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"syncConcurrent---end");
}

输出结果:
2016-09-03 19:22:27.577 GCD[11557:1897538] >syncConcurrent—begin
2016-09-03 19:22:27.578 GCD[11557:1897538] 1——{number = 1, name = main}
2016-09-03 19:22:27.578 GCD[11557:1897538] 1——{number = 1, name = main}
2016-09-03 19:22:27.578 GCD[11557:1897538] 2——{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] 2——{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] 3——{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] 3——{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] syncConcurrent—end

  1. 从并发队列 + 同步执行中可以看到,所有任务都是在主线程中执行的。由于只有一个线程,所以任务只能一个一个执行。
  2. 同时我们还可以看到,所有任务都在打印的syncConcurrent—begin和syncConcurrent—end之间,这说明任务是添加到队列中马上执行的。

并发队列 + 异步执行

可同时开启多线程,任务交替执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (void) asyncConcurrent
{
NSLog(@"asyncConcurrent---begin");
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"asyncConcurrent---end");
}

输出结果:
2016-09-03 19:27:31.503 GCD[11595:1901548] asyncConcurrent—begin
2016-09-03 19:27:31.504 GCD[11595:1901548] asyncConcurrent—end
2016-09-03 19:27:31.504 GCD[11595:1901626] 1——{number = 2, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901625] 2——{number = 4, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901855] 3——{number = 3, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901626] 1——{number = 2, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901625] 2——{number = 4, name = (null)}
2016-09-03 19:27:31.505 GCD[11595:1901855] 3——{number = 3, name = (null)}

  1. 在并发队列 + 异步执行中可以看出,除了主线程,又开启了3个线程,并且任务是交替着同时执行的。
  2. 另一方面可以看出,所有任务是在打印的syncConcurrent—begin和syncConcurrent—end之后才开始执行的。说明任务不是马上执行,而是将所有任务添加到队列之后才开始异步执行。

串行队列 + 同步执行

不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (void) syncSerial
{
NSLog(@"syncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"syncSerial---end");
}

输出结果为:
2016-09-03 19:29:00.066 GCD[11622:1903904] syncSerial—begin
2016-09-03 19:29:00.067 GCD[11622:1903904] 1——{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 1——{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 2——{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 2——{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 3——{number = 1, name = main}
2016-09-03 19:29:00.068 GCD[11622:1903904] 3——{number = 1, name = main}
2016-09-03 19:29:00.068 GCD[11622:1903904] syncSerial—end

  1. 在串行队列 + 同步执行可以看到,所有任务都是在主线程中执行的,并没有开启新的线程。而且由于串行队列,所以按顺序一个一个执行。
  2. 同时我们还可以看到,所有任务都在打印的syncConcurrent—begin和syncConcurrent—end之间,这说明任务是添加到队列中马上执行的。

串行队列 + 异步执行

会开启新线程,但是因为任务是串行的,执行完一个任务,再执行下一个任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (void) asyncSerial
{
NSLog(@"asyncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"asyncSerial---end");
}

输出结果为:
2016-09-03 19:30:08.363 GCD[11648:1905817] asyncSerial—begin
2016-09-03 19:30:08.364 GCD[11648:1905817] asyncSerial—end
2016-09-03 19:30:08.364 GCD[11648:1905895] 1——{number = 2, name = (null)}
2016-09-03 19:30:08.364 GCD[11648:1905895] 1——{number = 2, name = (null)}
2016-09-03 19:30:08.364 GCD[11648:1905895] 2——{number = 2, name = (null)}
2016-09-03 19:30:08.364 GCD[11648:1905895] 2——{number = 2, name = (null)}
2016-09-03 19:30:08.365 GCD[11648:1905895] 3——{number = 2, name = (null)}
2016-09-03 19:30:08.365 GCD[11648:1905895] 3——{number = 2, name = (null)}
在串行队列 + 异步执行可以看到,开启了一条新线程,但是任务还是串行,所以任务是一个一个执行。

另一方面可以看出,所有任务是在打印的syncConcurrent—begin和syncConcurrent—end之后才开始执行的。说明任务不是马上执行,而是将所有任务添加到队列之后才开始同步执行。

主队列 + 同步执行

互等卡住不可行(在主线程中调用)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (void)syncMain
{
NSLog(@"syncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"syncMain---end");
}

输出结果
2016-09-03 19:32:15.356 GCD[11670:1908306] syncMain—begin

这时候,我们惊奇的发现,在主线程中使用主队列 + 同步执行,任务不再执行了,而且syncMain—end也没有打印。这是为什么呢?

这是因为我们在主线程中执行这段代码。我们把任务放到了主队列中,也就是放到了主线程的队列中。而同步执行有个特点,就是对于任务是立马执行的。那么当我们把第一个任务放进主队列中,它就会立马执行。但是主线程现在正在处理syncMain方法,所以任务需要等syncMain执行完才能执行。而syncMain执行到第一个任务的时候,又要等第一个任务执行完才能往下执行第二个和第三个任务。

  • 要是如果不再主线程中调用,而在其他线程中调用会如何呢?

    不会开启新线程,执行完一个任务,再执行下一个任务(在其他线程中调用)
1
2
3
4
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[self syncMain];
});

输出结果:
2016-09-03 19:32:45.496 GCD[11686:1909617] syncMain—begin
2016-09-03 19:32:45.497 GCD[11686:1909374] 1——{number = 1, name = main}
2016-09-03 19:32:45.498 GCD[11686:1909374] 1——{number = 1, name = main}
2016-09-03 19:32:45.498 GCD[11686:1909374] 2——{number = 1, name = main}
2016-09-03 19:32:45.498 GCD[11686:1909374] 2——{number = 1, name = main}
2016-09-03 19:32:45.499 GCD[11686:1909374] 3——{number = 1, name = main}
2016-09-03 19:32:45.499 GCD[11686:1909374] 3——{number = 1, name = main}
2016-09-03 19:32:45.499 GCD[11686:1909617] syncMain—end

在其他线程中使用主队列 + 同步执行可看到:所有任务都是在主线程中执行的,并没有开启新的线程。而且由于主队列是串行队列,所以按顺序一个一个执行。
同时我们还可以看到,所有任务都在打印的syncConcurrent—begin和syncConcurrent—end之间,这说明任务是添加到队列中马上执行的。

主队列 + 异步执行

主队列 + 异步执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (void)asyncMain
{
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@",[NSThread currentThread]);
}
});
NSLog(@"asyncMain---end");
}

输出结果:
2016-09-03 19:33:54.995 GCD[11706:1911313] asyncMain—begin
2016-09-03 19:33:54.996 GCD[11706:1911313] asyncMain—end
2016-09-03 19:33:54.996 GCD[11706:1911313] 1——{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 1——{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 2——{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 2——{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 3——{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 3——{number = 1, name = main}

我们发现所有任务都在主线程中,虽然是异步执行,具备开启线程的能力,但因为是主队列,所以所有任务都在主线程中,并且一个接一个执行。

另一方面可以看出,所有任务是在打印的syncConcurrent—begin和syncConcurrent—end之后才开始执行的。说明任务不是马上执行,而是将所有任务添加到队列之后才开始同步执行。

GCD线程之间的通讯

在iOS开发过程中,我们一般在主线程里边进行UI刷新,例如:点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程,比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时,需要回到主线程,那么就用到了线程之间的通讯。

1
2
3
4
5
6
7
8
9
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
// 回到主线程
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"2-------%@",[NSThread currentThread]);
});
});

输出结果:
2016-09-03 19:34:59.165 GCD[11728:1913039] 1——0x7f8319c06820>{number = 2, name = (null)}
2016-09-03 19:34:59.166 GCD[11728:1913039] 1——{number = 2, name = (null)}
2016-09-03 19:34:59.166 GCD[11728:1912961] 2——-{number = 1, name = main}

可以看到在其他线程中先执行操作,执行完了之后回到主线程执行主线程的相应操作。

GCD的其他方法

  1. GCD的栅栏方法 dispatch_barrier_async
    我们有时需要异步执行两组操作,而且第一组操作执行完之后,才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来,当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- (void)barrier
{
dispatch_queue_t queue = dispatch_queue_create("12312312", 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]);
});
}

输出结果:
2016-09-03 19:35:51.271 GCD[11750:1914724] —-1—–{number = 2, name = (null)}
2016-09-03 19:35:51.272 GCD[11750:1914722] —-2—–{number = 3, name = (null)}
2016-09-03 19:35:51.272 GCD[11750:1914722] —-barrier—–{number = 3, name = (null)}
2016-09-03 19:35:51.273 GCD[11750:1914722] —-3—–{number = 3, name = (null)}
2016-09-03 19:35:51.273 GCD[11750:1914724] —-4—–{number = 2, name = (null)}

可以看出在执行完栅栏前面的操作之后,才执行栅栏操作,最后再执行栅栏后边的操作。

  1. GCD的延时执行方法 dispatch_after
    当我们需要延迟执行一段代码时,就需要用到GCD的dispatch_after方法。
1
2
3
4
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后异步执行这里的代码...
NSLog(@"run-----");
});
  1. GCD的一次性代码(只执行一次) dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时,我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。

1
2
3
4
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
  1. GCD的快速迭代方法 dispatch_apply

通常我们会用for循环遍历,但是GCD给我们提供了快速迭代的方法dispatch_apply,使我们可以同时遍历。比如说遍历0~5这6个数字,for循环的做法是每次取出一个元素,逐个遍历。dispatch_apply可以同时遍历多个数字。

1
2
3
4
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd------%@",index, [NSThread currentThread]);
});

从输出结果中前边的时间中可以看出,几乎是同时遍历的。

  1. GCD的队列组 dispatch_group

有时候我们会有这样的需求:分别异步执行2个耗时操作,然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。

* 我们可以先把任务放到队列中,然后将队列放入队列组中。
* 调用队列组的dispatch_group_notify回到主线程执行操作。
1
2
3
4
5
6
7
8
9
10
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(), ^{
// 等前面的异步操作都执行完毕后,回到主线程...
});

iOS多线程
iOS多线程开发
IOS多线程开发其实很简单