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;

    // 判断线程是否正在执行 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)
时间： 2024-10-29 23:44:47

iOS - Threads 多线程的相关文章

PHP安装threads多线程扩展基础教程_php实例

一.下载pthreads扩展 下载地址:http://windows.php.net/downloads/pecl/releases/pthreads 二.判断PHP是ts还是nts版 通过phpinfo(); 查看其中的 Thread Safety 项,这个项目就是查看是否是线程安全,如果是:enabled,一般来说应该是ts版,否则是nts版. 三.根据PHP ts\nts版选择对应pthreads的版本 本人php版本是5.4.17的所以下载php_pthreads-0.1.0-5.4-t

iOS开发多线程篇—多线程简单介绍

一.进程和线程 1.什么是进程 进程是指在系统中正在运行的一个应用程序 每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内 比如同时打开QQ.Xcode,系统就会分别启动2个进程 通过"活动监视器"可以查看Mac系统中所开启的进程 2.什么是线程 1个进程要想执行任务,必须得有线程(每1个进程至少要有1条线程) 线程是进程的基本执行单元,一个进程(程序)的所有任务都在线程中执行 比如使用酷狗播放音乐.使用迅雷下载电影,都需要在线程中执行 3.线程的串行 1个线程中任务的执

iOS开发多线程篇—线程安全

一.多线程的安全隐患 资源共享 1块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源 比如多个线程访问同一个对象.同一个变量.同一个文件 当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题 示例一: 示例二: 问题代码: 1 // 2 // YYViewController.m 3 // 05-线程安全 4 // 5 // Created by apple on 14-6-23. 6 // Copyright (c) 2014年 itcase. All rights res

iOS开发多线程篇—GCD介绍

一.简单介绍 1.什么是GCD? 全称是Grand Central Dispatch,可译为"牛逼的中枢调度器" 纯C语言,提供了非常多强大的函数 2.GCD的优势 GCD是苹果公司为多核的并行运算提出的解决方案 GCD会自动利用更多的CPU内核(比如双核.四核) GCD会自动管理线程的生命周期(创建线程.调度任务.销毁线程) 程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码 3.提示 (1)GCD存在于libdispatch.dylib这个库中,这个调度库包含了GC

iOS开发多线程篇—NSOperation简单介绍

一.NSOperation简介 1.简单说明 NSOperation的作⽤:配合使用NSOperation和NSOperationQueue也能实现多线程编程 NSOperation和NSOperationQueue实现多线程的具体步骤: (1)先将需要执行的操作封装到一个NSOperation对象中 (2)然后将NSOperation对象添加到NSOperationQueue中 (3)系统会⾃动将NSOperationQueue中的NSOperation取出来 (4)将取出的NSOperati

iOS开发多线程篇—GCD的常见用法

一.延迟执行 1.介绍 iOS常见的延时执行有2种方式 (1)调用NSObject的方法 [self performSelector:@selector(run) withObject:nil afterDelay:2.0]; // 2秒后再调用self的run方法 (2)使用GCD函数 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue()

详解iOS中多线程app开发的GCD队列的使用_IOS

GCD的基本使用 一.主队列介绍 主队列:是和主线程相关联的队列,主队列是GCD自带的一种特殊的串行队列,放在主队列中得任务,都会放到主线程中执行. 提示:如果把任务放到主队列中进行处理,那么不论处理函数是异步的还是同步的都不会开启新的线程. 获取主队列的方式: 复制代码 代码如下:  dispatch_queue_t queue=dispatch_get_main_queue(); (1)使用异步函数执行主队列中得任务,代码示例: 复制代码 代码如下: // //  YYViewControl

实例解析iOS应用多线程开发中NSthread类的用法_IOS

一.NSthread的初始化 1.动态方法 复制代码 代码如下: - (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument;  // 初始化线程  NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];  // 设置线程的优先级(0.0 - 1.0,1.0最高级)  thre

iOS开发多线程篇—创建线程

一.创建和启动线程简单说明 一个NSThread对象就代表一条线程 创建.启动线程 (1) NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil]; [thread start]; // 线程一启动,就会在线程thread中执行self的run方法 主线程相关用法 + (NSThread *)mainThread; // 获得主线程 - (BOOL)isMainThr