iOS---多线程GCD（整理）

IOS—GCD的学习

前言

本篇学习的是多线程GCD，关于GCD的总结，简书上有一篇非常详细的文章，本文大部分也是摘抄于此，iOS 多线程：『GCD』详尽总结

学习之前需了解的知识

1.什么是进程，什么是线程？

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

进程是操作系统分配资源的基本单元

线程是进程的基本执行单元，一个进程的所有任务都是在线程中执行的，进程想要执行任务，必须得有线程，进程至少有一个线程，程序会默认开启一条线程，这条线程被称为主线程或UI线程

2.什么是多线程？

多线程的实现原理：事实上，同一时间内 单核的CPU只能执行一个线程，多线程是CPU快速在多个线程之间进行切换（调度），造成了多个线程同时执行的假象。

如果是多核CPU就真的可以同时处理多个线程了。
目的是为了同步完成多项任务，通过提高系统的资源利用率来提高系统的效率。

3.多线程的优缺点

多线程可以提高系统的资源利用效率，从而提高系统的效率。

但开启多线程需要花费时间和空间，过多的线程反而会降低性能，cpu频繁的在多个线程中调度会消耗大量的CPU资源，把CPU累死。

4.多线程在开发中的使用场景？

在实际开发中应该将一些耗时的操作放在子线程执行，ios默认有一个主线程，用来响应用户的手势和刷新UI，如果在主线程执行耗时操作就会把页面卡死，直到执行完了这个操作才能操作界面。一定要在主线程刷新UI的原因：IOS为了保证效率，多线程是线程不安全的。

5.IOS中实现多线程的几种方案，各自有什么特点？

Pthread 是用C语言实现的，非常底层的多线程实现方案，在开发中很少用到。需要程序员手动管理线程的生命周期。但其具有很强的可移植性。

NSThread面向对象的，需要程序员手动创建线程，但不需要手动销毁。子线程间通信很难。

GCD 充分利用了设备的多核，自动管理线程生命周期。比NSOperation效率更高。

NSOperation 基于GCD封装，更加面向对象，比gcd多了一些功能。

1.GCD简介

GCD 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。

GCD 可用于多核的并行运算；
GCD 会自动利用更多的 CPU 内核（比如双核、四核）；
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）；
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码。

2.GCD任务和队列

GCD中两个核心概念 ： 任务和队列

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行和异步执行。区别在于：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

同步执行（sync）

同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行
只能在当前线程中执行任务，不具备开启新线程的能力。

举例：你打电话给小明的时候，不能同时打给小白。只有等到给小明打完了，才能打给小白（等待任务执行结束），而且只能用当前的电话（不具备开启新线程的能力）

异步执行 （async）

异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
可以在新的线程汇总执行任务，具备开启新线程的能力

举例：你打电话给小明的时候，不用等着和小明通话结束（不用等待任务执行结束），还能同时给小白打电话。而且除了当前电话，你还可以使用其他一个或多个电话（具备开启新线程的能力）

注意：异步执行虽然具有开启新线程的能力，但是并不一定开启新线程。这跟队列类型有关

队列：分为 串行队列 和 并发队列 。两者都符合FIFO的原则。
区别：执行顺序不同，以及开启线程数不同。

串行队列：每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程）

并发队列：可以让多个任务并发执行。（可以开启多个线程，并且同时执行任务）

3.GCD的使用步骤

GCD的使用步骤很简单，只有两步：

1. 创建一个队列（串行队列或并发队列）
2. 将任务追加到任务的等待队列中，然后系统就会根据任务类型执行

3.1 队列的创建方法

可以使用dispatch_queue_create方法创建 队列。 传入两个参数：

• 第一个参数表示队列的唯一标识符，用于DEBUG，可为空。队列的名称推荐使用应用程序ID这种逆序全程域名。
• 第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL表示串行队列，QDISPATCH_QUEUE_CONCURRENT表示并发队列

对于串行队列，GCD默认提供了：主队列（实质就是一个普通的串行队列）

所有放在主队列中的任务，都会放到主线程中执行
可使用dispatch_get_main_queue()方法获得主队列

对于并发队列，GCD默认提供了全局并发队列
可以使用dispatch_get_global_queue方法来获取全局并发队列。需要传入两个参数，第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

3.2任务的创建方法

GCD提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async

 //同步执行任务创建方法
dispatch_sync(queue , ^{
	       //同步执行任务代码
});
	
//异步执行任务创建方法
dispatch_async(queue , ^{
	     //异步执行任务代码
});

四种不同的组合方式

• 同步执行 + 并发队列
• 异步执行 + 并发队列
• 同步执行 + 串行队列
• 异步执行 + 串行队列
• 同步执行 + 主队列
• 异步执行 + 主队列

4.GCD 线程间的通信

在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

 - (void)communication {
    // 获取全局并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 获取主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        // 异步追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        
        // 回到主线程
        dispatch_async(mainQueue, ^{
            // 追加在主线程中执行的任务
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        });
    });
}

6.GCD的其他方法

6.1 GCD栅栏方法： dispatch_barrier_async

为什么要使用？
异步执行两组操作，第二组需得等第一组执行完后才开始执行，这时候就要一个类似于栅栏一样的东西将两组异步执行的操作分割起来。

6.2 GCD 延时执行方法：dispatch_after

我们经常会遇到这样的需求：在指定时间（例如 3 秒）之后执行某个任务。可以用 GCD 的dispatch_after 方法来实现。
需要注意的是：dispatch_after 方法并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中

/**
 * 延时执行方法 dispatch_after
 */
- (void)after {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"asyncMain---begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0 秒后异步追加任务代码到主队列，并开始执行
        NSLog(@"after---%@",[NSThread currentThread]);  // 打印当前线程
    });
}

6.3 GCD 一次性代码（只执行一次）：dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 方法。使用 dispatch_once 方法能保证某段代码在程序运行过程中只被执行 1 次，并且即使在多线程的环境下，dispatch_once 也可以保证线程安全

 /**
 * 一次性代码（只执行一次）dispatch_once
 */
- (void)once {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行 1 次的代码（这里面默认是线程安全的）
    });
}

6.4 GCD 快速迭代方法：dispatch_apply

通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的方法 dispatch_apply。dispatch_apply 按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。但是这样就体现不出快速迭代的意义了。

我们可以利用并发队列进行异步执行。比如说遍历 0~5 这 6 个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以 在多个线程中同时（异步）遍历多个数字。

还有一点，无论是在串行队列，还是并发队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

6.5 GCD 队列组：dispatch_group

有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

• 调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合来实现 dispatch_group_async。
• 调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。

6.5.1 dispatch_group_notify

监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。

6.5.2 dispatch_group_wait

• 暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

6.5.3 dispatch_group_enter、dispatch_group_leave

• dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数 +1
• dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数 -1。
• 当 group 中未执行完毕任务数为0的时候，才会使 dispatch_group_wait 解除阻塞，以及执行追加到
  dispatch_group_notify 中的任务。

6.6 GCD 信号量：dispatch_semaphore

GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。类似于过高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。在 Dispatch Semaphore 中，使用计数来完成这个功能，计数小于 0 时等待，不可通过。计数为 0 或大于 0 时，计数减 1 且不等待，可通过。

dispatch_semaphore_create: 创建一个Semaphore并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加1
dispatch_semaphore_wait: 可以使总信号量减1，信号总量小于0时就会一直等待（阻塞所在线程），否则就可以正常执行。

注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。

Dispatch Semaphore 在实际开发中主要用于：

• 保持线程同步，将异步执行任务转换为同步执行任务
• 保证线程安全，为线程加锁

6.6.1 Dispatch Semaphore 线程同步

我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将异步执行任务转换为同步执行任务。比如：AFNetworking中AFURLSessionManager.m里面的tasksForKeyPath：方法.通过引入信号量的方式，等待异步执行任务结果，获取到tasks，然后再返回该tasks。

 举个例子：
/**
 * semaphore 线程同步
 */
- (void)semaphoreSync {
    
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    
    __block int number = 0;
    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        
        number = 100;
        
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"semaphore---end,number = %zd",number);
}

输出结果：
2019-08-08 15:16:56.781543+0800 YSC-GCD-demo[17988:4325744] currentThread---<NSThread: 0x60000298d380>{number = 1, name = main}
2019-08-08 15:16:56.781698+0800 YSC-GCD-demo[17988:4325744] semaphore---begin
2019-08-08 15:16:58.785232+0800 YSC-GCD-demo[17988:4325867] 1---<NSThread: 0x6000029eba80>{number = 3, name = (null)}
2019-08-08 15:16:58.785432+0800 YSC-GCD-demo[17988:4325744] semaphore---end,number = 100

semaphore—end 是在执行完 number = 100; 之后才打印的。而且输出结果 number 为 100。这是因为 异步执行 不会做任何等待，可以继续执行任务。
执行顺如下：

1. semaphore 初始创建时计数为 0。
2. 异步执行 将 任务 1 追加到队列之后，不做等待，接着执行 dispatch_semaphore_wait 方法，semaphore 减 1，此时 semaphore == -1，当前线程进入等待状态。
3. 然后，异步任务 1 开始执行。任务 1 执行到 dispatch_semaphore_signal 之后，总信号量加 1，此时 semaphore == 0，正在被阻塞的线程（主线程）恢复继续执行。
4. 最后打印 semaphore---end,number = 100。

6.6.2 Dispatch Semaphore 线程安全和线程同步（为线程加锁）

线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。
举个简单例子就是：两个人在一起聊天。两个人不能同时说话，避免听不清(操作冲突)。等一个人说完(一个线程结束操作)，另一个再说(另一个线程再开始操作)。

下面，我们模拟火车票售卖的方式，实现 NSThread 线程安全和解决线程同步问题。

场景：总共有 50 张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。

6.6.2.1 非线程安全（不使用 semaphore）

/**
 * 非线程安全：不使用 semaphore
 * 初始化火车票数量、卖票窗口（非线程安全）、并开始卖票
 */
- (void)initTicketStatusNotSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketNotSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketNotSafe];
    });
}

/**
 * 售卖火车票（非线程安全）
 */
- (void)saleTicketNotSafe {
    while (1) {
        
        if (self.ticketSurplusCount > 0) {  // 如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { // 如果已卖完，关闭售票窗口
            NSLog(@"所有火车票均已售完");
            break;
        }
        
    }
}

6.6.2.2 线程安全（使用 semaphore 加锁）

 /**
 * 线程安全：使用 semaphore 加锁
 * 初始化火车票数量、卖票窗口（线程安全）、并开始卖票
 */
- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"semaphore---begin");
    
    semaphoreLock = dispatch_semaphore_create(1);
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

/**
 * 售卖火车票（线程安全）
 */
- (void)saleTicketSafe {
    while (1) {
        // 相当于加锁
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) {  // 如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { // 如果已卖完，关闭售票窗口
            NSLog(@"所有火车票均已售完");
            
            // 相当于解锁
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }
        
        // 相当于解锁
        dispatch_semaphore_signal(semaphoreLock);
    }
}