iOS开发小记-多线程篇

这两个月App被拒审，应对苹果那边花了不少心思，也花了大量时间，也对苹果审核团队有了全新高度的认识，后续计划写一下这段时间是如何与苹果斗智斗勇～html

线程和进程

几乎全部的操做系统都支持同时运行多个任务，一个任务一般就是一个程序，每一个运行程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每一个顺序执行流就是一个线程。ios

进程（Process）

当一个程序进入内存运行后，即变成一个进程。进程是处于运行过程当中的程序，而且具备必定的独立功能，进程是系统进行资源分配和调度的一个独立单位。通常而言，进程有以下特征：git

独立性：有本身独立的资源，且拥有本身私有的地址空间。在没有通过进程自己的容许下，其余进程是不能直接访问其进程的地址空间的。
动态性：程序只是静态的指令集合，而进程是一个正在系统中活动的指令集合。进程有时间的概念，具备本身的生命周期和各类状态。
并发性：多个进程能够在单个处理器上并发执行，互相不会影响。

线程（Thread）

线程也被称做轻量级进程，线程是进程的执行单元。就像进程在系统中同样，线程在进程中也是独立、并发的执行流。一个进程能够拥有多个线程，一个线程必须有一个父进程，但再也不拥有系统资源，而是和父进程下的其余线程一块儿共享父进程的所有资源。多线程因为共享父进程的资源，因此编程更加方便；可是也须要当心线程不会影响到父进程中的其余线程。线程是独立运行的，它并不知道其余线程的存在。线程的执行是抢占式的，也就是说，当前运行的线程在任什么时候候均可能被挂起，以便另一个线程能够运行。程序员

多线程优势

进程间不可共享内存，但线程之间共享内存十分容易。
系统建立进程要为其从新分配系统资源，但建立线程代价小得多，所以效率更高。

为何要用多线程编程

为了提升资源利用率来提高系统总体效率，实际每每是将耗时操做放在后台执行，避免阻塞主线程，在iOS中UI绘制和用户响应都是在主线程。github

多线程线程池的大小

Java中是cpu核数*2-1，iOS没有查到确切资料。编程

NSThread

经常使用API安全

- (void)viewDidLoad {
    [super viewDidLoad];
    
    //打印当前线程
    NSLog(@"开始：%@ 优先级：%d", [NSThread currentThread], [NSThread currentThread].qualityOfService);
    
    //1.建立NSTread对象，必须调用start方法开始，而且只能传一个参数object
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@"test"];
    //    NSThread *thread = [[NSThread alloc] initWithBlock:^{}];
    thread.name = @"testThread";
    thread.qualityOfService = NSQualityOfServiceUserInteractive;
    [thread start];
    
    //2.直接建立并启动线程
    //    [NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"test"];
    //    [NSThread detachNewThreadWithBlock:^{}];
    
    //3.隐式直接建立
//    [NSThread performSelectorInBackground:@selector(run:) withObject:nil];
    
    //    NSLog(@"结束：%@", [NSThread currentThread]);
}

- (void)run:(NSObject *)object {
    //阻塞休眠
    //    [NSThread sleepForTimeInterval:5];
    //停止当前线程
    //    [NSThread exit];
    NSLog(@"子线程运行：%@ %@ 优先级：%d", [NSThread currentThread], object, [NSThread currentThread].qualityOfService);
}
复制代码

线程的状态

线程被启动后，并非直接进入执行状态，也不是一直处于执行状态，因为多线程并发，线程会反复在运行、就绪间切换。建立一个线程后，处于新建状态，系统为其分配内存，初始化成员变量；调用- (void)start;方法后，该线程处于就绪状态，系统为其建立方法调用栈和程序计数器，此时并无运行，什么时候运行取决于系统调度。 bash

终止子线程

NSTread并无提供方法来终止子线程，只有+ (void)exit;来终止当前线程，咱们不能直接使用该方法，防止误操做终止了主线程，正确应该是调用子线程的- (void)cancel;方法用来标记子线程状态，而后在子线程的执行方法体内对isCancelled作判断，而后在调用+ (void)exit;来终止当前运行的子线程。markdown

线程优先级

每一个线程都有必定的优先级，优先级越高得到执行机会越多。目前经过qualityOfService属性来设置，原来的threadPriority因为语义不够清晰，已经被废弃了。多线程

NSQualityOfServiceUserInteractive：最高优先级，主要用于提供交互UI的操做，好比处理点击事件，绘制图像到屏幕上
NSQualityOfServiceUserInitiated：次高优先级，主要用于执行须要当即返回的任务
NSQualityOfServiceDefault：默认优先级，当没有设置优先级的时候，线程默认优先级
NSQualityOfServiceUtility：普通优先级，主要用于不须要当即返回的任务
NSQualityOfServiceBackground：后台优先级，用于彻底不紧急的任务
复制代码

缺点

使用NSThread进行多线程编程较复杂，须要本身控制多线程的同步、并发，还须要本身控制线程的终止销毁，稍不留神就容易出现错误，对开发者要求较高，通常较少使用。

NSOperation

iOS还提供了NSOperation与NSOperationQueue来实现多线程，是基于 GCD 更高一层的封装，彻底面向对象。可是比 GCD 更简单易用、代码可读性也更高。

NSOperationQueue：负责管理系统提交的多个NSOperation ，底层维护了一个线程池。不一样于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操做，首先进入准备就绪的状态（就绪状态取决于操做之间的依赖关系），而后进入就绪状态的操做的开始执行顺序（非结束执行顺序）由操做之间相对的优先级决定（优先级是操做对象自身的属性）。

NSOperation：表明一个多线程任务。

为何要使用 NSOperation、NSOperationQueue？

可添加完成的代码块，在操做完成后执行。
添加操做之间的依赖关系，方便的控制执行顺序。
设定操做执行的优先级。
能够很方便的取消一个操做的执行。
使用 KVO 观察对操做执行状态的更改：isExecuteing、isFinished、isCancelled。

经常使用API

NSOperationQueue *queue;
    //获取执行当前NSOperation的NSOperationQueue队列
    //    queue = [NSOperationQueue currentQueue];
    //获取主线程的NSOperationQueue队列
    //    queue = [NSOperationQueue mainQueue];
    //自定义队列
    queue = [[NSOperationQueue alloc] init];
    //队列名
    queue.name = @"testOperationQueue";
    //最大并发操做数（系统有限制，即便设置很大，也会自动调整）
    queue.maxConcurrentOperationCount = 10;
    //设置优先级
    queue.qualityOfService = NSQualityOfServiceDefault;
    
    //自定义NSOperation，若是SEL和Block为空，系统不会加入到指定队列
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"blockOperation");
    }];
    //添加依赖关系，invocationOperation执行完后才执行blockOperation
    [blockOperation addDependency:invocationOperation];
    //添加到队列中
    //    [queue addOperation:invocationOperation];
    [queue addOperations:@[invocationOperation, blockOperation] waitUntilFinished:NO];
    //直接添加代码块任务
    [queue addOperationWithBlock:^{
        
    }];
    
    //打印全部的NSOperation
    for(int i=0; i<queue.operationCount; i++) {
        NSLog(@"队列%@的第%d个NSOperation:%@", queue.name, i, queue.operations[i]);
    }
    
    //终止全部NSOperation
    //    [queue cancelAllOperations];
    //执行完全部NSOperation才能解除阻塞当前线程
    //    [queue waitUntilAllOperationsAreFinished];
复制代码

GCD（Grand Central Dispatch）

基本概念

队列：队列负责开发者提交的任务，不过不一样任务的执行时间不同，先处理的任务不必定先完成。队列便可是串行的，也但是并行的，队列底层会维持一个线程池来处理任务，串行队列只须要维护一个线程便可，并行队列则须要维护多个线程。
任务：用户提交给队列的工做单元，这些任务将会提交给队列底层维护的线程池。
异步：能够在新的线程中执行任务，但不必定会开辟新的线程。dispatch函数会当即返回, 而后Block在后台异步执行。
同步：在当前线程执行任务，不会开辟新的线程。必须等到Block函数执行完毕后，dispatch函数才会返回。

注：队列的串行和并行决定了任务以何种方式执行，执行的异步和同步决定是否须要开辟新线程处理任务。

特色

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

经常使用API

/** 获取队列 */
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);//获取指定优先级的全局并发队列（flag填0便可，仅预留的参数，使用其余值可能会返回null）
    dispatch_queue_t queue1 = dispatch_queue_create("testQueue1", DISPATCH_QUEUE_CONCURRENT);//建立自定义并行队列
    dispatch_queue_t queue2 = dispatch_get_main_queue();//获取系统主线程关联的串行队列
    dispatch_queue_t queue3 = dispatch_queue_create("testQueue3", DISPATCH_QUEUE_SERIAL);//建立自定义串行队列
    
    /** 提交任务 */
    dispatch_async(queue, ^{
        
    });//异步提交代码块到并发队列
    
    dispatch_sync(queue1, ^{
        
    });//同步提交代码块到自定义并发队列
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5*NSEC_PER_SEC)), queue2, ^{
        
    });//异步提交代码块到串行队列，线程池将在指定时间执行代码块（实际是5秒后加入到队列中，实际并不必定会立马执行，通常精度要求下是没问题的）
    
    dispatch_apply(5, queue3, ^(size_t time) {
        
    });//异步提交代码到自定义串行队列，同步函数，不管是在串行仍是并行队列中执行，都要执行完才返回，因此要防止线程阻塞和死锁，time表示当前是第几回（若是提交给并发队列，会启动五个线程来执行）
    
    static dispatch_once_t onceToken; //实际是个long类型变量，用于判断该代码块是否被执行过
    dispatch_once(&onceToken, ^{
        
    });//主线程执行一次代码块

    //等group执行完后，才能执行下一步
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    /** 组（用于须要等待多个任务所有执行完再进行下一步） */
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, queue, ^{
        
    });//并发执行的代码块1
    dispatch_group_async(group, queue, ^{
        
    });//并发执行的代码块2
    dispatch_group_notify(group, queue, ^{
        
    });//等待两个代码块执行完汇总
    
    /** 栅栏（用于须要依次执行完多个线程组） */
    //并发队列异步执行代码块1，2
    dispatch_async(queue, ^{
        //代码块1
    });
    dispatch_async(queue, ^{
        //代码块2
    });
    //1，2执行完后才会执行3，4
    dispatch_barrier_async(queue, ^{
        
    });
    //并发队列异步执行代码块3，4
    dispatch_async(queue, ^{
        //代码块3
    });
    dispatch_async(queue, ^{
        //代码块4
    });

    /** 信号量（用于控制线程的等待和执行） */
    //建立信号量，value表示初始信号总量，支持多少个操做来执行
    dispatch_semaphore_t t = dispatch_semaphore_create(1);
    //发送一个信号，让信号总量+1
    dispatch_semaphore_signal(t);
    //使信号总量-1，若是总量为0，则会一直等待（阻塞所在线程），直到总量大于0则继续执行
    dispatch_semaphore_wait(t, DISPATCH_TIME_FOREVER);
    
    /*1.能够将异步执行变为同步执行，如须要等待下载完后再直接返回数据（咱们也能够经过block回调）*/
    //总信号量设置为0
    dispatch_semaphore_t t1 = dispatch_semaphore_create(0);
    //执行耗时代码
    void (^downloadTask)(void) = ^ {
        //下载图片
        ...
        ...
        //完成后发送信号量
        dispatch_semaphore_signal(t1);
    };
    downloadTask();
    //一直等到信号量计数为1才执行下一步，也就是等到图片下载完后
    dispatch_semaphore_wait(t1, DISPATCH_TIME_FOREVER);
    
    /*2.保证线程安全*/
    //设置信号量初始计数为1，保证只能有一个操做能进来
    dispatch_semaphore_t t2 = dispatch_semaphore_create(1);
    //至关于加锁，消耗使用计数，若是已经被一个线程使用，后续只能挂起等待信号量回复
    dispatch_semaphore_wait(t2, DISPATCH_TIME_FOREVER);
    //执行业务代码
    ...
    ...
    //解锁
    dispatch_semaphore_signal(t2);
    
    /*3.模拟NSOperationQueue的最大并发操做数*/
    //最大并发操做支持10
    dispatch_semaphore_t t3 = dispatch_semaphore_create(10);
    //剩余操做同上，其实就是相似于将NSOperationQueue的maxConcurrentOperationCount设置为10
复制代码

后台运行

在App程序进入后台时，咱们应该尽可能释放内存和保存用户数据或者状态信息。在默认状况下，应用仅有5秒钟处理这些工做，咱们能够经过调用UIApplication的beginBackgroundTaskWithExpirationHandler方法来申请延长处理时间，最多有十分钟。

- (void)applicationDidEnterBackground:(UIApplication *)application {
    //声明关闭后台任务代码块
    void (^endBackgroundTask)(UIBackgroundTaskIdentifier backgroudTask) = ^(UIBackgroundTaskIdentifier backgroudTask) {
        [[UIApplication sharedApplication] endBackgroundTask:backgroudTask];
        backgroudTask = UIBackgroundTaskInvalid;
    };
    
    //开启后台任务
    __block UIBackgroundTaskIdentifier backgroudTask;
    backgroudTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
        //十分钟内仍然没有完成，系统处理终止句柄
        endBackgroundTask(backgroudTask);
    }];
    
    //执行相关代码
    
    //结束后台任务
    endBackgroundTask(backgroudTask);
}
复制代码

线程死锁

- (void)viewDidLoad {
    [super viewDidLoad];
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"%@", [NSThread currentThread]);
    });
}
复制代码

在主队列中增长同步代码块，就会形成死锁，因为同步是须要当即顺序执行的，上述代码中，Block中的方法须要在viewDidLoad结束后才能完成，可是viewDidLoad想要结束又必须得先结束Block中的方法，因此相互永久等待，形成了死锁。

GCD会形成循环引用吗？

直接使用GCD的相关API通常是不会的，block结束后没有循环引用的条件，YYKit的Issues下有个有趣的讨论：dispatch_async的block里面须要__weak self 吗？

注意

同步执行会在当前线程执行任务，不具有开辟线程的能力或者说没有必要开辟新的线程。而且，同步执行必须等到Block函数执行完毕，dispatch函数才会返回，从而阻塞同一串行队列中外部方法的执行。
异步执行dispatch函数会直接返回，只有异步执行才有开辟新线程的必要，可是异步执行不必定会开辟新线程。
想要开辟新线程必须让任务在异步执行，想要开辟多个线程，只有让任务在并行队列中异步执行才能够。执行方式和队列类型多层组合在必定程度上可以实现对于代码执行顺序的调度。
同步+串行：未开辟新线程，串行执行任务；同步+并行：未开辟新线程，串行执行任务；异步+串行：新开辟一条线程，串行执行任务；异步+并行：开辟多条新线程，并行执行任务；在主线程中同步使用主队列执行任务，会形成死锁。

线程安全

线程安全主要是因为系统的线程调度具备必定的随机性形成的，因为是多并发，多个线程同时对一份数据进行读写，就可能在读取执行一半的时候另一个线程去写入，致使数据异常。

线程安全的类的特征

该类的对象能够被多个线程安全访问。
每一个线程调用对象的任意方法都会获得正确的结果。
每一个线程调用对象的任意方法以后，该对象仍保持合理状态。

@synchronized（同步锁、互斥锁）

为了解决这个问题，Objective-C的多线程支持引入同步，使用@synchronized修饰代码块，被修饰的代码块可简称为同步代码块。语法格式以下：

@synchronized (obj) {
    //同步代码块
}
复制代码

其中obj就是同步监视器，当一个线程执行同步前，必须先得到同步监视器的锁定，任什么时候刻只能有一个线程得到锁定，执行完成后，才会释放，若是此时有新线程访问，那么新线程会进入休眠状态。一般推荐使用可能被并发访问的的共享资源做为同步监视器。

NSLock

除了上面的同步代码块，还支持显示的同步锁NSLock，在须要加锁的代码块首尾使用- (void)lock;和- (void)unlock;来加锁和释放锁。

自旋锁

当新线程访问代码时，若是发现有其余的线程正在访问，新线程会用死循环的方式去等待当前线程的访问结束，比较耗性能，例如atomic就是采用的自旋锁。可使用OSSpinLock，可是有安全问题，iOS10之后可使用os_unfair_lock。

读写锁

//加读锁
pthread_rwlock_rdlock(&rwlock);
//解锁
pthread_rwlock_unlock(&rwlock);
//加写锁
pthread_rwlock_wrlock(&rwlock);
//解锁
pthread_rwlock_unlock(&rwlock);
复制代码

递归锁
条件锁
为了减小线程安全的负面影响，应使用何种策略？

只对有可能会形成资源竞争的方法进行同步。
提供非线程安全和线程安全两个版本，单线程中使用非线程安全版本。