iOS并发编程对比总结,NSThread,NSOperation,GCD - iOS

1. 多线程概念

进程

• 正在进行中的程序被称为进程，负责程序运行的内存分配
• 每一个进程都有自己独立的虚拟内存空间

线程

• 线程是进程中一个独立的执行路径(控制单元)
• 一个进程中至少包含一条线程，即主线程
• 可以将耗时的执行路径(如：网络请求)放在其他线程中执行

创建线程的目的就是为了开启一条新的执行路径，运行指定的代码，与主线程中的代码实现同时运行

1.1 多任务系统调度示意图

说明：每个应用程序由操作系统分配的短暂的时间片(Timeslice)轮流使用CPU，由于CPU对每个时间片的处理速度非常快，因此，用户看来好像这些任务在同时执行的

并发：指两个或多个任务在同一时间间隔内发生，但是，在任意一个时刻点上，CPU只会处理一个任务

1.2 优势、弊端以及误区

优势

• 充分发挥多核处理器优势，将不同线程任务分配给不同的处理器，真正进入“并行运算”状态
• 将耗时的任务分配到其他线程执行，由主线程负责统一更新界面会使应用程序更加流畅，用户体验更好
• 当硬件处理器的数量增加，程序会运行更快，而程序无需做任何调整

弊端

• 新建线程会消耗内存空间和CPU时间，线程太多会降低系统的运行性能

误区

• 多线程技术是为了并发执行多项任务，不会提高单个算法本身的执行效率

1.3 iOS的三种多线程技术

NSThread

• 使用NSThread对象建立一个线程非常方便
• 但是！要使用NSThread管理多个线程非常困难，不推荐使用
• 技巧！使用[NSThread currentThread]跟踪任务所在线程，适用于这三种技术

NSOperation/NSOperationQueue

• 是使用GCD实现的一套Objective-C的API
• 是面向对象的线程技术
• 提供了一些在GCD中不容易实现的特性，如：限制最大并发数量、操作之间的依赖关系

GCD —— Grand Central Dispatch

• 是基于C语言的底层API
• 用Block定义任务，使用起来非常灵活便捷
• 提供了更多的控制能力以及操作队列中所不能使用的底层函数

提示：iOS的开发者，需要了解三种多线程技术的基本使用，因为在实际开发中会根据实际情况选择不同的多线程技术

2 GCD - Grand Central Dispatch

2.1 GCD基本思想

GCD的基本思想是就将操作s放在队列s中去执行

• 操作使用Blocks定义
• 队列负责调度任务执行所在的线程以及具体的执行时间
• 队列的特点是先进先出(FIFO)的，新添加至对列的操作都会排在队尾

提示

• GCD的函数都是以dispatch(分派、调度)开头的

队列dispatch_queue_t

• 串行队列，队列中的任务只会顺序执行
• 并行队列，队列中的任务通常会并发执行

操作

• dispatch_async 异步操作，会并发执行，无法确定任务的执行顺序
• dispatch_sync 同步操作，会依次顺序执行，能够决定任务的执行顺序

注：

• 队列不是线程？也不表示对应的CPU
• 队列就是负责调度的!谁空闲，就把任务给谁！
• 多线程技术的目的，就是为了在一个CPU上实现快速切换！

2.2 串行队列

#pragma mark - 串行（一个接一个，排队跑步，保持队形）队列
- (void)gcdDemo1
{
// 将操作放在队列中
// 在C语言函数中，定义类型，绝大多数的结尾是_t或者ref
// 使用串行队列，的异步任务非常非常非常有用！新建子线程是有开销的，不能无休止新建线程
// 即可以保证效率（新建一个子线程），用能够实现并发
// 应用案例：
// 1> 从网络上上下载图片
// 2> 滤镜（高光，红眼...）

dispatch_queue_t q = dispatch_queue_create("com.yoferzhang.gcddemo", DISPATCH_QUEUE_SERIAL);

// 非ARC开发时，千万别忘记release
// dispatch_release(q);

// 串行行队列的同步任务，同样会在主线程上运行
// 提示：在开发中极少用d
// 面试中有可能会问！
for (int i = 0; i < 10; ++i) {
// 同步任务顺序执行
dispatch_sync(q, ^{
NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }

for (int i = 0; i < 10; ++i) {
// 异步任务，并发执行，但是如果在串行队列中，仍然会依次顺序执行
dispatch_async(q, ^{
// [NSThread currentThread] 可以在开发中，跟踪当前线程
// num = 1，表示主线程
// num = 2，表示第2个子线程。。。
NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
}

2.3 并行队列

#pragma mark - 并行（并排跑，类似于赛跑）
- (void)gcdDemo2
{
// 特点：没有队形，执行顺序程序员不能控制！
// 应用场景：并发执行任务，没有先后顺序关系
// 并行队列容易出错！并行队列不能控制新建线程的数量！
dispatch_queue_t q = dispatch_queue_create("com.yoferzhang.gcd2", DISPATCH_QUEUE_CONCURRENT);

// for (int i = 0; i < 10; ++i) {
// // 异步任务
// dispatch_async(q, ^{
// // [NSThread currentThread] 可以在开发中，跟踪当前线程
// // num = 1，表示主线程
// // num = 2，表示第2个子线程。。。
// NSLog(@"%@ %d", [NSThread currentThread], i);
// });
// }

for (int i = 0; i < 10; ++i) {
// 同步任务顺序执行
dispatch_sync(q, ^{
NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
}

2.4 全局队列

#pragma mark - 全局队列（苹果为了方便多线程的设计，提供一个全局队列，供所有的APP共同使用）
- (void)gcdDemo3
{
// 全局队列与并行队列的区别
// 1> 不需要创建，直接GET就能用
// 2> 两个队列的执行效果相同
// 3> 全局队列没有名称，调试时，无法确认准确队列

// 记住：在开发中永远用DISPATCH_QUEUE_PRIORITY_DEFAULT
// 多线程的优先级反转！低优先级的线程阻塞了高优先级的线程！
dispatch_queue_t q =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

for (int i = 0; i < 10; ++i) {
// 同步任务顺序执行
dispatch_sync(q, ^{
NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }

for (int i = 0; i < 10; ++i) {
// 异步任务，并发执行，但是如果在穿行队列中，仍然会依次顺序执行
dispatch_async(q, ^{
// [NSThread currentThread] 可以在开发中，跟踪当前线程
// num = 1，表示主线程
// num = 2，表示第2个子线程。。。
NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
}

2.5 主队列

#pragma mark - 主(线程)队列，保证操作在主线程上执行
- (void)gcdDemo4
{
// 每一个应用程序都只有一个主线程
// 为什么需要在主线程上工作呢？
// 在iOS开发中，所有UI的更新工作，都必须在主线程上执行！
dispatch_queue_t q = dispatch_get_main_queue();

// 主线程是由工作的，而且除非将程序杀掉，否则主线程的工作永远不会结束！
// 阻塞了！！！
dispatch_sync(q, ^{
NSLog(@"come here baby!");
    });

// 异步任务，在主线程上运行，同时是保持队形的
for (int i = 0; i < 10; ++i) {
dispatch_async(q, ^{
NSLog(@"%@ - %d", [NSThread currentThread], i);
        });
    }
}

2.6 不同队列中嵌套dispatch_sync的结果

// 全局队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 并行队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_queue_create("com.yoferzhang.gcddemo", DISPATCH_QUEUE_CONCURRENT);
// 串行队列，会死锁，但是会执行嵌套同步操作之前的代码
dispatch_queue_t q = dispatch_queue_create("com.yoferzhang.gcddemo", DISPATCH_QUEUE_SERIAL);
// 直接死锁
dispatch_queue_t q = dispatch_get_main_queue();

dispatch_sync(q, ^{
NSLog(@"同步任务 %@", [NSThread currentThread]);
dispatch_sync(q, ^{
NSLog(@"同步任务 %@", [NSThread currentThread]);
    });
});

2.7 dispatch_sync的应用场景

• 阻塞并行队列的执行，要求某一操作执行后再进行后续操作，如用户登录
• 确保块代码之外的局部变量确实被修改

dispatch_queue_t q = dispatch_queue_create("com.yoferzhang.gcddemo", DISPATCH_QUEUE_CONCURRENT);
__block BOOL logon = NO;
dispatch_sync(q, ^{
NSLog(@"模拟耗时操作 %@", [NSThread currentThread]);
      [NSThread sleepForTimeInterval:2.0f];
NSLog(@"模拟耗时完成 %@", [NSThread currentThread]); 
    logon = YES;
});

dispatch_async(q, ^{
NSLog(@"登录完成的处理 %@", [NSThread currentThread]);
});

[NSThread sleepForTimeInterval:2.0f];

通常在多线程调试中用于模拟耗时操作
在发布的应用程序中，不要使用此方法！

2.8 GCD——大*调度

• 串行队列，同步任务，不需要新建线程

• 串行队列，异步任务，需要一个子线程，线程的创建和回收不需要程序员参与！“是最安全的一个选择”串行队列只能创建！

• 并行队列，同步任务，不需要创建线程

• 并行队列，异步任务，有多少个任务，就开N个线程执行，

无论什么队列和什么任务，线程的创建和回收不需要程序员参与。
线程的创建回收工作是由队列负责的

“并发”编程，为了让程序员从负责的线程控制中解脱出来！只需要面对队列和任务！

2.9 GCD阶段性小结

GCD

• 通过GCD，开发者不用再直接跟线程打交道，只需要向队列中添加代码块即可
• GCD在后端管理着一个线程池，GCD不仅决定着代码块将在哪个线程被执行，它还根据可用的系统资源对这些线程进行管理。从而让开发者从线程管理的工作中解放出来，通过集中的管理线程，缓解大量线程被创建的问题
• 使用GCD，开发者可以将工作考虑为一个队列，而不是一堆线程，这种并行的抽象模型更容易掌握和使用

GCD的队列

• GCD公开有5个不同的队列：运行在主线程中的主队列，3 个不同优先级的后台队列，以及一个优先级更低的后台队列（用于 I/O）
• 自定义队列：串行和并行队列。自定义队列非常强大，建议在开发中使用。在自定义队列中被调度的所有Block最终都将被放入到系统的全局队列中和线程池中
• 提示：不建议使用不同优先级的队列，因为如果设计不当，可能会出现优先级反转，即低优先级的操作阻塞高优先级的操作

2.10 GCD队列示意图

3 NSOperation

3.1 NSOperation & NSOperationQueue

简介

• NSOperationQueue(操作队列)是由GCD提供的队列模型的Cocoa抽象，是一套Objective-C的API
• GCD提供了更加底层的控制，而操作队列则在GCD之上实现了一些方便的功能，这些功能对于开发者而言通常是最好最安全的选择
  队列及操作

NSOperationQueue有两种不同类型的队列：主队列和自定义队列

主队列运行在主线程上

自定义队列在后台执行

队列处理的任务是NSOperation的子类

• NSInvocationOperation
• NSBlockOperation

3.2 NSOperation的基本使用步骤

基本使用步骤

• 定义操作队列
• 定义操作
• 将操作添加到队列

提示：一旦将操作添加到队列，操作就会立即被调度执行

#pragma mark NSBlockOperation
- (void)demoOp1
{
// NSBlockOperation *block = [NSBlockOperation blockOperationWithBlock:^{
// NSLog(@"%@", [NSThread currentThread]);
// }];
// 
// 所有的自定义队列，都是在子线程中运行
// [self.myQueue addOperation:block];

// 新建线程是有开销的
// 在设定同时并发的最大线程数时，如果前一个线程工作完成，但是还没有销毁，会新建线程
// 应用场景：网络开发中，下载工作！（线程开销：CPU,MEM）电量！
// 如果是3G，开3个子线程
// 如果是WIFI，开6个子线程

for (int i = 0; i < 10; ++i) {
        [self.myQueue addOperationWithBlock:^{
NSLog(@"%@ %d", [NSThread currentThread], i);
        }];
    }

// 在主线程中执行
// [[NSOperationQueue mainQueue] addOperationWithBlock:^{
// NSLog(@"%@", [NSThread currentThread]);
// }];
}

3.3 NSInvocationOperation(调度操作)

定义队列

self.myQueue = [[NSOperationQueue alloc] init];

操作调用的方法

- (void)operationAction:(id)obj
{
NSLog(@"%@ - obj : %@", [NSThread currentThread], obj);
}

定义操作并添加到队列

NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationAction:) object:@(i)];
[self.myQueue addOperation:op];

小结：需要准备一个被调度的方法，并且能够接收一个参数

#pragma mark NSInvocationOP
- (void)demoOp2
{
// 需要定义一个方法，能够接收一个参数
// 是用起来不够灵活
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(demoOp:) object:@"hello op"];

// [self.myQueue addOperation:op];

    [[NSOperationQueue mainQueue] addOperation:op];
}

3.4 设置操作的依赖关系

提示：利用addDependency可以指定操作之间的彼此依赖关系(执行先后顺序)

注意：不要出现循环依赖！

#pragma mark - NSOperation方法
#pragma mark 设置任务的执行顺序
- (void)demoOp3
{
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"下载图片 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"修饰图片 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"保存图片 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"更新UI %@", [NSThread currentThread]);
    }];

// 设定执行顺序, Dependency依赖，可能会开多个，但不会太多
// 依赖关系是可以跨队列的！
    [op2 addDependency:op1];
    [op3 addDependency:op2];
    [op4 addDependency:op3];
// GCD是串行队列，异步任务，只会开一个线程

    [self.myQueue addOperation:op1];
    [self.myQueue addOperation:op2];
    [self.myQueue addOperation:op3];
// 所有UI的更新需要在主线程上进行
    [[NSOperationQueue mainQueue] addOperation:op4];
}

3.5 设置同时并发的线程数量

[self.myQueue setMaxConcurrentOperationCount:2];
// 设置同时并发的线程数量能够有效地降低CPU和内存的开销
// 这一功能用GCD不容易实现


for (int i = 0; i < 10; ++i) {
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        [self operationAction:@(i)];
    }];

    [self.myQueue addOperation:op];
}

3.6 NSOperation小结

从本质上来看，操作队列的性能会比GCD略低，不过，大多数情况下这点负面影响可以忽略不计，操作队列是并发编程的首选工具

AFN，底层用GCD开发，开发的接口是NSOperation的。

4 Run Loop

• Run Loop提供了一种异步执行代码的机制，不能并行执行任务
• 在主队列中，Main Run Loop直接配合任务的执行，负责处理UI事件、计时器，以及其它内核相关事件
• Run Loop的主要目的是保证程序执行的线程不会被系统终止

Run Loop的工作特点

• 当有事件发生时，Run Loop会根据具体的事件类型通知应用程序做出响应
• 当没有事件发生时，Run Loop会进入休眠状态，从而达到省电的目的
• 当事件再次发生时，Run Loop会被重新唤醒，处理事件
• 主线程和其他线程中的Run Loop

iOS程序的主线程默认已经配置好了Run Loop

其他线程默认情况下没有设置Run Loop

一般在开发中很少会主动创建RunLoop，而通常会把事件添加到RunLoop中

4.1 RunLoop示意图

4.2 UIApplication中的Run Loop

4.3 多线程中的循环引用

如果self对象持有操作对象的引用，同时操作对象当中又直接访问了self时，才会造成循环引用

单纯在操作对象中使用self不会造成循环引用

注意：此时不能使用(weakSelf)

5 资源共享

5.1 多线程中的资源共享

并发编程中许多问题的根源就是在多线程中访问共享资源。资源可以是一个属性、一个对象、网络设备或者一个文件等

在多线程中任何一个共享的资源都可能是一个潜在的冲突点，必须精心设计以防止这种冲突的发生

5.2 资源共享示例

5.3 互斥锁(@synchronized)

5.4 共享资源小结

• 为了保证性能，atomic仅针对属性的setter方法做了保护
• 而争抢共享资源时，如果涉及到属性的getter方法，可以使用互斥锁@synchronized可以保证属性在多个线程之间的读写都是安全的
• 无论是atomic还是@synchronized，使用的代价都是高昂的

建议：多线程是并发执行多个任务提高效率的，如果可能，应该在线程中避免争抢共享资源

正是出于性能的考虑，UIKit中的绝大多数的类都不是线程安全的，因此，苹果公司要求：更新UI相关的操作，应该在主线程中执行

取舍！

6单例

• 单例模式是一种常用的软件设计模式
• 通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源
• 如果希望系统中某个类的对象只能存在一个，单例模式是最好的解决方案

iOS中最常见的单例就是UIApplication

应用场景：

• 音频播放，背景音乐！
• 硬件资源：加速器、[UIScreen mainScreen]

sharedXX, mainXXX

6.1 单例的实现步骤

重写allocWithZone方法

allocWithZone方法是对象分配内存空间时，最终会调用的方法，重写该方法，保证只会分配一个内存空间

建立sharedXXX类方法，便于其他类访问

#import <Foundation/Foundation.h>

@interface DemoObj : NSObject

// 共享实例，便于其他类访问
+ (instancetype)sharedDemoObj;

@end

#import "DemoObj.h"

@implementation DemoObj

static DemoObj *instance;

/**
 1. 重写allocWithZone，用dispatch_once实例化一个静态变量
 2. 写一个+sharedXXX方便其他类调用
 */

// 在iOS中，所有对象的内存空间的分配，最终都会调用allocWithZone方法
// 如果要做单例，需要重写此方法
// GCD提供了一个方法，专门用来创建单例的
+ (id)allocWithZone:(struct _NSZone *)zone
{
static DemoObj *instance;

// dispatch_once是线程安全的，onceToken默认为0
static dispatch_once_t onceToken;
// dispatch_once宏可以保证块代码中的指令只被执行一次
    dispatch_once(&onceToken, ^{
// 在多线程环境下，永远只会被执行一次，instance只会被实例化一次
        instance = [super allocWithZone:zone];
    });

return instance;
}

+ (instancetype)sharedDemoObj
{
// 如果有两个线程同时实例化，很有可能创建出两个实例来
// if (!instance) {
// // thread 1 0x0000A
// // thread 2 0x0000B
// instance = [[self alloc] init];
// }
// // 第一个线程返回的指针已经被修改！
// return instance;
return [[self alloc] init];
}

@end

6.2 单例小结

优点

• 可以阻止其他对象实例化单例对象的副本，从而确保所有对象都访问唯一实例

缺点

• 单例对象一旦建立，对象指针是保存在静态区的，单例对象在堆中分配的内存空间，会在应用程序终止后才会被释放

提示

• 只有确实需要唯一使用的对象才需要考虑单例模式，不要滥用单例

7 NSThread

7.1 NSObject的多线程方法

开启后台执行任务的方法

- (void)performSelectorInBackground:(SEL)aSelector withObject:(id)arg

在后台线程中通知主线程执行任务的方法

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait

获取线程信息

[NSThread currentThread]

线程休眠

[NSThread sleepForTimeInterval:2.0f];

特点

• 使用简单，量级轻
• 不能控制线程的数量以及执行顺序

7.2 NSObject的多线程方法注意事项

NSObject的多线程方法使用的是NSThread的多线程技术

而NSThread的多线程技术不会自动使用@autoreleasepool

在使用NSObject或NSThread的多线程技术时，如果涉及到对象分配，需要手动添加@autoreleasepool

#import "ViewController.h"
/**
 需求分析

 1. UIImageView显示图片
 2. UIImage模拟从网络上下载
 3. NSString记录图片路径

 小结

 方法，看起来很简单，

 1> 不能够自动回收线程，如果并发数量多，会建立大量的子线程！
 2> 使用NSThread的线程，不会自动添加autoreleasepool

 意味着，如果在后台线程方法中，

 @autoreleasepool {} 自动释放池

 主线程中是有自动释放池的，使用GCD和NSOperation也会自动添加自动释放池

 NSThread和NSObject不会，如果在后台线程中创建了autorelease的对象，需要使用自动释放池，否则会出现内存泄漏！

 工作原理：

 1. 当自动释放池被销毁或者“耗尽”时，对池中的所有对象发送release消息，清空自动释放池
 2. 所有autorelease的对象，在出了作用域之后，会自动添加到【最近一次创建的自动释放池中】自动释放池中

 在ARC中，编译器在编译过程中，会自动根据代码结构，添加retain和release。
 */
@interface ViewController ()

@property (nonatomic, strong) UIImageView *imageView;
@property (nonatomic, strong) UIImage *image;
@property (nonatomic, strong) NSString *imagePath;

@end

@implementation ViewController

// 0. 模拟使用图像路径加载图片
- (void)setImagePath:(NSString *)imagePath
{
    @autoreleasepool {
NSLog(@"%@", [NSThread currentThread]);

// 1> 模拟下载，延时
        [NSThread sleepForTimeInterval:1.0];

// 2> 设置图像，苹果底层允许使用performSelectorInBackground方法
// 在后台线程更新UI，强烈不建议大家这么做！
// YES会阻塞住线程，直到调用方法完成
// NO不会阻塞线程，会继续执行
        [self performSelectorOnMainThread:@selector(setImage:) withObject:[UIImage imageNamed:imagePath] waitUntilDone:NO];
    }
}

// 1. 图像
- (void)setImage:(UIImage *)image
{

self.imageView.image = image;

// [NSThread sleepForTimeInterval:1.0];
// 根据图片自动调整大小
    [self.imageView sizeToFit];
}

// 2. 创建imageView
- (UIImageView *)imageView
{
if (!_imageView) {
        _imageView = [[UIImageView alloc] init];
    }

return _imageView;
}

- (void)viewDidLoad
{
    [super viewDidLoad];

    [self.view addSubview:self.imageView];

// 在后台线程执行这段代码即可
for (int i = 0; i < 50; ++i) {
        [self performSelectorInBackground:@selector(setImagePath:) withObject:@"头像1.png"];
    }
// [self setImagePath: @"头像1.png"];
}

- (void)demo
{
// 提问：代码存在什么问题？如果循环次数非常大，会出现什么问题？应该如何修改？

// 解决办法1：如果i比较大，可以
// 解决方法2：如果非常大，一次循环都会造成自动释放池被填满
for (int i = 0; i < 10000000; ++i) {
        @autoreleasepool {
// *
NSString *str = @"Hello World!";
// new *
            str = [str uppercaseString];
// new *
            str = [NSString stringWithFormat:@"%@ %d", str, i];

NSLog(@"%@", str);
        }
    }
}

@end

参考文章：
Threading Programming Guide
Concurrency Programming Guide

新博客文章地址：iOS并发编程对比总结,NSThread,NSOperation,GCD