理解iOS中的GCD

作者: aLonelyRoot3 | 来源:发表于2016-07-28 05:51 被阅读703次

关于GCD，大体上要说的有这些：

本文就这么点事.png

多线程

一个千篇一律的应届生面试题：什么是进程和线程，以及二者的区别和联系

进程

像Xcode，GitBook一样，系统中正在运行的应用程序，可以说系统中有一个运行的程序，系统就会启动一个进程

线程

可以说，线程是进程的子单元，是进程执行的基本单位，进程中所有的任务都是在线程中执行。

多线程

一个进程可能在同时执行多个任务，比如说，chrome浏览器可以一边执行文件的下载任务，一边进行网页的浏览，设置还可以一边执行音乐的播放任务。
这就需要系统为chrome开辟多条线程协同操作，让每条线程分别执行不同的任务，并且是同时

线程间只是看上去的“同时执行”

实际上在同一时间，CPU仅仅能处理一条线程，只有一条线程在执行
N多条线程同时执行，实际上是CPU快速的在多条线程之间频繁的调度（众所周知CPU的执行频率是极其快速的，调度足够快便可以认为是“同时执行”）

多线程的优点在于可以充分的利用CPU的“多核心”，提高系统资源的利用率，提高程序执行效率。
但是存在一定弊端：

创建线程具有一定开销（iOS主要包括：内核数据结构（大约1KB）、栈空间（子线程512KB、主线程1MB，也可以使用-setStackSize:设置，但必须是4K的倍数，而且最小是16K），创建线程大约需要90毫秒的创建时间）
开启大量线程，会降低程序性能
线程越多，CPU在调度线程上的开销就越大
程序设计更加复杂：比如线程之间的通信、多线程的数据共享，势必带来更多逻辑问题

iOS开发与多线程

一个iOS程序运行后，默认会开启1条线程，称为“主线程”或“UI线程”
主线程的主要作用是显示\刷新UI界面，处理UI事件（比如点击事件、滚动事件、拖拽事件等）
开发中需注意不要将比较耗时的操作放到主线程中，考虑到用户体验，实际上这里就需要理解线程的串行执行。

线程的串行执行

一个线程中的任务是串行执行的
一个线程中执行多个任务，只能一个一个的按顺序执行、
因此比较耗时的操作应该放在“非主线程”

iOS多线程的实现方案

iOS多线程的实现方案.png

为什么研究GCD

研究GCD的目的在于：

相对于pThread，NSThread这两种功能简单的实现多线程的方案，GCD可以提供了更为强大的API实现更复杂的需求。
之后的NSOperation也是基于GCD的OC包装，并在此基础上实现的更高级的功能。

因此，研究GCD对于研究多线程技术是不可或缺的。

什么是GCD ?

Grand Central Dispatch (GCD) 是 Apple 开发的一个多核编程的解决方法，iOS4.0推出，是替代NSThread的技术，基于C语言的API，大部分是通过配合block进行使用

任务和队列

研究GCD，需要弄清楚GCD的几个名词，包括任务、队列。GCD进行线程操作，需要配合使用任务和队列。

任务

想要做的事情/执行什么操。
GCD 中的任务可以定义在block中。

void (^myBlock)() = ^{
    // 想要做的事情/任务
}

队列

用来'存放'任务
队列 != 线程
队列中存放的任务最后都要由线程来执行
队列的原则:先进先出,后进后出(FIFO/ First In First Out)

队列的类型包括：

串行队列 : (Serial Dispatch Queue)

存放按顺序执行的任务!(一个任务执行完毕,再执行下一个任务)
创建方法 - 指定为 DISPATCH_QUEUE_SERIAL 类型

// 创建一个串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL);

并发队列 : (Concurrent Dispatch Queue)

存放想要同时(并发)执行的任务，这里可能会有疑惑，但是注意队列不等于线程就OK了
创建方法 - 指定为 DISPATCH_QUEUE_CONCURRENT 类型

// 创建一个并发队列
dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrent",DISPATCH_QUEUE_CONCURRENT);

注意两个非常常用的特殊队列:

主队列

UI 操作放在主队列中执行
跟主线程相关联的队列!
主队列是 GCD 自带的一种特殊的串行队列，注意是串行
主队列中的任务都会在主线程中执行
获取主队列

dispatch_queue_t mainQueue = dispatch_get_main_queue();

全局并发队列

一般情况下，并发任务都可以放在全局并发队列中
获取全局并发队列

dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
}

执行函数

有了队列是远远不够的，队列仅仅用来存放任务。队列的类型只是告诉GCD，以后我的任务是想要按顺序执行or同时执行，注意是“想要”。但是GCD想要执行队列中的任务，开线程也好，不开线程也罢，总之需要配合执行函数。

从功能上讲，大体可以分为两种（在不细分的前提下）

dispatch_sync

同步执行函数
只能在“当前”线程执行任务
不能开启新线程

dispatch_sync(<#dispatch_queue_t queue#>, <#^(void)block#>)

<#dispatch _queue _t queue#> :队列
<#^ ( void)block#>:任务

dispatch_async

异步执行函数
可以开新线程，可以在新线程内执行任务
注意是“可以”开新线程，并不意味着一定就会开新线程

dispatch_async(dispatch_queue_t queue, <#^(void)block#>)

第三点是什么意思呢？这里需要理解队列和执行函数的组合情况，你需要知道的是 dispatch_sync 是一定不会开新线程的，而 dispatch_async 则可能会开新线程，仅仅是“可能”，有些队列和执行函数的组合情况是不会开启新线程的，至于哪些情况，看下文。

同步和异步执行顺序的问题

这个问题不好描述，但是很重要，可以描述成这样：

同步函数中的任务，是马上执行的
异步函数中的任务，是在整个方法的代码块结束之后，再返回去执行的

你可能不理解，那么看代码：

- (void)syncConcurrent
{
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });
    
    NSLog(@"syncConcurrent--------end");
}

这是一个同步执行函数 + 全局并发队列，打印的结果是 1，2，3，end，并且全部是在主线程

异步函数的代码是这样：

- (void)asyncConcurrent
{
    // 1.创建一个并发队列
   
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.将任务加入队列
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"1-----%@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"2-----%@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"3-----%@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"asyncConcurrent--------end");
//    dispatch_release(queue);
}

这是一个异步执行函数 + 全局并发队列，打印的结果是 "asyncConcurrent--------end" 在第一个，end在前啊，你明白了么？

GCD的使用步骤

将任务添加到队列中
选择同步还是异步的方式执行任务

实际上GCD提供的使用方法，我知道的有两种，一种是block封装任务的形式，另一种是 dispatch_async_f 的形式，一般情况下使用第一种。

block 封装任务

  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(queue, ^{

        // 想要执行的任务
        ...
        }
    });

dispatch_ async_ f（）

 void download(void * data)
{
    // 想要执行的任务
    ...
}

 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
 dispatch_async_f(queue, NULL, download);

常见组合形式

排列组合，我们可以依次研究以下几种组合方法

同步函数 + 串行队列

dispatch_sync + Serial Dispatch Queue
不会开启新的线程
在当前线程执行任务。
任务是串行的，执行完一个任务，再执行下一个任务

- (void)syncSerial
{
    // 1.创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("SerialQueue", DISPATCH_QUEUE_SERIAL);

    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });

    NSLog(@"-------end------");
}

// 是从上到下依次打印的

同步函数 + 并发队列

dispatch_sync + Concurrent Dispatch Queue / (Global Queue)
不会开启新的线程

- (void)syncConcurrent
{
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });
    
    NSLog(@"syncConcurrent--------end");
}

打印结果是 1，2，3，syncConcurrent，线程也都是主线程，因为是在主线程执行的此方法，因此判定这个组合也不会开新线程。

同步函数 + 主队列

dispatch_sync + Main Queue
可能会造成任务互相等待，卡住线程的问题

首先看一段代码：

- (void)syncMain
{
    NSLog(@"syncMain ----- begin");
    
    // 1.获得主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });
    
    NSLog(@"syncMain ----- end");
}

这段代码只会打印 “syncMain ----- begin”，这是为什么呢？因为发生了死锁
首先，基本的原理你应该要理解：

主队列的任务都会放在主线程执行
主线程如果有任务在处理，那就是处在一个忙碌的状态，此时，主队列会暂停调度任务，等待当前任务处理完再去执行其他任务
dispatch_sync 不能开新线程，同步函数中的任务也是在主线程执行
前文介绍的，同步函数中的任务，是马上要执行的

有了这些，理解起来就很方便了。首先开始和结尾的这对大括号中间的内容算是一个任务A, 这是在主队列中的一个任务。方法 syncMain 一调用，先打印 begin；执行到第一个同步函数，这个主队列中的任务B“要求”马上被执行，很嚣张，但是此时主队列中的任务A还没有执行完。所以会卡在这个位置无法继续执行。

异步执行函数 + 串行队列

dispatch_async + Serial Dispatch Queue
会开启新的线程，但是任务是串行的，执行完一个任务，再执行下一个任务
有点浪费的感觉，像是没事找事

异步执行函数 + 并发队列

dispatch_async + Concurrent Dispatch Queue / (Global Queue)
可以同时开启多条线程
开发中常用的，多条线程并发执行的正确打开方式

异步函数 + 主队列

dispatch_async + Main Queue
只在主线程中执行任务
并不会开新线程

简单的总结一下各种组合情况，大致是这样：

GCD执行函数+队列的组合情况.png

GCD的线程间通信

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

GCD的其他函数

GCD的其他函数也是很常用的，像dispatch_after，dispatch_once，dispatch_group，下面会介绍几个。

dispatch_ barrier_ async

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

这里的输出顺序是 1，2，barrier，3，4，也可能是2，1，barrier，4，3。
总之，后两个任务会等待前两个执行完再执行，前面两个任务是并发执行。
执行完在执行 barrier 中的任务，最后再并发执行后两个任务。

dispatch_after

dispatch_after 是GCD提供的延时执行的函数，用法如下：

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"run-----");
    });

这句代码意为2秒后执行block中的代码，在哪条线程执行取决于队列的类型。

此外，iOS还可以通过以下几种方法实现延时执行：

NSTimer
NSObject的performSelector

第一种使用定时器，大致是这样：

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

其中第二种是调用以下API：

 [self performSelector:@selector(run) withObject:nil afterDelay:2.0];

还有一种不太常见的方法是让线程睡觉，但是会阻塞当前线程，一般不用。

dispatch_once

一次性代码
整个程序运行的过程中, 只调用用一次, 一旦被某个地方调用, 其他地方便无法调用
可以用来实现单例
线程安全的

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

dispatch_apply

快速迭代，快速遍历
把一项任务提交到队列中多次执行，具体是并行执行还是串行执行由队列queue本身决定
注意，dispatch_apply不会立刻返回，在执行完毕后才会返回，是同步的调用

void
dispatch_apply(size_t iterations, dispatch_queue_t queue,
        void (^block)(size_t));

什么意思呢？我举个例子你可能就清楚了。

比如说，我在文件夹A下存储了一堆图片，想剪切到文件夹B下，实际上我剪切图片的先后顺序是并不影响我的结果的，也就说剪切文件夹下单张图片是毫不相关的操作，这些操作并不存在先后依赖关系。

常规的方法我可能需要 for 循环，对内部的每一张图片进行一次 move 操作，类似于这样：

- (void)moveFile
{
    NSString *from = @"/Users/AY/Desktop/From";
    NSString *to = @"/Users/AY/Desktop/To";

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

    for (NSString *subpath in subpaths) {
        NSString *fromFullpath = [from stringByAppendingPathComponent:subpath];
        NSString *toFullpath = [to stringByAppendingPathComponent:subpath];
    
          dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            // 剪切
            [mgr moveItemAtPath:fromFullpath toPath:toFullpath error:nil];
            
            NSLog(@"%@---%@", [NSThread currentThread], subpath);

        });
    }
}

我们知道，这段代码是在一个代码块里，for 循环的执行过程是一个迭代的过程，循环多少次，就会迭代多少次。这里就算在每一次迭代的时候都会把剪切单张图片的任务开一个线程执行，但是这里是一个循环啊... 循环也就意味着是一个线性的迭代，迭代A执行过了，才会执行迭代B...

如何能做到“同时迭代”呢？ GCD提供了dispatch_apply 函数。

使用大致是这样的：

- (void)apply
{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSString *from = @"/Users/AY/Desktop/From";
    NSString *to = @"/Users/AY/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_group

将任务放入队列中，然后将队列放入对列组
队列组会让其中的任务都执行完之后，再调用 dispatch_group_notify 的 block

 dispatch_group_t group = dispatch_group_create(); // 队列组
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0); // 全局并发队列
    
    dispatch_group_async(group, queue, ^{         // 异步执行操作1
        // longTime1
    });
    
    dispatch_group_async(group, queue, ^{         // 异步执行操作2
        // longTime2
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{     // 在主线程刷新数据
        // reload Data
    });
}

dispatch_once 实现单例模式

代码大致是这样的：

static MBGlobalTool *_instance = nil;

+ (instancetype)sharedInstance
{
  static dispatch_once_t onceToken ;
  dispatch_once(&onceToken, ^{
    _instance = [[self alloc] init] ;
  }) ;
 
  return _instance ;
}

越来越懒的开发者喜欢拖进去这样一个.h文件：

//
// Single.h
// CreateTools
//
// Created by AY on 16/6/27.
// Copyright © 2016年 Jasperay. All rights reserved.
//

#ifndef Single_h
#define Single_h

#ifdef __OBJC__

#pragma mark - 单例模式 .h文件内容
#define SingleInterface(name) +(instancetype)share##name;

#pragma mark - 单例模式 .m文件内容
#if __has_feature(objc_arc)
#define SingleImplementation(name) +(instancetype)share##name {return [[self alloc]init];} \
+ (instancetype)allocWithZone:(struct _NSZone *)zone { \
static id instance; \
static dispatch_once_t onceToken; \
dispatch_once(&onceToken, ^{ \
instance = [super allocWithZone:zone]; \
}); \
return instance; \
} \
- (id)copyWithZone:(NSZone *)zone{return self;} \
- (id)mutableCopyWithZone:(NSZone *)zone {return self;}

#else

#define SingleImplementation(name) +(instancetype)share##name {return [[self alloc]init];} \
+ (instancetype)allocWithZone:(struct _NSZone *)zone { \
static id instance; \
static dispatch_once_t onceToken; \
dispatch_once(&onceToken, ^{ \
instance = [super allocWithZone:zone]; \
}); \
return instance; \
} \
- (id)copyWithZone:(NSZone *)zone{return self;} \
- (id)mutableCopyWithZone:(NSZone *)zone {return self;} \
- (instancetype)retain {return self;} \
- (instancetype)autorelease {return self;} \
- (oneway void)release {} \
- (NSUInteger)retainCount {return MAXFLOAT;} \

#endif

#endif

#endif /* Single_h */

然后，在写一个唯一实例的类的时候，只需要这样写：
.h

SingleInterface(AYPerson)

SingleImplementation(AYPerson)

总结

关于GCD更高级的使用，作者也是在不断的学习研究。有了这些基础，还有前面写过的RunLoop 学习笔记也就方便研究 NSOperation，然后就可以研究注明框架如 AFNetWorking，SDWebImage等著名框架，相信有朝一日，你也可以写出这么优秀的框架。

网友评论

fd35d9dc3525:我觉得作者写的很用心。单利宏的代码都帮忙贴出来了！在这里请教一个问题。dispatch_group, 放到全局队列里面执行的任务带有block块，如何在block块里面的代码执行完毕，再刷新UI
fd35d9dc3525:这里自答下，把问题先再仔细说下，场景是在一个界面需要执行四个网络请求任务。四个网络请求完成后，刷新界面。实现这个需要在每个block里面加上 dispatch_group_leave(requestGroup);这句代码。
豆小兽:可以说，线程是进程的子单元，是进程执行的基本单位，进程中所有的任务都是在进程中执行？？？这句话有问题吧，应该是进程中所有的任务都是在线程中执行吧？
aLonelyRoot3:@七月天熊谢谢，已修正
343cea0f7107:6666
XM_Dong:有些地方写的有点不是很明了，但是对于初学者有一定的帮助！
aLonelyRoot3:@XM_Dong 不明的地可以提示我
余夏:主线程中加入异步执行的任务为什么不会开辟新线程？
aLonelyRoot3:@余夏注意是主队列 + 异步执行函数不会开启新线程