iOS - Threads 多线程

1、Threads

1.1 进程

• 进程是指在系统中正在运行的一个应用程序。每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内。

  • 比如同时打开 QQ、Xcode，系统就会分别启动两个进程。通过 “活动监视器” 可以查看 Mac 系统中所开启的进程。

    

  • 一个程序的一次运行，在执行过程中拥有独立的内存单元，而多个线程共享一块内存。

1.2 线程

• 线程是进程中执行任务的基本执行单元。一个进程要执行任务，必须得有线程，一个进程（程序）的所有任务都在线程中执行。每一个进程至少有一条线程，即主线程。一个进程可以开启多条线程，每条线程可以并发（同时）执行不同的任务。

  • 比如使用酷狗播放音乐、使用迅雷下载电影，都需要在线程中执行。

    

• 在程序中每一个方法的执行，都是从上向下串行执行的。除非使用 block，否则在一个方法中，所有代码的执行都在同一个线程上。

• 进程与线程的联系：线程是进程的基本组成单位。

• 进程与线程的区别：
  • 1) 调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
  • 2) 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行。
  • 3) 拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
  • 4) 系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。

1.2.1 线程的串行

• 一个线程中任务的执行是串行（顺序执行）的。如果要在一个线程中执行多个任务，那么只能一个一个的按顺序执行这些任务，也就是说，在同一时间内，一个线程只能执行一个任务。

  • 比如在一个线程中下载三个文件（分别是文件 A，文件 B，文件 C）。

    

1.2.2 多线程原理

• 同一时间，CPU 只能处理一条线程，只有一条线程在工作（执行）。多线程并发（同时）执行，其实是 CPU 快速的在多条线程之间调度（切换）。如果 CPU 调度线程的时间足够快，就造成了多条线程并发执行的假象。

  

• 多线程开发的复杂度相对较高，在开发时可以按照以下套路编写代码：

  • 1、首先确保单个线程执行正确。
  • 2、添加线程。

• 在多线程开发的时候，有几点提示：

  • 1、不要相信一次运行的结果。
  • 2、不要去做不同线程之间执行的比较，线程内部的方法都是各自独立执行的。
  • 3、多线程的目的是将耗时的操作放在后台，不阻塞主线程和用户的交互。
  • 4、多线程开发的原则是简单，不要将简单的事情搞复杂了。

1.2.3 多线程优点

• 使用多线程可以将耗时的任务放到后台去执行，不阻塞主线程和用户的交互。
• 使用多线程能够并发、同时执行多个任务，可以适当提高程序的执行效率，适当提高资源的利用率（CPU、内存的利用率）。

1.2.4 多线程缺点

• 每开一个线程都会造成系统额外的负担，开启线程需要占用一定的内存空间（默认情况下，每一条线程都会占用 512KB），如果开启大量的线程，会占用大量的内存空间，降低程序的性能。
• 线程越多，CPU 调度线程上开销就越大。

• 线程越多，程序设计就更加复杂，比如线程之间的通信、多线程的数据共享就更加复杂。

• 通常开启 5 到 6 条线程即可，不能开启的太多。

  • 栈区：保存局部变量和函数的参数，由下向上压栈。线程执行完毕后，栈区会自动释放，程序员不需要管理栈区的内存。
    
    

1.2.5 主线程

• 一个 iOS 程序运行后，默认会开启一条线程，称为主线程或 UI 线程。主线程主要用于显示/刷新 UI 界面，处理 UI 事件（比如点击事件、滚动事件、拖拽事件等）。

• 注意别将比较耗时的操作放到主线程中，耗时的操作会卡住主线程，严重影响 UI 的流畅度，给用户一种 “卡” 的坏体验。

1.2.6 线程状态

• 新线程创建启动后，线程对象被加入可调度线程池中，进入就绪状态，等待 CPU 调度。在线程被调度运行时，如果线程调用了 sleep 方法或者等待同步锁时，线程由运行状态进入到阻塞状态，线程被移出可调度线程池。sleep 到时或者得到同步锁时，线程重新进入可调度线程池，回到就绪状态。线程任务执行完毕或者异常、强制退出时，线程由运行状态进入到死亡状态，线程结束，线程占用内存空间被释放。

  

  • 在整个线程状态循环中，程序员无法控制线程的运行状态。线程是否运行由 CPU 调度完成。

1.2.7 线程安全

• 如果一个属性，在多个线程执行的情况下，仍然能够得到正确结果，被称为线程安全。

• 要实现线程安全，就必须要用到锁，用到锁就会降低程序的性能。为了得到更佳的用户体验，UIKit 不是线程安全的，UI 线程约定所有更新 UI 的操作都必须主线程上执行，因此，主线程又被称为 UI 线程。

  • 1）iOS 开发建议：

    • 所有属性都声明为 nonatomic。
    • 尽量避免多线程抢夺同一块资源。
    • 尽量将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力。

  • 2）使用互斥锁：

        @synchronized (self) {}

    • 互斥锁能够保证锁定范围的代码，同一时间，只有一条线程能够执行。
    • 互斥锁的锁定范围，应该尽量小，只要锁住资源读写部分的代码即可。锁定范围越大，效率越差。使用锁之后，程序执行性能都会受到影响，会影响并发的目的。

    • 在 iOS 开发中，使用锁的机会极少，一般都是从服务器获取到数据，直接显示。

    • 参数：
      • self 表示当前的 UIViewController，为 NSObject 的子类。本质上是任意一个 NSObject 子类对象都可以当成锁。
      • 如果代码中只有一个地方需要加锁，大多都使用 self，这样可以避免单独再创建一个锁对象。
      • 锁对象一定要保证所有的线程都能够访问。必须为全局变量。

  • 3）使用变量原子性：

    • 原子属性（线程安全），是针对多线程设计的，是默认属性。
    • 多个线程在写入原子属性时（调用 setter 方法），能够保证同一时间只有一个线程执行写入操作，但是允许多个线程同时读取属性值。
    • 原子属性是一种单(线程)写多(线程)读的多线程技术，在多线程读取数据时，有可能出现“脏”数据 - 读取的数据可能会不正确。
    • 原子属性内部也有一把 "锁"，是自旋锁，执行效率比互斥锁高。
    • 在定义属性时，如果不需要考虑线程安全，要显示地指定为 nonatomic。

    • 原子属性，解决不了卖票问题，因为卖票的读写都需要锁定。

    • 如果重写了原子属性的 setter 方法，相当于覆盖了系统提供的 setter 方法，此时，系统要求，必须重写 getter 方法。

    • 定义属性时，系统默认提供 getter & setter 方法，并且生成一个 _成员变量，但是如果自己重写了 getter & setter 方法，_成员变量，不会自动生成。

    • @synthesize 合成指令，可以指定保存属性数值的 成员变量。

    • 在 Xcode 4.5 之前，开发，程序员必须自己实现 @synthesize 指令。

  • 4）自旋锁 & 互斥锁：

    • 共同点：
      • 都能够保证同一时间，只有一条线程执行锁定范围的代码。
    • 不同点：
      • 互斥锁：如果发现有其他线程正在执行锁定的代码，线程会进入休眠状态，等待其他线程执行完毕，打开锁之后，线程会被唤醒。
      • 自旋锁：如果发现有其他线程正在执行锁定的代码，线程会以死循环的方式，一直等待锁定代码执行完成。
    • 结论：
      • 自旋锁更适合执行非常短的代码。
      • 无论什么锁，都是要付出代价。

1.2.8 线程间通信

• 在子线程中执行比较耗时的操作（如下载图片等），子线程执行完毕后通知主线程更新 UI 等的操作。

• UIKit 中几乎所有控件都不是线程安全的，因此需要在主线程上更新 UI。在子线程中可以使用以下方法让主线程执行 UI 操作：

      // waitUntilDone: YES 等待主线程执行完成后子线程再继续执行[self performSelectorOnMainThread:@selector(updateUI:) withObject:image waitUntilDone:YES];dispatch_async(dispatch_get_main_queue(), ^{[self updateUI:image];});[[NSOperationQueue mainQueue] addOperationWithBlock:^{[self updateUI:image];}];

1.3 iOS 中多线程实现方案

1.3.1 pthread

• pthread 是 POSIX 的多线程开发框架，由于是跨平台的 C 语言框架，在苹果的头文件中并没有详细的注释。Xcode 中所用跨平台的文件通常都在 usr/include 目录下。对于所有跨平台的框架（如：pthread & socket），可以访问一个网站： baike.baidu.com

• iOS 中 C 语言框架：

  • 在 C 语言中，没有对象的概念，对象是以结构体的方式来实现的。

  • 通常，在 C 语言框架中，“对象” 类型以 _t/Ref 结尾，而且定义时不需要使用 * 。

  • 内存管理：

    • 在 OC 中，如果是 ARC 开发，编译器会在编译时，根据代码结构，自动添加 retain/release/autorelease。
    • 但是，ARC 只负责管理 OC 部分的内存管理，而不负责 C/C++ 语言部分代码的内存管理。
    • 如果开发的时候，涉及到混合语言开发，如果使用的 C 语言框架出现 retain/create/copy/new 等字样的函数，大多都需要程序员手动 release，否则会出现内存泄漏。

  • 参数桥接：

    • 在混合开发时，如果在 C 和 OC 之间传递数据，需要使用 __bridge 进行桥接，告诉编译器如何管理内存。__bridge 就是保留原有的管理方式。
    • 桥接的添加可以借助 Xcode 的辅助功能添加。
    • MRC 中不需要使用桥接。MRC 中所有内存都是程序员负责的。
    • 管理的是堆区的内存。alloc/copy/retain 等字样的函数都是和堆区有关的。

  • void *：

    • C 语言中的 void * 和 OC 中的 id 是等价的。

    • 例如：

          C     ： void *(*)(void *)OC    ： id (函数名) (id)       即 返回值类型(函数名)(参数)block ： 返回值 (^) (参数)       block 匿名的函数指针

1.3.2 NSThread

• 优点：NSThread 轻量级。
• 缺点：需要自己管理线程的生命周期，线程同步。线程同步对数据的加锁会有一定的系统开销。

1.3.3 GCD

• GCD 是 Grand Central Dispatch（译为 “中枢调度器”）的简称，它是基于 C 语言编写的，是苹果公司为多核的并行运算提出的解决方案。GCD 在工作时会自动利用更多的处理器核心，以充分利用更强大的机器。如果使用 GCD，完全由系统管理线程，我们不需要编写线程代码，只需定义想要执行的任务，然后添加到适当的调度队列（dispatch queue），GCD 会负责创建线程和调度你的任务。它首次发布在 Mac OS X 10.6 ，iOS 4 上。在 iOS 所有实现多线程的方案中，GCD 应该是最有魅力的，GCD 是一个替代诸如 NSThread， NSOperationQueue，NSInvocationOperation 等技术的很高效和强大的技术。

• 1) 工作原理：

  • 将长期运行的任务拆分成多个工作单元，并将这些单元添加到 dispath queue 中，系统会为我们管理这些 dispath queue，根据可用的处理资源，安排他们在任何可用的处理器核心上执行任务。我们不需要直接启动和管理后台线程。一个任务可以是一个函数（function）或者是一个 block。GCD 的底层依然是用线程实现，不过这样可以让程序员不用关注实现的细节。

  • 将任务添加到队列，并且指定执行任务的函数，执行任务。任务使用 block 封装，任务的 block 没有参数也没有返回值。

• 2) 执行任务的函数：

  • 异步 dispatch_async

    • 不用等待当前语句执行完毕，就可以执行下一条语句。
    • 会开启线程执行 block 的任务。
    • 异步是多线程的代名词。

  • 同步 dispatch_sync

    • 必须等待当前语句执行完毕，才会执行下一条语句。
    • 不会开启线程。

    • 在当前线程执行 block 的任务。

    • 同步任务的作用：同步任务，可以让其他异步执行的任务，"依赖" 某一个同步任务。例如：在用户登录之后，再异步下载文件！

• 3) 任务调度队列：

  • GCD 中的 FIFO 队列称为 dispatch queue（调度队列）。系统提供了许多预定义的 dispatch queue，包括可以保证始终在主线程上执行工作的 dispatch queue。也可以创建自己的 dispatch queue，而且可以创建任意多个。GCD 的 dispatch queue 严格遵循 FIFO(先进先出) 原则，添加到 dispatch queue 的工作单元将始终按照加入 dispatch queue 的顺序启动。dispatch queue 按先进先出的顺序，串行或并发地调度任务在线程上实行。

  • dispatch queue 分为下面三种：

    • Serial：

      • 串行队列，又称为 private dispatch queues，一次只能 "调度" 一个任务, 当前任务完成才开始出列并启动下一个任务。Serial queue 通常用于同步访问特定的资源或数据。当你创建多个 Serial queue 时，虽然它们各自是同步执行的，但 Serial queue 与 Serial queue 之间是并发执行的。

    • Concurrent：

      • 并发队列，又称为 global dispatch queues，一次可以 "调度" 多个任务，尽可能多地启动任务并发执行，任务执行完成的顺序是随机的。

      • 系统给每一个应用程序提供了三个 concurrent dispatch queues。这三个并发调度队列是全局的，它们只有优先级的不同。因为是全局的，我们不需要去创建。我们只需要通过使用函数 dispath_get_global_queue 去得到队列。

    • Main dispatch queue：

      • 主队列，它是全局可用的 serial queue，专门用来在主线程上调度任务的队列。不会开启线程，主队列异步执行时如果主线程上正在有代码执行，就不会调度队列中的任务，等待主线程空闲之后再调度任务。主线程中主队列同步执行时，主队列和主线程相互等待会造成死锁。

• 4) 各种队列的执行效果：

  Type           |     全局并发队列     |   手动创建串行队列    |       主队列

  -----------------|--------------------|--------------------|-------------------
  同步 (sync） | 没有开启新线程 | 没有开启新线程 | 没有开启新线程
  ~ | 串行执行任务 | 串行执行任务 | 串行执行任务
  异步 (async） | 有开启新线程 | 有开启新线程 | 没有开启新线程
  ~ | 并发执行任务 | 串行执行任务 | 串行执行任务

  • 开不开线程由执行任务的函数决定：

    • 异步开，异步是多线程的代名词。
    • 同步不开。

  • 开几条线程由队列决定：

    • 串行队列开一条线程。

    • 并发队列开多条线程。

    • 主队列不会开启线程。

• 5) 队列的选择：

  • 多线程的目的：将耗时的操作放在后台执行！

  • 串行队列，只开一条线程，所有任务顺序执行

    • 如果任务有先后执行顺序的要求。
    • 效率低 -> 执行慢 -> "省电"。
    • 有的时候，用户其实不希望太快！例如使用 3G 流量，"省钱"。

  • 并发队列，会开启多条线程，所有任务不按照顺序执行

    • 如果任务没有先后执行顺序的要求。
    • 效率高 -> 执行快 -> "费电"。
    • WIFI，包月。

  • 实际开发中

    • WIFI 线程数 6 条。
    • 3G / 4G 移动开发的时候，2~3 条，再多会费电费钱。

• 6) 全局队列 & 并发队列的区别：

  • 全局队列：

    • 没有名称。
    • 无论 MRC & ARC 都不需要考虑释放。
    • 日常开发中，建议使用 "全局队列"。

  • 并发队列：

    • 有名字，和 NSThread 的 name 属性作用类似。
    • 如果在 MRC 开发时，需要使用 dispatch_release(q); 释放相应的对象。
    • 开发第三方框架时，建议使用并发队列。

• 7) GCD & NSThread 对比：

  • GCD 所有的代码写在一起的，让代码更加简单，易于阅读和维护。
    • NSThread 通过 @selector 指定要执行的方法，代码分散。
    • GCD 通过 block 指定要执行的代码，代码集中。
  • 使用 GCD 不需要管理线程的创建/销毁/复用的过程。程序员不用关心线程的生命周期。
    • NSThread 需要自己创建线程对象，并且指定 selector 方法，然后 start。
    • GCD 只需要将任务添加给队列，并且指定执行的函数
  • 如果要开多个线程 NSThread 必须实例化多个线程对象。
  • NSThread 靠 NSObject 的分类方法实现的线程间通讯，GCD 靠 block。

1.3.4 NSOperation

• NSOperation 也是苹果公司推出的 “并发” 技术。是基于 OC 语言的，iOS 2.0 推出。GCD 推出之后，苹果对 NSOperation 底层重新编写过，是对 GCD 的封装。Cocoa operation 相关的类是 NSOperation，NSOperationQueue。NSOperation 是个抽象类，使用它必须用它的子类，可以实现它或者使用它定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。

• 优点：不需要关心线程管理，数据同步的事情，可以把精力放在自己需要执行的操作上。

• 1）NSOperation 与 GCD 对比：

  • NSOperation：

    • 核心概念：把 "操作(异步执行的任务)" 添加到队列(全局的并发队列)。即创建 NSOperation 子类的对象，把对象添加到 NSOperationQueue 队列里执行。

    • OC 的框架，更加面向对象，是对 GCD 的封装

    • 高级功能：
      • 最大操作并发数(GCD 不好做)
        • 在 iOS 7.0 之前，使用 GCD & NSOperation 能够开启的线程数都不多，最大的线程数一般只有 5~6 条
        • 从 iOS 8.0 开始，能够开很多个线程，如果不控制，会造成资源浪费
      • 继续/暂停/全部取消
      • 能够指定任务的 "依赖" 关系(GCD 中，同步任务是来指定依赖关系)

  • GCD：

    • 核心概念：将 "任务（block）" 添加到队列(串行/并发/全局/主队列)，并且指定任务执行的函数(同步/异步)

    • C 语言的框架，dispatch_xxx 函数

    • 高级功能：
      • 一次性 once
      • 延迟操作 after
      • 调度组 (op 可以做，但是做不了太复杂)

• 2）自定义 NSOperation 操作流程：

  

2、pthread 的使用

2.1 pthread 线程创建

• Objective-C

      // 添加头文件#import <pthread.h>// 创建 pthread 子线程/*int pthread_create(pthread_t * __restrict, const pthread_attr_t * __restrict, void *(*)(void *), void * __restrict);返回值：线程创建成功，返回 0。线程创建失败，返回出错编号。成功的原因只有一个，失败的原因可以有很多，在很多 C 语言框架中，都会采用这个套路。参数：pthread_t *       ：第一个参数为指向线程标识符的指针。pthread_attr_t *  ：第二个参数用来设置线程属性。void *(*)(void *) ：第三个参数是线程运行函数的起始地址。void *            ：第四个参数是运行函数的参数。*/pthread_t threadId = NULL;NSString *str = @"pthread";int result = pthread_create(&threadId, NULL, pthreadDemo, (__bridge void *)(str));if (result) {NSLog(@"线程创建失败 %d", result);} else {NSLog(@"线程创建成功");}// 子线程执行方法void * pthreadDemo(void * param) {NSString *str = (__bridge NSString *)(param);NSLog(@"%@ --- %@", [NSThread currentThread], str);return NULL;}

3、NSThread 的使用

3.1 NSThread 线程创建

    - (instancetype)initWithTarget:(id)target selector:(SEL)selector object:(nullable id)argument;+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(nullable id)argument;- (void)performSelectorInBackground:(SEL)aSelector withObject:(nullable id)arg;public convenience init(target: AnyObject, selector: Selector, object argument: AnyObject?)public class func detachNewThreadSelector(selector: Selector, toTarget target: AnyObject, withObject argument: AnyObject?)public func performSelectorInBackground(aSelector: Selector, withObject arg: AnyObject?)参数的意义：selector ：线程执行的方法，这个 selector 只能有一个参数，而且不能有返回值。target   ：selector 消息发送的对象。argument ：传输给 target 的唯一参数，也可以是 nil。第一种方式是先创建线程对象，然后再运行线程操作，在运行线程操作前可以设置线程的优先级等线程信息。第二种和第三种方式会直接创建线程并且开始运行线程。第三种方式是 "NSObject" 的一个分类方法，可以由任何继承自 "NSObject" 的类对象调用该方法隐式创建并启动一个子线程。

• Objective-C

      // 1. 创建一个子线程NSThread *myThread = [[NSThread alloc] initWithTarget:self selector:@selector(downloadImage:) object:imageUrlPath];[myThread start];                                                                                                           // 2. 创建并启动一个子线程[NSThread detachNewThreadSelector:@selector(downloadImage:) toTarget:self withObject:imageUrlPath];// 3. 隐式创建并启动一个子线程[self performSelectorInBackground:@selector(downloadImage:) withObject:imageUrlPath];// 子线程执行方法- (void)downloadImage:(NSString *) urlPath {}

• Swift

      // 1. 创建一个子线程let myThread = NSThread(target: self, selector: #selector(ViewController.downloadImage(_:)), object: imageUrlPath)myThread.start()                                                                                                        // 2. 创建并启动一个子线程NSThread.detachNewThreadSelector(#selector(ViewController.downloadImage(_:)), toTarget: self, withObject: imageUrlPath)// 3. 隐式创建并启动一个子线程self.performSelectorInBackground(#selector(ViewController.downloadImage(_:)), withObject: imageUrlPath)// 子线程执行方法func downloadImage(urlPath: String) {}

3.2 NSThread 线程设置

• Objective-C

      // 启动子线程/*将线程对象加入可调度线程池等待 CPU 调度，线程执行完毕后，由于内存空间已经被释放，不能再次启动*/[myThread start];// 通知线程取消/*可以在外部终止线程执行，在线程执行方法中需要增加 isCancelled == YES，如果成立直接返回*/[myThread cancel];// 获取线程名字NSString *threadName = myThread.name;// 设置线程名字/*在多个线程开发时，可以用来判断到底是谁在执行任务在大的商业项目中，通常需要在程序崩溃时，获取程序准确执行所在的线程*/myThread.name = @"downloadImage";// 设置线程的优先级/*范围 0.0 到 1.0，默认为 0.5，优先级高表示 CPU 调度的频率相对较高。开发时尽量不要修改*/myThread.threadPriority = 1;// 判断线程是否正在执行 readonlyBOOL isExecuting = myThread.isExecuting;// 判断线程是否完成 readonlyBOOL isFinished = myThread.isFinished;// 判断线程是否被取消 readonlyBOOL isCancelled = myThread.isCancelled;// 获取当前线程NSThread *currentThread = [NSThread currentThread];// 判断当前线程是否为主线程/*可以在所有的多线程技术中使用*/BOOL isMainThread = [[NSThread currentThread] isMainThread];BOOL isMainThread = [NSThread isMainThread];// 判断是否为多线程操作BOOL isMultiThreaded = [NSThread isMultiThreaded];// 引用主线程/*返回主线程对象*/NSThread *mainThread = [NSThread mainThread];// 获取栈区大小/*线程执行前，主线程和子线程默认栈区大小都为 512K，线程完成后，栈区大小 0K，内存空间被释放在以前的 iOS 版本，主线程栈区 1M，子线程是 512K，而且不能修改*/NSUInteger stackSize = [NSThread currentThread].stackSize;// 设置栈区大小/*即 256 * 1024 ＝ 256K，只有在当前线程中设置才有效*/[NSThread currentThread].stackSize = 256 * 1024;// 退出当前线程的执行/*使线程进入死亡状态，线程被终止后，后续代码都不会执行，不能在主线程中调用此方法在需要手动内存管理的代码中，在终止线程之前，应该注意释放之前分配的对象*/[NSThread exit];// 休眠到指定的时间/*使线程进入阻塞状态，线程暂时被移出可调度线程池*/[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:10]];// 休眠指定的时长/*使线程进入阻塞状态，线程暂时被移出可调度线程池*/[NSThread sleepForTimeInterval:10];

• Swift

      // 启动子线程/*将线程对象加入可调度线程池等待 CPU 调度，线程执行完毕后，由于内存空间已经被释放，不能再次启动*/myThread.start()// 通知线程取消/*可以在外部终止线程执行，在线程执行方法中需要增加 isCancelled == YES，如果成立直接返回*/myThread.cancel()// 获取线程名字let threadName:String? = myThread.name// 设置线程名字/*在多个线程开发时，可以用来判断到底是谁在执行任务在大的商业项目中，通常需要在程序崩溃时，获取程序准确执行所在的线程*/myThread.name = "downloadImage"// 设置线程的优先级/*范围 0.0 到 1.0，默认为 0.5，优先级高表示 CPU 调度的频率相对较高。开发时尽量不要修改*/myThread.threadPriority = 1// 判断线程是否正在执行 readonlylet isExecuting:Bool = myThread.executing// 判断线程是否完成 readonlylet isFinished:Bool = myThread.finished// 判断线程是否被取消 readonlylet isCancelled:Bool = myThread.cancelled// 获取当前线程let currentThread:NSThread = NSThread.currentThread()// 判断当前线程是否为主线程/*可以在所有的多线程技术中使用*/let isMainThread:Bool = NSThread.currentThread().isMainThreadlet isMainThread:Bool = NSThread.isMainThread()// 判断是否为多线程操作let isMultiThreaded:Bool = NSThread.isMultiThreaded()// 引用主线程/*返回主线程对象*/let mainThread:NSThread = NSThread.mainThread()// 获取栈区大小/*线程执行前，主线程和子线程默认栈区大小都为 512K，线程完成后，栈区大小 0K，内存空间被释放在以前的 iOS 版本，主线程栈区 1M，子线程是 512K，而且不能修改*/let stackSize:Int = NSThread.currentThread().stackSize// 设置栈区大小/*即 256 * 1024 ＝ 256K，只有在当前线程中设置才有效*/NSThread.currentThread().stackSize = 256 * 1024// 退出当前线程的执行/*使线程进入死亡状态，线程被终止后，后续代码都不会执行，不能在主线程中调用此方法在需要手动内存管理的代码中，在终止线程之前，应该注意释放之前分配的对象*/NSThread.exit()// 休眠到指定的时间/*使线程进入阻塞状态，线程暂时被移出可调度线程池*/NSThread.sleepUntilDate(NSDate(timeIntervalSinceNow: 10))// 休眠指定的时长/*使线程进入阻塞状态，线程暂时被移出可调度线程池*/NSThread.sleepForTimeInterval(10)

3.3 NSThread 线程间通信

• 子线程里不允许操作 UI。

• 在子线程中向 self 发送消息，让主线程执行某个方法。waitUntilDone: YES 等待主线程执行完成后子线程再继续，NO 主线程在执行方法的时候，子线程也同时运行。

• Objective-C

      // 在主线程中执行操作[self performSelectorOnMainThread:@selector(updateUI:) withObject:image waitUntilDone:YES];// 在另一个线程中执行操作NSThread *mainThread = [NSThread mainThread];[self performSelector:@selector(updateUI:) onThread:mainThread withObject:image waitUntilDone:YES];

• Swift

      // 在主线程中执行操作self.performSelectorOnMainThread(#selector(ViewController.updateUI(_:)), withObject: image, waitUntilDone: true)// 在另一个线程中执行操作let mainThread = NSThread.mainThread()self.performSelector(#selector(ViewController.updateUI(_:)), onThread: mainThread, withObject: image, waitUntilDone: true)

3.4 NSThread 线程系统通知

    NSWillBecomeMultiThreadedNotification   // 将要变成多线程NSDidBecomeSingleThreadedNotification   // 已经变成单线程NSThreadWillExitNotification            // 将要退出子线程

• Objective-C

      // 添加线程系统通知[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(downloadEnd:) name:NSThreadWillExitNotification object:nil];  // 系统通知响应触发事件- (void)downloadEnd:(NSNotification *)notification {NSThread *thread = notification.object;NSLog(@"%@ 线程结束了", thread.name);}

• Swift

      // 添加线程系统通知NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(ViewController.downloadEnd(_:)), name: NSThreadWillExitNotification, object: nil)// 系统通知响应触发事件func downloadEnd(notification: NSNotification){let thread = notification.object as! NSThreadprint("\(thread.name) 线程结束了");}

3.5 NSThread 线程安全

• Objective-C

      // 对线程加锁// 操作变量时需要加线程锁，保证同时只有一个线程在访问该变量。// 实例化线程锁NSLock *threadLock;_threadLock = [[NSLock alloc] init];// 打开线程锁，开始对变量写操作[_threadLock lock];// 关闭线程锁，停止对变量写操作[_threadLock unlock];// 使用互斥锁@synchronized (self) {// 对变量写操作}// 声明变量为原子性 // 声明变量为原子性（默认）@property(assign) NSInteger page;

• Swift

      // 对线程加锁// 操作变量时需要加线程锁，保证同时只有一个线程在访问该变量。// 实例化线程锁var threadLock:NSLock!threadLock = NSLock()// 打开线程锁，开始对变量写操作threadLock.lock()// 关闭线程锁，停止对变量写操作threadLock.unlock()

3.6 自旋锁&互斥锁比较

• 如果重写了原子属性的 setter 方法，相当于覆盖了系统提供的 setter 方法，此时，系统要求，必须重写 getter 方法。

• 定义属性时，系统默认提供 getter & setter 方法，并且生成一个 _成员变量，但是如果自己重写了 getter & setter 方法，_成员变量，不会自动生成。

• @synthesize 合成指令，可以指定保存属性数值的 成员变量。

• 在 Xcode 4.5 之前，开发，程序员必须自己实现 @synthesize 指令。

• Objective-C

      @property (atomic, strong) NSObject *obj1;@property (atomic, strong) NSObject *obj2;

  • 原子属性模拟

        @synthesize obj1 = _obj1;// obj1 - getter- (NSObject *)obj1 {return _obj1;}// obj1 - setter- (void)setObj1:(NSObject *)obj1 {// 使用互斥锁@synchronized(self) {_obj1 = obj1;}}

  • 自旋锁&互斥锁性能测试

        long largeNumber = 1000 * 1000;// 互斥锁测试// 2001-01-01 00:00:00 到现在的秒数CFAbsoluteTime start = CFAbsoluteTimeGetCurrent();                              for (int i = 0; i < largeNumber; ++i) {self.obj1 = [[NSObject alloc] init];}NSLog(@"互斥锁: %f", CFAbsoluteTimeGetCurrent() - start);// 自旋锁测试start = CFAbsoluteTimeGetCurrent();for (int i = 0; i < largeNumber; ++i) {self.obj2 = [[NSObject alloc] init];}NSLog(@"自旋锁: %f", CFAbsoluteTimeGetCurrent() - start);

4、GCD 的使用

4.1 GCD 线程创建

• 1、dispatch_async

  • 常用的方法 dispatch_async，为了避免界面在处理耗时的操作时卡死，比如读取网络数据，IO，数据库读写等，我们会在另外一个线程中处理这些操作，然后通知主线程更新界面。

        dispatch_async(dispatch_get_global_queue(0, 0), ^{// 耗时的操作 Codedispatch_async(dispatch_get_main_queue(), ^{// 更新界面 Code});});

• 2、dispatch_barrier_async

  • dispatch_barrier_async 是在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行，并且所有的任务都不能使用全局的 queue 序列。

• 3、dispatch_group_async

  • dispatch_group_async 可以实现监听一组任务是否完成，等到 group 中的所有任务执行完毕后，由队列调度 dispatch_group_notify block 中的任务异步执行。需要在所有异步任务执行完毕后，统一获得一个通知。group 负责监控任务，queue 负责调度任务。

  • dispatch_group_async 是异步的方法，任务的执行顺序不确定，与任务添加的顺序无关。所有 dispatch_group_async 添加的任务都执行完后，再执行 dispatch_group_notify 添加的任务，但 dispatch_group_notify 添加的任务需最后添加。这个方法很有用，比如你执行两个下载任务，当两个任务都下载完成后你才通知界面说完成的了。

• 4、dispatch_apply

  • dispatch_apply 执行某个代码片段 N 次。任务 同步执行。

• Objective-C

  • 全局队列同步执行任务

        // 全局队列，负责调度任务dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);// 任务，使用 block 来包装任务，block 没有参数，没有返回值void (^task)() = ^ {};// 指定执行任务的函数，不会开启线程，就在当前线程执行 blockdispatch_sync(globalQueue, task);

  • 全局队列异步执行任务

        // 全局队列，负责调度任务dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);// 任务，使用 block 来包装任务，block 没有参数，没有返回值void (^task)() = ^ {};// 指定执行任务的函数，会开启线程，在其他线程执行 blockdispatch_async(globalQueue, task);

  • 创建 dispatch_async 线程

        dispatch_async(dispatch_get_global_queue(0, 0), ^{// 耗时的操作 CodeNSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:imageUrlPath]];UIImage *image = [[UIImage alloc] initWithData:data];dispatch_async(dispatch_get_main_queue(), ^{// 更新界面，刷新主线程 Codeself.imageView.image = image;});});

  • 顺序操作

        // myQueue 不能使用全局的对列dispatch_queue_t myQueue = dispatch_queue_create("qq", DISPATCH_QUEUE_CONCURRENT);                      dispatch_async(myQueue, ^{NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:imageUrlPath]];_backImage = [[UIImage alloc] initWithData:data];});dispatch_async(myQueue, ^{NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:iconImageUrlPath]];_iconImage = [[UIImage alloc] initWithData:data];});dispatch_barrier_async(myQueue, ^{dispatch_async(dispatch_get_main_queue(), ^{self.iconImageView.image = _iconImage;}); });dispatch_async(myQueue, ^{dispatch_async(dispatch_get_main_queue(), ^{self.imageView.image = _backImage;}); });

  • 群组操作，线程通知

        // queue 负责调度任务dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);// group 负责监控任务dispatch_group_t group = dispatch_group_create();// 第一个任务dispatch_group_async(group, globalQueue, ^{NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:imageUrlPath]];_backImage = [[UIImage alloc] initWithData:data];});// 第二个任务dispatch_group_async(group, globalQueue, ^{NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:iconImageUrlPath]];_iconImage = [[UIImage alloc] initWithData:data];});// 其它所有添加的任务都执行完后，再执行该任务，但该任务需最后添加dispatch_group_notify(group, dispatch_get_main_queue(), ^{self.imageView.image = _backImage;self.iconImageView.image = _iconImage;});

  • 群组操作实现原理

        /*The dispatch_group_async() convenience function behaves like so:voiddispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block){dispatch_retain(group);dispatch_group_enter(group);dispatch_async(queue, ^{block();dispatch_group_leave(group);dispatch_release(group);});}*/// queue 负责调度任务dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);// group 负责监控任务dispatch_group_t group = dispatch_group_create();// 入组，之后的 block 会被 group 监听dispatch_group_enter(group);dispatch_async(globalQueue, ^{NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:imageUrlPath]];_backImage = [[UIImage alloc] initWithData:data];// 出组，block 的末尾，所有任务执行完毕后，添加一个出组，dispatch_group_enter & dispatch_group_leave 必须成对出现dispatch_group_leave(group);});// 入组，之后的 block 会被 group 监听dispatch_group_enter(group);dispatch_async(globalQueue, ^{NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:iconImageUrlPath]];_iconImage = [[UIImage alloc] initWithData:data];// 出组，block 的末尾，所有任务执行完毕后，添加一个出组，dispatch_group_enter & dispatch_group_leave 必须成对出现dispatch_group_leave(group);});// 阻塞式等待调度组中所有任务执行完毕dispatch_group_wait(group, DISPATCH_TIME_FOREVER);// 群组结束dispatch_group_notify(group, dispatch_get_main_queue(), ^{self.imageView.image = _backImage;self.iconImageView.image = _iconImage;  });

  • 延迟操作

        // 从现在开始 n 纳秒后，1.0 * NSEC_PER_SEC = 1 秒dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));// 延迟指定时间（纳秒）后在指定的队列中调度执行，异步执行dispatch_after(when, dispatch_get_global_queue(0, 0), ^{NSLog(@"%@", [NSThread currentThread]);});

  • 循环操作

        // 循环执行设定的次数（5 次），同步执行dispatch_apply(5, dispatch_get_global_queue(0, 0), ^(size_t index) {                            NSLog(@"dispatch_apply: %zu --- %@", index, [NSThread currentThread]);});

  • 一次性操作

        /*有的时候，在程序开发中，有些代码只想从程序启动就只执行一次，典型的应用场景就是 “单例”。dispatch_once 能够保证 block 中的代码，只会被执行一次，onceToken == 0 时就会执行 block 的代码，执行后 变为 -1，dispatch 内部也有一把锁，是能够保证 "线程安全" 的，而且是苹果公司推荐使用的。block 同步执行，能够保证后续的代码直接使用 block 执行后的结果。*/// 同步执行static dispatch_once_t onceToken;dispatch_once(&onceToken, ^{});

  • 同步任务的作用

        // 同步任务，可以让其他异步执行的任务，"依赖" 某一个同步任务。例如：在用户登录之后，再异步下载文件。// 队列dispatch_queue_t q = dispatch_queue_create("qq", DISPATCH_QUEUE_CONCURRENT);// 异步执行 taskdispatch_async(q, ^{dispatch_sync(q, ^{NSLog(@"Login %@", [NSThread currentThread]);});dispatch_async(q, ^{NSLog(@"Download A %@", [NSThread currentThread]);});dispatch_async(q, ^{NSLog(@"Download B %@", [NSThread currentThread]);});});

  • 主队列同步任务不死锁

        // 主线程中主队列同步执行时，主队列和主线程相互等待会造成死锁。在子线程中执行不会死锁。// 并发队列dispatch_queue_t q = dispatch_queue_create("qq", DISPATCH_QUEUE_CONCURRENT);// 任务void (^task)() = ^ {dispatch_sync(dispatch_get_main_queue(), ^{NSLog(@"come here %@", [NSThread currentThread]);});};// 异步执行任务dispatch_async(q, task);

• Swift

  • 全局队列同步执行任务

        // 全局队列，负责调度任务let q:dispatch_queue_t = dispatch_get_global_queue(0, 0);// 任务，使用 闭包 来包装任务，闭包 没有参数，没有返回值let task:(() -> Void) = {}// 指定执行任务的函数，不会开启线程，就在当前线程执行 闭包dispatch_sync(q, task);

  • 全局队列异步执行任务

        // 全局队列，负责调度任务let q:dispatch_queue_t = dispatch_get_global_queue(0, 0);// 任务，使用 闭包 来包装任务，闭包 没有参数，没有返回值let task:(() -> Void) = {}// 指定执行任务的函数，会开启线程，在其他线程执行 闭包dispatch_async(q, task);

  • 创建 dispatch_async 线程

        dispatch_async(dispatch_get_global_queue(0, 0)) {// 耗时的操作 Codelet data = NSData(contentsOfURL: NSURL(string: self.imageUrlPath)!)let image = UIImage(data: data!)dispatch_async(dispatch_get_main_queue()) {// 更新界面，刷新主线程 Code                  self.imageView.image = image}}

  • 顺序操作

        // myQueue 不能使用全局的序列let myQueue:dispatch_queue_t = dispatch_queue_create("qq", DISPATCH_QUEUE_CONCURRENT)dispatch_async(myQueue) {let data = NSData(contentsOfURL: NSURL(string: self.imageUrlPath)!)self.backImage = UIImage(data: data!)}dispatch_async(myQueue) {let data = NSData(contentsOfURL: NSURL(string: self.iconImageUrlPath)!)self.iconImage = UIImage(data: data!)}dispatch_barrier_async(myQueue) {dispatch_async(dispatch_get_main_queue(), {self.iconImageView.image = self.iconImage})NSThread.sleepForTimeInterval(4)}dispatch_async(myQueue) {dispatch_async(dispatch_get_main_queue(), {self.imageView.image = self.backImage})}

  • 群组操作

        // queue 负责调度任务let globalQueue = dispatch_get_global_queue(0, 0)// group 负责监控任务let group = dispatch_group_create()// 第一个任务dispatch_group_async(group, globalQueue) {let data = NSData(contentsOfURL: NSURL(string: self.imageUrlPath)!)self.backImage = UIImage(data: data!)print("第一个任务完成")}// 第二个任务dispatch_group_async(group, globalQueue) {let data = NSData(contentsOfURL: NSURL(string: self.iconImageUrlPath)!)self.iconImage = UIImage(data: data!)print("第二个任务完成")}// 其它所有添加的任务都执行完后，再执行该任务，但该任务需最后添加dispatch_group_notify(group, dispatch_get_main_queue()) {// 异步执行self.imageView.image = self.backImageself.iconImageView.image = self.iconImageprint("更新界面")}

  • 群组操作实现原理

        /*The dispatch_group_async() convenience function behaves like so:voiddispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block){dispatch_retain(group);dispatch_group_enter(group);dispatch_async(queue, ^{block();dispatch_group_leave(group);dispatch_release(group);});}*/// queue 负责调度任务let globalQueue = dispatch_get_global_queue(0, 0)// group 负责监控任务let group = dispatch_group_create()// 入组，之后的 block 会被 group 监听dispatch_group_enter(group)dispatch_async(globalQueue) { let data = NSData(contentsOfURL: NSURL(string: self.imageUrlPath)!)self.backImage = UIImage(data: data!)// 出组，block 的末尾，所有任务执行完毕后，添加一个出，dispatch_group_enter & dispatch_group_leave 必须成对出现dispatch_group_leave(group)}// 入组，之后的 block 会被 group 监听dispatch_group_enter(group)dispatch_async(globalQueue) {let data = NSData(contentsOfURL: NSURL(string: self.iconImageUrlPath)!)self.iconImage = UIImage(data: data!)// 出组，block 的末尾，所有任务执行完毕后，添加一个出组，dispatch_group_enter & dispatch_group_leave 必须成对出现dispatch_group_leave(group)}// 阻塞式等待调度组中所有任务执行完毕dispatch_group_wait(group, DISPATCH_TIME_FOREVER)// 群组结束dispatch_group_notify(group, dispatch_get_main_queue()) {// 异步执行self.imageView.image = self.backImageself.iconImageView.image = self.iconImage   }

  • 延迟操作

        // 从现在开始 n 纳秒后，1 * NSEC_PER_SEC = 1 秒let when:dispatch_time_t = dispatch_time(DISPATCH_TIME_NOW, (Int64)(1 * NSEC_PER_SEC))// 延迟指定时间（纳秒）后在指定的队列中调度执行，异步执行dispatch_after(when, dispatch_get_global_queue(0, 0)) {}

  • 循环操作

        // 循环执行设定的次数（5 次），同步执行dispatch_apply(5, dispatch_get_global_queue(0, 0)) { (index:Int) in}

  • 一次性操作

        /*有的时候，在程序开发中，有些代码只想从程序启动就只执行一次，典型的应用场景就是 “单例”。dispatch_once 能够保证 block 中的代码，只会被执行一次，onceToken == 0 时就会执行 block 的代码，执行后 变为 -1，dispatch 内部也有一把锁，是能够保证 "线程安全" 的，而且是苹果公司推荐使用的。block 同步执行，能够保证后续的代码直接使用 block 执行后的结果。*/// 同步执行struct Static {static var onceToken: dispatch_once_t = 0}dispatch_once(&Static.onceToken, {})

  • 同步任务的作用

        // 同步任务，可以让其他异步执行的任务，"依赖" 某一个同步任务。例如：在用户登录之后，再异步下载文件。// 队列let q:dispatch_queue_t = dispatch_queue_create("qq", DISPATCH_QUEUE_CONCURRENT)dispatch_async(q) { // 异步执行 taskdispatch_sync(q, {})dispatch_async(q, { })dispatch_async(q, {})}

  • 主队列同步任务不死锁

        // 主线程中主队列同步执行时，主队列和主线程相互等待会造成死锁。在子线程中执行不会死锁。// 队列let q:dispatch_queue_t = dispatch_queue_create("qq", DISPATCH_QUEUE_CONCURRENT)// 任务let task:(() -> Void) = {dispatch_async(dispatch_get_main_queue(), { })}// 异步执行任务dispatch_async(q, task)

4.2 GCD 线程设置

• Objective-C

  • 调度组的创建

        // 创建调度组dispatch_group_t group = dispatch_group_create();

  • 线程队列的创建

        // 获取全局队列dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);// 获取主线程队列dispatch_queue_t mainQueue = dispatch_get_main_queue();// 创建串行队列dispatch_queue_t mySerialQueue = dispatch_queue_create("mySerialQueue", NULL);// 创建并发队列dispatch_queue_t myConcurrentQueue = dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT);

  • 全局队列的获取

        /*dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);全局队列，是 GCD 为了方便程序员的多线程开发提供的 dispatch_get_global_queue，本身就是一个并发队列。参数：1. identifier：服务质量（队列对任务调度的优先级）/iOS 7.0 之前，是优先级iOS 8.0＋ 告诉队列执行任务的 "服务质量 quality of service"：QOS_CLASS_USER_INTERACTIVE 0x21,               用户交互(希望尽快完成，用户对结果很期望，不要放太耗时操作)QOS_CLASS_USER_INITIATED 0x19,                 用户期望(希望快，不要放太耗时操作)QOS_CLASS_DEFAULT 0x15,                        默认(不是给程序员使用的，用来重置对列使用的)QOS_CLASS_UTILITY 0x11,                        实用工具(耗时操作，专门用来处理耗时操作)QOS_CLASS_BACKGROUND 0x09,                     后台QOS_CLASS_UNSPECIFIED 0x00,                    未指定，可以和 iOS 7.0 适配iOS 7.0 及之前 优先级：DISPATCH_QUEUE_PRIORITY_HIGH 2                 高优先级DISPATCH_QUEUE_PRIORITY_DEFAULT 0              默认优先级DISPATCH_QUEUE_PRIORITY_LOW (-2)               低优先级DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN   后台优先级提示：不要选择 BACKGROUND 的选项，苹果认为：BACKGROUND 表示用户不需要知道任务什么时候完成。选择这个选项，速度慢的令人发指！不利于调试。关于优先级，不要搞太负责，就用最简单的。结论：如果要做 iOS 8.0 & iOS 7.0 的适配，使用以下代码：dispatch_get_global_queue(0, 0);如果要做 iOS 8.0 & iOS 9.0 的适配，应该选择 QOS_CLASS_UTILITY2. flags：保留标记是为了未来使用保留的。这个参数应该永远指定为 0。*/// 获取全局队列dispatch_queue_t globalQueue = dispatch_get_global_queue(QOS_CLASS_UTILITY, 0);

• Swift

  • 调度组的创建

        // 创建调度组let group:dispatch_group_t = dispatch_group_create()

  • 线程队列的创建

        // 获取全局队列let globalQueue:dispatch_queue_t = dispatch_get_global_queue(0, 0)// 获取主线程队列let mainQueue:dispatch_queue_t = dispatch_get_main_queue()// 创建串行队列let mySerialQueue:dispatch_queue_t = dispatch_queue_create("mySerialQueue", nil);// 创建并发队列let myConcurrentQueue:dispatch_queue_t = dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT)

4.3 GCD 线程间通信

• 子线程里不允许操作 UI。

• 在子线程中调用主线程队列，执行刷新 UI 等操作。

• Objective-C

      dispatch_async(dispatch_get_main_queue(), ^{// 更新界面，刷新主线程 Code});

• Swift

      dispatch_async(dispatch_get_main_queue()) {// 更新界面，刷新主线程 Code}

5、NSOperation 的使用

5.1 NSOperation 线程创建

• NSOpeartion 是对 GCD 的封装，是 OC 的，比 GCD 的使用简单。即将 “操作” 添加到队列。

  • 队列：全局队列(并发队列)。
  • 操作：异步执行的任务。

• 使用 NSOperation 的方式有两种：

  • 1、用定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。
  • 2、继承 NSOperation，NSOperation 也是设计用来扩展的，只需继承 NSOperation 在 .m 文件中实现 main 方法，main 方法编写要执行的代码即可。然后把 NSOperation 子类的对象放入NSOperationQueue 队列中，该队列就会启动并开始处理它。

• Objective-C

  • 创建一个 block 风格的任务

        // 创建任务操作队列NSOperationQueue *operationQueue = [[NSOperationQueue alloc] init];NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{[self downloadImage1:imageUrlPath];}];// 将一个操作任务加到队列中，如果队列中的任务数小于最大并发数，会立即执行，否则任务排队[operationQueue addOperation:operation];

  • 直接向队列添加 block

        // 创建任务操作队列NSOperationQueue *operationQueue = [[NSOperationQueue alloc] init];// 直接向操作队列添加操作 block[operationQueue addOperationWithBlock:^{[self downloadImage1:imageUrlPath];}];

  • 含主队列的任务

        [[[NSOperationQueue alloc] init] addOperationWithBlock:^{// 耗时的操作 CodeNSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:imageUrlPath]];UIImage *image = [[UIImage alloc] initWithData:data];[[NSOperationQueue mainQueue] addOperationWithBlock:^{// 更新界面，刷新主线程 Codeself.imageView.image = image;}];}];

  • 创建一个普通的任务

        // 创建任务操作队列NSOperationQueue *operationQueue = [[NSOperationQueue alloc] init];// 创建一个普通的操作任务NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage1:) object:imageUrlPath];// 将一个操作任务加到队列中，如果队列中的任务数小于最大并发数，会立即执行，否则任务排队[operationQueue addOperation:operation];

  • 子线程执行方法

        - (void)downloadImage:(NSString *) urlPath {}

• Swift

  • 创建一个 block 风格的任务

        // 创建任务操作队列let operationQueue = NSOperationQueue()let operation = NSBlockOperation {self.downloadImage1(self.imageUrlPath)}// 将一个操作任务加到队列中，如果队列中的任务数小于最大并发数，会立即执行，否则任务排队operationQueue.addOperation(operation)

  • 直接向队列添加 block

        // 创建任务操作队列let operationQueue = NSOperationQueue()// 直接向操作队列添加操作 blockoperationQueue.addOperationWithBlock {self.downloadImage1(self.imageUrlPath)}

  • 含主队列的任务

        NSOperationQueue().addOperationWithBlock { // 耗时的操作 Codelet data = NSData(contentsOfURL: NSURL(string: self.imageUrlPath)!)let image = UIImage(data: data!)NSOperationQueue.mainQueue().addOperationWithBlock({ // 更新界面，刷新主线程 Codeself.imageView.image = image})}

  • 子线程执行方法

        func downloadImage(urlPath: String) {}

5.2 NSOperation 线程设置

• Objective-C

  • 队列设置

        // 创建全局并发队列NSOperationQueue *globalQueue = [[NSOperationQueue alloc] init];// 获取当前队列NSOperationQueue *currentQueue = [NSOperationQueue currentQueue];// 获取主队列NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];// 向队列添加操作[operationQueue addOperation:operation];// 向队列添加多个操作/*NO 异步的，YES 同步的*/[operationQueue addOperations:@[operation1, operation2] waitUntilFinished:NO];// 向队列添加操作 block[operationQueue addOperationWithBlock:^{}];// 设置最大并发数/*默认情况下是 -1，-1 表示没有限制，会同时运行队列中的全部的操作*/operationQueue.maxConcurrentOperationCount = 4;// 设置队列名称operationQueue.name = @"myOperationQueue";// 设置队列服务质量operationQueue.qualityOfService = NSQualityOfServiceUtility;// 设置队列是否挂起/*YES 挂起，NO 继续执行队列挂起，当前 "没有完成的操作" 是包含在队列的操作数中的队列挂起，不会影响已经执行操作的执行状态对列一旦被挂起，再添加的操作不会被调度*/operationQueue.suspended = YES;// 判断队列是否挂起BOOL isSuspended = operationQueue.isSuspended;// 给队列中所有操作发送取消(cancel)消息/*在队列取消完成之前，操作计数并不会发生变化系统的所有方法都没有对 isCancelled 做判断正在执行的操作不会响应 cancel 消息，不会取消正在执行中的操作，不会影响队列的挂起状态*/[operationQueue cancelAllOperations];// 获取队列中操作的数量NSUInteger operationCount = operationQueue.operationCount;// 获取队列中的所有操作NSArray *operations = operationQueue.operations;// 等待所有操作完成[operationQueue waitUntilAllOperationsAreFinished];

  • 操作设置

        // 设置操作间依赖关系/*operation2 依赖于 operation1*/[operation2 addDependency:operation1];// 移除操作间依赖关系 [operation2 removeDependency:operation1];// 获取依赖的所有操作，readonlyNSArray *dependencies = operation2.dependencies;// 取消操作[operation cancel];// 判断操作是否被取消，readonlyBOOL isCancelled = operation.isCancelled;// 判断操作是否正在被执行，readonlyBOOL isExecuting = operation.isExecuting;// 判断操作是否执行完成，readonlyBOOL isFinished = operation.isFinished;// 判断操作是否是异步执行的，readonlyBOOL isAsynchronous = operation.isAsynchronous;// 判断操作是否准备好执行，readonlyBOOL isReady = operation.isReady;// 设置操作名称operation.name = @"myOperation";// 设置操作队列优先级operation.queuePriority = NSOperationQueuePriorityNormal;// 设置操作服务质量operation.qualityOfService = NSQualityOfServiceUtility;// 等待操作完成[operation waitUntilFinished];// 在当前线程中开始执行操作[operation start];// 设置操作完成的回调[operation setCompletionBlock:^{NSLog(@"任务一完成了");}];// 设置操作完成的回调[operationQueue.operations[0] setCompletionBlock:^{NSLog(@"任务一完成了");}];

• Swift

  • 队列设置

        // 创建全局并发队列let globalQueue:NSOperationQueue = NSOperationQueue()// 获取当前队列let currentQueue:NSOperationQueue? = NSOperationQueue.currentQueue()// 获取住队列let mainQueue:NSOperationQueue = NSOperationQueue.mainQueue()// 向队列添加操作operationQueue.addOperation(operation)// 向队列添加多个操作/*NO 异步的，YES 同步的*/operationQueue.addOperations([operation1, operation2], waitUntilFinished: false)    // 向队列添加操作 blockoperationQueue.addOperationWithBlock {}// 设置最大并发数/*默认情况下是 -1，-1 表示没有限制，会同时运行队列中的全部的操作*/operationQueue.maxConcurrentOperationCount = 4// 设置队列名称operationQueue.name = "myOperationQueue"// 设置队列服务质量operationQueue.qualityOfService = .Utility// 设置队列是否挂起/*YES 挂起，NO 继续执行队列挂起，当前 "没有完成的操作" 是包含在队列的操作数中的队列挂起，不会影响已经执行操作的执行状态对列一旦被挂起，再添加的操作不会被调度*/operationQueue.suspended = true// 判断队列是否挂起let isSuspended:Bool = operationQueue.suspended// 给队列中所有操作发送取消(cancel)消息/*在队列取消完成之前，操作计数并不会发生变化系统的所有方法都没有对 isCancelled 做判断正在执行的操作不回响应 cancel 消息，不会取消正在执行中的操作，不会影响队列的挂起状态*/operationQueue.cancelAllOperations()// 获取队列中操作的数量let operationCount:Int = operationQueue.operationCount// 获取队列中的所有操作let operations:[NSOperation] = operationQueue.operations// 等待所有操作完成operationQueue.waitUntilAllOperationsAreFinished()

  • 操作设置

        // 设置操作间依赖关系/*operation2 依赖于 operation1*/operation2.addDependency(operation1)// 移除操作间依赖关系operation2.removeDependency(operation1)// 获取依赖的所有操作，readonlylet dependencies:[NSOperation] = operation2.dependencies// 取消操作operation.cancel()// 判断操作是否被取消，readonlylet isCancelled:Bool = operation.cancelled// 判断操作是否正在被执行，readonlylet isExecuting:Bool = operation.executing// 判断操作是否执行完成，readonlylet isFinished:Bool = operation.finished// 判断操作是否是异步执行的，readonlylet isAsynchronous:Bool = operation.asynchronous// 判断操作是否准备好执行，readonlylet isReady:Bool = operation.ready// 设置操作名称operation.name = "myOperation"// 设置操作队列优先级operation.queuePriority = .Normal// 设置操作服务质量operation.qualityOfService = .Utility// 等待操作完成operation.waitUntilFinished()// 在当前线程中开始执行操作operation.start()// 设置操作完成的回调operation.completionBlock = {print("任务一完成了")}// 设置操作完成的回调operationQueue.operations[0].completionBlock = {print("任务一完成了")}

5.3 NSOperation 线程间通信

• 子线程里不允许操作 UI

  • Objective-C

        [[[NSOperationQueue alloc] init] addOperationWithBlock:^{                                               // 在子队列中执行耗时的操作[[NSOperationQueue mainQueue] addOperationWithBlock:^{                                              // 在主队列中执行刷新 UI 等操作}];}];

  • Swift

        NSOperationQueue().addOperationWithBlock {                                              // 在子队列中执行耗时的操作NSOperationQueue.mainQueue().addOperationWithBlock({                                // 在主队列中执行刷新 UI 等操作})}

5.4 NSOperation 指定依赖关系

• Objective-C

      NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{NSLog(@"用户登录 %@", [NSThread currentThread]);}];NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{NSLog(@"付费 %@", [NSThread currentThread]);}];NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{[NSThread sleepForTimeInterval:1.0f];NSLog(@"下载 %@", [NSThread currentThread]);}];NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{NSLog(@"更新UI %@", [NSThread currentThread]);}];// 付费之前需要登录，在指定依赖关系时，不要出现循环依赖[op2 addDependency:op1];// 下载之前需要付费[op3 addDependency:op2];// 更新UI之前需要完成下载[op4 addDependency:op3];// NO 异步的，YES 同步的[[[NSOperationQueue alloc] init] addOperations:@[op1, op2, op3] waitUntilFinished:NO];// 更新 UI 的操作，应该由主队列来调度[[NSOperationQueue mainQueue] addOperation:op4];

• Swift

      let op1 = NSBlockOperation.init { print("用户登录 \(NSThread.currentThread())")}let op2 = NSBlockOperation.init {print("付费 \(NSThread.currentThread())")}let op3 = NSBlockOperation.init {print("下载 \(NSThread.currentThread())")}let op4 = NSBlockOperation.init {print("更新UI \(NSThread.currentThread())")}// 付费之前需要登录，在指定依赖关系时，不要出现循环依赖op2.addDependency(op1)// 下载之前需要付费op3.addDependency(op2)// 更新UI之前需要完成下载op4.addDependency(op3)// NO 异步的，YES 同步的NSOperationQueue().addOperations([op1, op2, op3], waitUntilFinished: false)// 更新 UI 的操作，应该由主队列来调度NSOperationQueue.mainQueue().addOperation(op4)

5.5 自定义 NSOperation 操作

• Objective-C

  • WebImageOperation.h

        @interface WebImageOperation : NSOperation///  实例化 web 图像操作+ (instancetype)webImageOperationWithURLString:(NSString *)urlString completion:(void (^)(UIImage *image))completion;@end

  • WebImageOperation.m

        /// 下载图片的 URL@property (nonatomic, copy) NSString *urlStr;/// 下载完成的回调@property (nonatomic, copy) void (^completion) (UIImage *image);+ (instancetype)webImageOperationWithURLString:(NSString *)urlString completion:(void (^)(UIImage *))completion {WebImageOperation *imageOperation = [[self alloc] init];imageOperation.urlStr= urlString;imageOperation.completion = completion;return imageOperation;}// 操作加入队列后会自动执行该方法- (void)main {@autoreleasepool {if (self.isCancelled) return;NSURL *url = [NSURL URLWithString:self.urlStr];NSData *data = [NSData dataWithContentsOfURL:url];if (self.isCancelled) return;if (self.completion && data != nil) {[[NSOperationQueue mainQueue] addOperationWithBlock:^{self.completion([UIImage imageWithData:data]);  }];}}}

  • ViewController.m

        // 自定义 NSOperation 操作WebImageOperation *downloadOperation = [WebImageOperation webImageOperationWithURLString:imageUrlPath completion:^(UIImage *image) {self.imageView.image = image;}];// 将操作添加到队列[[[NSOperationQueue alloc] init] addOperation:downloadOperation];

• Swift

  • WebImageOperation.swift

        class WebImageOperation: NSOperation/// 下载图片的 URLvar urlStr:String!/// 下载完成的回调var completion:((image:UIImage) -> Void)!class func webImageOperationWithURLString(urlString:String, completion:((image:UIImage) -> Void)) -> WebImageOperation {let imageOperation:WebImageOperation = WebImageOperation()imageOperation.urlStr = urlStringimageOperation.completion = completionreturn imageOperation}// 操作加入队列后会自动执行该方法override func main() {if self.cancelled == true {return}let url:NSURL = NSURL(string: self.urlStr)!let data:NSData? = NSData(contentsOfURL: url)if self.cancelled == true {return}if (self.completion != nil) && (data != nil) {NSOperationQueue.mainQueue().addOperationWithBlock({self.completion(image: UIImage(data: data!)!)})}}

  • ViewController.swift

        // 自定义 NSOperation 操作let downloadOperation:WebImageOperation = WebImageOperation.webImageOperationWithURLString(imageUrlPath) { (image:UIImage) inself.imageView.image = image}// 将操作添加到队列NSOperationQueue().addOperation(downloadOperation)