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 中多线程实现方案

Threads7

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;

    // 判断线程是否正在执行 readonly
    BOOL isExecuting = myThread.isExecuting;

    // 判断线程是否完成 readonly
    BOOL isFinished = myThread.isFinished;

    // 判断线程是否被取消 readonly
    BOOL 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

    // 判断线程是否正在执行 readonly
    let isExecuting:Bool = myThread.executing

    // 判断线程是否完成 readonly
    let isFinished:Bool = myThread.finished

    // 判断线程是否被取消 readonly
    let isCancelled:Bool = myThread.cancelled

    // 获取当前线程
    let currentThread:NSThread = NSThread.currentThread()

    // 判断当前线程是否为主线程
    /*
        可以在所有的多线程技术中使用
    */
    let isMainThread:Bool = NSThread.currentThread().isMainThread
    let 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! NSThread

            print("\(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), ^{

        // 耗时的操作 Code

        dispatch_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)() = ^ {

    };

    // 指定执行任务的函数，不会开启线程，就在当前线程执行 block
    dispatch_sync(globalQueue, task);

全局队列异步执行任务

    // 全局队列，负责调度任务
    dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);

    // 任务，使用 block 来包装任务，block 没有参数，没有返回值
    void (^task)() = ^ {

    };

    // 指定执行任务的函数，会开启线程，在其他线程执行 block
    dispatch_async(globalQueue, task);

创建 dispatch_async 线程

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        // 耗时的操作 Code
        NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:imageUrlPath]];
        UIImage *image = [[UIImage alloc] initWithData:data];

        dispatch_async(dispatch_get_main_queue(), ^{

            // 更新界面，刷新主线程 Code
            self.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:

        void
        dispatch_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);

    // 异步执行 task
    dispatch_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)) {

        // 耗时的操作 Code

        let 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.backImage
        self.iconImageView.image = self.iconImage

        print("更新界面")
    }

群组操作实现原理

    /*
        The dispatch_group_async() convenience function behaves like so:

        void
        dispatch_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.backImage
        self.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) { 

        // 异步执行 task
        dispatch_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_UTILITY

            2. 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:^{

        // 耗时的操作 Code
        NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:imageUrlPath]];
        UIImage *image = [[UIImage alloc] initWithData:data];

        [[NSOperationQueue mainQueue] addOperationWithBlock:^{

            // 更新界面，刷新主线程 Code
            self.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()

    // 直接向操作队列添加操作 block
    operationQueue.addOperationWithBlock {

        self.downloadImage1(self.imageUrlPath)
    }

含主队列的任务

    NSOperationQueue().addOperationWithBlock { 

        // 耗时的操作 Code
        let data = NSData(contentsOfURL: NSURL(string: self.imageUrlPath)!)

        let image = UIImage(data: data!)

        NSOperationQueue.mainQueue().addOperationWithBlock({ 

            // 更新界面，刷新主线程 Code
            self.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];

    // 获取依赖的所有操作，readonly
    NSArray *dependencies = operation2.dependencies;

    // 取消操作
    [operation cancel];

    // 判断操作是否被取消，readonly
    BOOL isCancelled = operation.isCancelled;

    // 判断操作是否正在被执行，readonly
    BOOL isExecuting = operation.isExecuting;

    // 判断操作是否执行完成，readonly
    BOOL isFinished = operation.isFinished;

    // 判断操作是否是异步执行的，readonly
    BOOL isAsynchronous = operation.isAsynchronous;

    // 判断操作是否准备好执行，readonly
    BOOL 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)    
    // 向队列添加操作 block
    operationQueue.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)

    // 获取依赖的所有操作，readonly
    let dependencies:[NSOperation] = operation2.dependencies

    // 取消操作
    operation.cancel()

    // 判断操作是否被取消，readonly
    let isCancelled:Bool = operation.cancelled

    // 判断操作是否正在被执行，readonly
    let isExecuting:Bool = operation.executing

    // 判断操作是否执行完成，readonly
    let isFinished:Bool = operation.finished

    // 判断操作是否是异步执行的，readonly
    let isAsynchronous:Bool = operation.asynchronous

    // 判断操作是否准备好执行，readonly
    let 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

    /// 下载图片的 URL
    var urlStr:String!

    /// 下载完成的回调
    var completion:((image:UIImage) -> Void)!

    class func webImageOperationWithURLString(urlString:String, 
                                   completion:((image:UIImage) -> Void)) -> WebImageOperation {

        let imageOperation:WebImageOperation = WebImageOperation()

        imageOperation.urlStr = urlString
        imageOperation.completion = completion

        return 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) in

        self.imageView.image = image
    }

    // 将操作添加到队列
    NSOperationQueue().addOperation(downloadOperation)

iOS - Threads 多线程

1、Threads

1.1 进程

1.2 线程

1.2.1 线程的串行

1.2.2 多线程原理

1.2.3 多线程优点

1.2.4 多线程缺点

1.2.5 主线程

1.2.6 线程状态

1.2.7 线程安全

1.2.8 线程间通信

1.3 iOS 中多线程实现方案

1.3.1 pthread

1.3.2 NSThread

1.3.3 GCD

1.3.4 NSOperation

2、pthread 的使用

2.1 pthread 线程创建

3、NSThread 的使用

3.1 NSThread 线程创建

3.2 NSThread 线程设置

3.3 NSThread 线程间通信

3.4 NSThread 线程系统通知

3.5 NSThread 线程安全

3.6 自旋锁&互斥锁比较

4、GCD 的使用

4.1 GCD 线程创建

4.2 GCD 线程设置

4.3 GCD 线程间通信

5、NSOperation 的使用

5.1 NSOperation 线程创建

5.2 NSOperation 线程设置

5.3 NSOperation 线程间通信

5.4 NSOperation 指定依赖关系

5.5 自定义 NSOperation 操作

热门文章

最新文章

相关电子书