iOS 多线程介绍

多线程概念

进程
正在进行中的程序被称为进程，负责程序运行的内存分配
每一个进程都有自己独立的虚拟内存空间
线程
线程是进程中一个独立的执行路径(控制单元)
一个进程中至少包含一条线程，即主线程
可以将耗时的执行路径(如：网络请求)放在其他线程中执行
创建线程的目的就是为了开启一条新的执行路径，运行指定的代码，与主线程中的代码实现同时运行

主线程 1M；子线程 512K

不能杀掉一个线程！但是可以暂停、休眠

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

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

优势
充分发挥多核处理器优势，将不同线程任务分配给不同的处理器，真正进入“并行运算”状态
将耗时的任务分配到其他线程执行，由主线程负责统一更新界面会使应用程序更加流畅，用户体验更好
当硬件处理器的数量增加，程序会运行更快，而程序无需做任何调整
弊端
新建线程会消耗内存空间和CPU时间，线程太多会降低系统的运行性能
误区
多线程技术是为了并发执行多项任务，不会提高单个算法本身的执行效率

iOS的三种多线程技术

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

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

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

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

GCD基本思想

GCD的基本思想是就将操作s放在队列s中去执行
操作使用Blocks定义
队列负责调度任务执行所在的线程以及具体的执行时间
队列的特点是先进先出(FIFO)的，新添加至对列的操作都会排在队尾

提示
GCD的函数都是以dispatch(分派、调度)开头的
队列
dispatch_queue_t
串行队列，队列中的任务只会顺序执行
并行队列，队列中的任务通常会并发执行
操作
dispatch_async 异步操作，会并发执行，无法确定任务的执行顺序
dispatch_sync 同步操作，会依次顺序执行，能够决定任务的执行顺序

#import "MJViewController.h"@interface MJViewController ()@end@implementation MJViewController- (void)viewDidLoad{    [super viewDidLoad];        NSLog(@"%@", [NSThread currentThread]);        //[self gcdSyncDemo];    [self gcdDemo4];    }- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{    NSLog(@"Touch me");}#pragma mark - GCD方法#pragma mark 同步任务的阻塞- (void)gcdSyncDemo{    dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", DISPATCH_QUEUE_SERIAL);        // 任务嵌套    dispatch_sync(q, ^{        NSLog(@"sync %@", [NSThread currentThread]);                // 耗时的任务，同步里面包含同步，会造成阻塞//        dispatch_sync(q, ^{        // 永远也不会执行到//            NSLog(@"async %@", [NSThread currentThread]);//        });    });}#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);        });    }}#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);        });    }}#pragma mark - 串行（一个接一个，排队跑步，保持队形）队列- (void)gcdDemo1{    // 将操作放在队列中    // 在C语言函数中，定义类型，绝大多数的结尾是_t或者ref    // 使用串行队列，的异步任务非常非常非常有用！新建子线程是有开销的，不能无休止新建线程    // 即可以保证效率（新建一个子线程），用能够实现并发    // 应用案例：    // 1> 从网络上上下载图片    // 2> 滤镜（高光，红眼...）        dispatch_queue_t q = dispatch_queue_create("cn.itcast.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);        });    }}#pragma mark - 并行（并排跑，类似于赛跑）- (void)gcdDemo2{    // 特点：没有队形，执行顺序程序员不能控制！    // 应用场景：并发执行任务，没有先后顺序关系    // 并行队列容易出错！并行队列不能控制新建线程的数量！    dispatch_queue_t q = dispatch_queue_create("cn.itcast.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);        });    }}

GCD阶段性小结

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

并行队列，同步任务，不需要创建线程
并行队列，异步任务，有多少个任务，就开N个线程执行，

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

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

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

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

NSOperation & NSOperationQueue

简介
NSOperationQueue(操作队列)是由GCD提供的队列模型的Cocoa抽象，是一套Objective-C的API
GCD提供了更加底层的控制，而操作队列则在GCD之上实现了一些方便的功能，这些功能对于开发者而言通常是最好最安全的选择
队列及操作
NSOperationQueue有两种不同类型的队列：主队列和自定义队列
主队列运行在主线程上
自定义队列在后台执行
队列处理的任务是NSOperation的子类
NSInvocationOperation
NSBlockOperation

#import "MJViewController.h"@interface MJViewController ()@property (nonatomic, strong) NSOperationQueue *myQueue;@end@implementation MJViewController- (void)viewDidLoad{    [super viewDidLoad];        self.myQueue = [[NSOperationQueue alloc] init];        [self demoOp1];}- (void)demoOp:(id)obj{    NSLog(@"%@ - %@", [NSThread currentThread], obj);}#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];}#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];}#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]);//    }];}

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

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

多线程中的资源共享

并发编程中许多问题的根源就是在多线程中访问共享资源。资源可以是一个属性、一个对象、网络设备或者一个文件等
在多线程中任何一个共享的资源都可能是一个潜在的冲突点，必须精心设计以防止这种冲突的发生

资源强夺演练(卖票)

系统预设
共有N张票可以销售
售票工作由多个线程并发进行
没有可出售票据时，线程工作停止
子线程的执行效率不同，模拟售票人员效率不同
使用一个多行文本框公告售票进度（主线程更新UI）
线程工作安排
主线程：负责更新UI
多个子线程：模拟多名卖票员

共享资源小结

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

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

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

取舍！

单例

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

iOS中最常见的单例就是UIApplication

应用场景：
音频播放，背景音乐！
硬件资源：加速器、[UIScreen mainScreen]
sharedXX, mainXXX

单例的实现步骤

重写allocWithZone方法
allocWithZone方法是对象分配内存空间时，最终会调用的方法，重写该方法，保证只会分配一个内存空间
建立sharedXXX类方法，便于其他类访问

+ (id)allocWithZone:(struct _NSZone *)zone{    static Ticket *instance;    static dispatch_once_t onceToken;    dispatch_once(&onceToken, ^{        instance = [super allocWithZone:zone];    });       return instance;}

dispatch_once是线程安全的
能够做到在多线程的环境下Block中的代码只会被执行一次

单例小结

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

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

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