将来的自己,会感谢现在努力的自己!

0%

iOS开发之多线程GCD

发表于 更新于 分类于
本文字数： 12k 阅读时长 ≈ 11 分钟
多线程GCD

目前多线程主要分为三类：

1 NSThread
2 NSOperation
3 GCD
前面两种网上资料很多，本文就苹果推荐使用的GCD理一理。

一、多线程相关概念

进程与线程的关系？

  • 进程：app打开的时候会打开相应的进程，一般情况下，一个App会有一个或多个进程，但是iOS的App一般只有一个进程（后台播放，IM除外）。在iOS系统中，打开一个新的App会挂起其他App的进程。一个进程会包含一个或多个线程。
  • 线程：一个线程同时只可以执行一个任务，多线程就可以同时执行多个任务。一个进程可以包含多个线程。

主线程和子线程（非主线程）到底有什么区别？

  • 主线程：iOS程序中，主线程（又叫作UI线程）主要任务是处理UI事件，显示和刷新UI，（只有主线程有直接修改UI的能力）耗时的操作放在子线程（又叫作后台线程、异步线程）。
  • 子线程：在iOS中开子线程去处理耗时的操作，可以有效提高程序的执行效率，提高资源利用率。

但是开启线程会占用一定的内存，（主线程的堆栈大小是1M，第二个线程开始都是512KB，并且该值不能通过编译器开关或线程API函数来更改）降低程序的性能。所以一般不要同时开很多线程。

注:查看当前线程信息用**[NSThread currentThread]，而不要用[NSOperationQueue currentQueue]**，因前者内容可以看到更全面的线程信息！

下面进入正题：

二、GCD几个重要的关键字

2.1、异步与同步

  • 异步执行：具备开新线程的能力，可以先绕过线程任务，回头再执行。
  • 同步执行：不具备开新线程的能力，因此只能在当前线程中执行！任务执行必须按顺序执行（必须执行完当前任务才会继续走代码）。

2.2、并发队列与串行队列

  • 并发队列：队列中的任务同时执行(Concurrent Dispatch Queue)
  • 串行队列：队列中的任务按添加任务顺序执行(Serial Dispatch Queue)

注：这里说的任务就是GCD中block中的代码。

这里的关键字一般都是组合用，理解单个是没有意义的，组合后的效果：
注：如果同步执行的时候，不放入新创建的线程中的话，就会在主线程执行。

2.3、同步的情况下需要注意

以下两种同步执行的情况都是在主线程执行的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
dispatch_queue_t concurrentQueue = dispatch_queue_create("abcd", DISPATCH_QUEUE_CONCURRENT);//并发队列
//这里的abcd仅仅作为调试时用的标识符，打印线程属性时并不是name
dispatch_sync(concurrentQueue, ^{
    [self loadImage:@10];
});
dispatch_sync(concurrentQueue, ^{
    [self loadImage:@11];
});
dispatch_sync(concurrentQueue, ^{
    [self loadImage:@12];
});
dispatch_sync(concurrentQueue, ^{
    [self loadImage:@13];
});

打印log：

1
2
3
4
2017-06-28 10:38:54.797 多线程GCD[80605:13173361] 执行：10 线程信息：<NSThread: 0x600000073ec0>{number = 1, name = main}
2017-06-28 10:38:57.342 多线程GCD[80605:13173361] 执行：11 线程信息：<NSThread: 0x600000073ec0>{number = 1, name = main}
2017-06-28 10:38:59.681 多线程GCD[80605:13173361] 执行：12 线程信息：<NSThread: 0x600000073ec0>{number = 1, name = main}
2017-06-28 10:39:01.966 多线程GCD[80605:13173361] 执行：13 线程信息：<NSThread: 0x600000073ec0>{number = 1, name = main}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列
//这里的DISPATCH_QUEUE_SERIAL等价于NULL
dispatch_sync(serialQueue, ^{
    [self loadImage:@5];
});
dispatch_sync(serialQueue, ^{
    [self loadImage:@6];
});
dispatch_sync(serialQueue, ^{
    [self loadImage:@7];
});
dispatch_sync(serialQueue, ^{
    [self loadImage:@8];
});

打印log：

1
2
3
4
2017-06-28 10:45:30.928 多线程GCD[81007:13250389] 执行：5 线程信息：<NSThread: 0x600000065000>{number = 1, name = main}
2017-06-28 10:45:37.232 多线程GCD[81007:13250389] 执行：6 线程信息：<NSThread: 0x600000065000>{number = 1, name = main}
2017-06-28 10:45:39.713 多线程GCD[81007:13250389] 执行：7 线程信息：<NSThread: 0x600000065000>{number = 1, name = main}
2017-06-28 10:45:42.314 多线程GCD[81007:13250389] 执行：8 线程信息：<NSThread: 0x600000065000>{number = 1, name = main}

正确的打开方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列

dispatch_async(dispatch_queue_create("abcd", DISPATCH_QUEUE_SERIAL), ^{
    
    dispatch_sync(serialQueue, ^{
        [self loadImage:@5];
    });
    dispatch_sync(serialQueue, ^{
        [self loadImage:@6];
    });
    dispatch_sync(serialQueue, ^{
        [self loadImage:@7];
    });
    dispatch_sync(serialQueue, ^{
        [self loadImage:@8];
    });
    
});

打印log：

1
2
3
4
2017-06-28 10:47:15.677 多线程GCD[81128:13270066] 执行：5 线程信息：<NSThread: 0x60800007e000>{number = 3, name = (null)}
2017-06-28 10:47:18.103 多线程GCD[81128:13270066] 执行：6 线程信息：<NSThread: 0x60800007e000>{number = 3, name = (null)}
2017-06-28 10:47:20.470 多线程GCD[81128:13270066] 执行：7 线程信息：<NSThread: 0x60800007e000>{number = 3, name = (null)}
2017-06-28 10:47:22.774 多线程GCD[81128:13270066] 执行：8 线程信息：<NSThread: 0x60800007e000>{number = 3, name = (null)}

以上说的是同步的时候需要注意的，下面说一下异步的情况：

2.4、异步的情况下需要注意-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列
    
    dispatch_async(serialQueue, ^{
        [self loadImage:@0];
    });
    dispatch_async(serialQueue, ^{
        [self loadImage:@1];
    });
    dispatch_async(serialQueue, ^{
        [self loadImage:@2];
    });
    dispatch_async(serialQueue, ^{
        [self loadImage:@3];
    });

打印log：

1
2
3
4
2017-06-28 10:49:14.498 多线程GCD[81251:13288476] 执行：0 线程信息：<NSThread: 0x600000262680>{number = 3, name = (null)}
2017-06-28 10:49:17.125 多线程GCD[81251:13288476] 执行：1 线程信息：<NSThread: 0x600000262680>{number = 3, name = (null)}
2017-06-28 10:49:19.599 多线程GCD[81251:13288476] 执行：2 线程信息：<NSThread: 0x600000262680>{number = 3, name = (null)}
2017-06-28 10:49:21.934 多线程GCD[81251:13288476] 执行：3 线程信息：<NSThread: 0x600000262680>{number = 3, name = (null)}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
dispatch_queue_t concurrentQueue = dispatch_queue_create("abcd", DISPATCH_QUEUE_CONCURRENT);//并发队列
    
    dispatch_async(concurrentQueue, ^{
        [self loadImage:@0];
    });
    dispatch_async(concurrentQueue, ^{
        [self loadImage:@1];
    });
    dispatch_async(concurrentQueue, ^{
        [self loadImage:@2];
    });
    dispatch_async(concurrentQueue, ^{
        [self loadImage:@3];
    });

打印log：

1
2
3
4
2017-06-28 10:54:06.805 多线程GCD[81549:13342819] 执行：1 线程信息：<NSThread: 0x608000072f80>{number = 4, name = (null)}
2017-06-28 10:54:06.805 多线程GCD[81549:13341379] 执行：0 线程信息：<NSThread: 0x60800007b200>{number = 3, name = (null)}
2017-06-28 10:54:06.805 多线程GCD[81549:13342821] 执行：3 线程信息：<NSThread: 0x6080000743c0>{number = 6, name = (null)}
2017-06-28 10:54:06.805 多线程GCD[81549:13342820] 执行：2 线程信息：<NSThread: 0x60000026a400>{number = 5, name = (null)}

在串行队列异步执行过程中，会创建一个线程，按顺序执行当前线程中的任务。有阻塞！
在并发队列异步执行过程中，可能会创建多个线程，同时执行当前线程中的任务。没有阻塞！

2.4、异步的情况下需要注意-2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dispatch_async(dispatch_queue_create("aaa", DISPATCH_QUEUE_SERIAL), ^{
    [self loadImage:@0];
});
dispatch_async(dispatch_queue_create("bbb", DISPATCH_QUEUE_SERIAL), ^{
    [self loadImage:@1];
});
dispatch_async(dispatch_queue_create("ccc", DISPATCH_QUEUE_SERIAL), ^{
    [self loadImage:@2];
});
dispatch_async(dispatch_queue_create("ddd", DISPATCH_QUEUE_SERIAL), ^{
    [self loadImage:@3];
});
dispatch_async(dispatch_queue_create("eee", DISPATCH_QUEUE_SERIAL), ^{
    [self loadImage:@4];
});

打印log：

1
2
3
4
5
2017-06-28 11:05:10.966 多线程GCD[82282:13469275] 执行：2 线程信息：<NSThread: 0x608000076100>{number = 5, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469905] 执行：4 线程信息：<NSThread: 0x6080000738c0>{number = 6, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469278] 执行：3 线程信息：<NSThread: 0x608000075b40>{number = 7, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469331] 执行：1 线程信息：<NSThread: 0x600000076d00>{number = 4, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469276] 执行：0 线程信息：<NSThread: 0x60800006dcc0>{number = 3, name = (null)}

以上会创建5个串行队列线程，而不是1个串行队列线程，因为不是同一个线程，所以执行顺序是同时执行，互相没有影响(对于并发队列是同样的)。
正确使用方法应该是1中创建的方式，对于并发队列，计算机会根据性能和需要创建合理的线程数量。保证系统高性能和流畅性。

1
2
3
4
5
6
7
8
9
10
11
12
dispatch_async(dispatch_queue_create("a", DISPATCH_QUEUE_CONCURRENT), ^{
    [self loadImage:@14];
});
dispatch_async(dispatch_queue_create("b", DISPATCH_QUEUE_CONCURRENT), ^{
    [self loadImage:@15];
});
dispatch_async(dispatch_queue_create("c", DISPATCH_QUEUE_CONCURRENT), ^{
    [self loadImage:@16];
});
dispatch_async(dispatch_queue_create("d", DISPATCH_QUEUE_CONCURRENT), ^{
    [self loadImage:@17];
});

打印log：

1
2
3
4
5
2017-06-28 11:03:51.193 多线程GCD[82177:13453338] 执行：15 线程信息：<NSThread: 0x608000263040>{number = 4, name = (null)}
2017-06-28 11:03:51.193 多线程GCD[82177:13449499] 执行：14 线程信息：<NSThread: 0x608000261580>{number = 3, name = (null)}
2017-06-28 11:03:51.193 多线程GCD[82177:13453339] 执行：16 线程信息：<NSThread: 0x608000272f00>{number = 5, name = (null)}
2017-06-28 11:03:51.193 多线程GCD[82177:13453340] 执行：17 线程信息：<NSThread: 0x60000026e740>{number = 6, name = (null)}

2.5、关键字 - Main Dispatch Queue/Global Dispatch Queue

实际上不用特意生成Dispatch Queue，系统也会为我们准备几个。那就是Main Dispatch Queue和Global Dispatch Queue。

  • Main Dispatch Queue就是主线程，因为主线程只有一个，所以Main Dispatch Queue是Serial Dispatch Queue。Main Dispatch Queue的处理在主线程的Runloop中执行。

相应的，Global Dispatch Queue是系统为我们准备的Concurrent Dispatch Queue。Global Dispatch Queue有四个优先级，应根据需求使用对应优先级。

优先级.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 /**
  high优先级的获取方法
 */
dispatch_queue_t globalHighQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
 /**
  default优先级的获取方法
 */
dispatch_queue_t globalDefaultQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
 /**
  low优先级的获取方法
 */
dispatch_queue_t globalLowQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
 /**
  background优先级的获取方法
 */
dispatch_queue_t globalBackgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

更改队列优先级：dispatch_set_target_queue(dispatch_object_t _Nonnull object, dispatch_queue_t _Nullable queue)

1
2
3
4
5
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列
   
dispatch_queue_t globalBackgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
   
dispatch_set_target_queue(serialQueue, globalBackgroundQueue);将serialQueue指定为globalBackgroundQueue用。

注：如果这里用函数dispatch_set_target_queue将多个Serial Dispatch Queue指定为同一个Serial Dispatch Queue，就会将原本并发的队列变更为串行队列。

2.6、关键字 - Dispatch Group

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
将原本在serialQueue中要执行的放在group里，后面可以加一个结束的回调（很多时候会有这种需求）
*/
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, serialQueue, ^{
        //代码
    });
    dispatch_group_async(group, serialQueue, ^{
        //代码
    });
    dispatch_group_async(group, serialQueue, ^{
        //代码
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"done");//执行完成后回调
    });

2.7、关键字 - dispatch_barrier_async 栅栏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
dispatch_queue_t concurrentQueue = dispatch_queue_create("abcd", DISPATCH_QUEUE_CONCURRENT);//并行队列
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@0];
       //读取数据0
   });
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@1];
       //读取数据1
   });
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@2];
       //读取数据2
   });
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@3];
       //读取数据3
   });
   dispatch_barrier_async(concurrentQueue, ^{
       [self loadImage:@4];
      //异步栅栏写入数据4
   });
   dispatch_barrier_sync(concurrentQueue, ^{
       [self loadImage:@4];
       //同步栅栏写入数据4
   });
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@5];
       //读取数据5
   });
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@6];
       //读取数据6
   });
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@7];
       //读取数据7
   });
   dispatch_async(concurrentQueue, ^{
       [self loadImage:@8];
       //读取数据8
   });

打印log：

1
2
3
4
5
6
7
8
9
10
2017-06-28 11:11:53.029 多线程GCD[82699:13543714] 执行：2 线程信息：<NSThread: 0x600000076d80>{number = 5, name = (null)}
2017-06-28 11:11:53.029 多线程GCD[82699:13543650] 执行：0 线程信息：<NSThread: 0x600000076d40>{number = 3, name = (null)}
2017-06-28 11:11:53.029 多线程GCD[82699:13543652] 执行：1 线程信息：<NSThread: 0x608000066940>{number = 4, name = (null)}
2017-06-28 11:11:53.029 多线程GCD[82699:13543715] 执行：3 线程信息：<NSThread: 0x608000071140>{number = 6, name = (null)}
2017-06-28 11:11:58.763 多线程GCD[82699:13544668] 异步栅栏执行：4 线程信息：<NSThread: 0x6080000710c0>{number = 8, name = (null)}
2017-06-28 11:12:01.195 多线程GCD[82699:13542941] 同步栅栏执行：4 线程信息：<NSThread: 0x600000066500>{number = 1, name = main}
2017-06-28 11:12:03.605 多线程GCD[82699:13543650] 执行：7 线程信息：<NSThread: 0x600000076d40>{number = 3, name = (null)}
2017-06-28 11:12:03.605 多线程GCD[82699:13544677] 执行：5 线程信息：<NSThread: 0x608000074bc0>{number = 9, name = (null)}
2017-06-28 11:12:03.605 多线程GCD[82699:13544668] 执行：6 线程信息：<NSThread: 0x6080000710c0>{number = 8, name = (null)}
2017-06-28 11:12:03.605 多线程GCD[82699:13543714] 执行：8 线程信息：<NSThread: 0x600000076d80>{number = 5, name = (null)}

在读取数据时，有时候会出现数据竞争，数据安全问题，比如：当前的写入没有结束，读取操作就开始处理，导致数据错乱。或者读取正在进行，开始写入操作，导致程序崩溃等问题。
苹果为我们提供了一个便捷的参数：dispatch_barrier_async（栅栏）。
作用：如上述代码中所表示，只有在1234操作完成时（无序），才会执行写入操作，只有当前写入操作结束后，才会继续向下执行。dispatch_barrier_sync也有同样的效果，但是如果不放入其他线程中的话，会在当前线程即主线程执行，会阻塞线程。

注意：dispatch_barrier_async中如果使用全局队列的话，就相当于要等待全局队列里的所有并发任务执行完后，才会执行dispatch_barrier_async中的任务，这样会受其他在全局队列里任务的影响，达不到我们想要的效果。

三、总结：

**
并发队列(Concurrent Dispatch Queue) 串行队列(Serial Dispatch Queue) ：
负责执行顺序！
异步执行 (dispatch_async) 同步执行 (dispatch_sync)：
负责选择线程执行！
**