基本概念

线程：一个应用的运行是一个进程，一个进程中可以开启多条线程执行不同的任务；线程是CPU分配和调度资源的最小单位；多线程并发其实是GPU的快速切换调度处理的假象 / 但并行是充分利用多核在多个线程上同步进行；可以提高CPU利用率和运行效率，但是过多时会占用内存空间，降低性能。

任务：狭义上指的闭包内的代码（如GCD的block中），分sync和async。

队列：存放待执行任务的等待队列，FIFO原则，分串行和并行。

线程同步：加锁；串行队列；NSOperation的最大并发数=1；各种Lock；信号量；CGD的barrierAPI。

多线程的优缺点：提升效率，充分利用多核特性；但创建线程需要资源消耗（子线程内存占用约512kb）；切换线程需要消耗CPU。

GCD

原理：时间片的轮换。让任务在线程中排队，根据可用资源安排内核处理，底层也是用线程实现，但是自动管理线程的声明周期，不用关心线程具体的使用情况。

源码中的队列

1个主线程管理池+1个其他线程管理池+14个runloop队列。其中12个可以通过各种API获取：create（优先级，overcommit，串行并行）组合获取。

根据qos，overcommit的组合，root queue一共12个。

主线程和主队列

主队列任务一定在主线程执行，但为了线程切换造成的性能消耗，主线程有空时可能会执行其他队列的任务（CPU的寄存器）。注：在GCD中我们永远无法直接接触到线程，而是根据队列和任务的组合选用，让系统自动对线程进行管理调度。

常用API

dispatch_queue_create创建队列（SERIAL串行，CONCURRENT并行）

dispatch_get_main_queue()获取主队列

dispatch_get_global_queue全局队列（入参qos优先级+overcommit是否过量开线程）

dispatch_after延迟把任务加入某队列

dispatch_barrier_async栅栏方法控制（自定义并行队列中分割任务执行顺序）

dispatch_once创建单例（保证程序中只执行一次）

dispatch_semaphore_create / signal / wait创建信号量（颗粒度更细的任务顺序控制，即加锁原理）

注1：overcommit，串行默认true表示内存不足也得开线程完成串行任务，并行false。

注2：barrier_sync和barrier_async都是等前面的执行完再执行自己的任务，再执行后面的任务。区别就是是否等待自己的任务执行完，再把后面的任务加入队列（但都不会执行）。

dispatch_once

多用于创建单例和方法交换。

单例原理：dispatch_once_t是个整型，外部初始化标记，dispatch_once(&onceToken)在初始化的标记下，才会执行Block，执行后标记掉dispatch_atomic_cmpxchg { block; dispatch_atomic_barrier内存屏障，加锁原子操作赋值onceToken }（所以要传地址），barrier实现原子操作保证线程安全，标记之后再次进入会调用_dispatch_hardware_pause以节省CPU。

注意事项：单例的block调用期间，多次请求同类的dispatch_once会造成请求链表无限增长，造成死锁。

单例的弊端：滥用单例会浪费资源占用内存；没有抽象层接口，难以扩展；职责过重未被单一职责；可能被回收造成状态丢失。

死锁

核心原因：任务的相互等待，如单例多次调用，串行队列追加同步任务。

具体原因：首先得是个同步任务操作（即sync一个任务），然后要sync到一个当前队列（别的队列肯定不阻塞啦），最后这个队列要串行的（并行的当然不阻塞啦），典型的就是主线程sync。

总结：当前队列（串行）追加同步任务（sync）。

注1：由于主队列的任务一定在主线程上执行，所以在主线程往主队列追加任务，就是往主线程同步任务，会阻塞主线程，造成死锁。

注2：死锁其实是队列任务互相等待引起的，而与线程无关。比如自建两个队列，嵌套sync，虽然是在同一线程执行（因为是sync），但因为队列不同所以不会造成死锁。

其他多线程方案

pthread：C语言跨平台的多线程API

NSThread：面向对象的轻量级多线程方案，手动管理生命周期，适合简单的场景。

NSOpertaion+NSOperationQueue：对GCD的封装，面向对象，可设置跨队列的依赖关系。

线程同步

为了防止多个线程抢夺同一个资源造成的数据安全问题，给线程加锁的操作。

原子操作：atomic修饰符-getter、setter加锁。

OSMemoryBarrier：内存屏障确保书写顺序。

Volatile：修饰变量，告诉编译器变量从内存而非寄存器读取。

其他加锁：OSSpinLock自旋锁，pthread_mutex互斥锁，@synchronize同步锁，dispatch_semaphore信号量加锁。

同步执行

GCD：将操作放入自建队列（串行）中。

NSOperation：任务放入自建队列并将最大并发数设置为1，设置跨队列依赖addDependency。

barrier_sync：栅栏方法，并发队列中先执行之前的。

semphore：信号量，收到signal+1，执行wait-1，<=0等待。

------旧版------

关键字：多线程原理，线程（偏CPU），队列（串行并行），任务（同步异步），GCD及其源码分析，@synchronized

概述

一个应用的运行是一个进程，一个进程中可以开启多条线程用于执行不同的任务，提高程序执行效率，但线程过多会占用大量内存空间，降低性能。iOS中一般将UI事件的处理放在主线程里。一些耗时的操作不应放入主线程，应新开线程异步执行。

原理：CPU只能处理一条线程，多线程实际上是CPU快速在多条线程间不断切换调度，而切换调度的时间特别快，造成了并发处理的假象。

队列与线程：队列是对线程的包装，便于使用，偏程序（线程偏CPU）。队列的底层也是通过线程实现的。

任务（狭义的闭包含义，非进程层级的广义任务）：根据是否开辟新线程，任务分为同步和异步，区别为是否阻塞当前线程。

iOS中的多线程

pthread

一套C语言编写的通用的跨平台的多线程API，iOS中不常用。忽略。

NSThread

面向对象的轻量级的多线程方案，更直观的控制线程对象，需手动管理生命周期，但多适用于比较简单的场景。

创建

1、实例方法创建（不需要start立刻创建线程）

[NSThread detachNewThreadSelector:@selector(doSomething:) toTarget:self withObject:nil];

2、performSelector创建（swift中取消了performSelector:方法）

[self performSelectorInBackground:@selector(SEL) withObject:nil];

3、类方法创建（需手动start，可在线程开始前配置stack大小和优先级）

NSThread * myThread = [[NSThread alloc] initWithTarget:(id)target selector:(SEL)selector object:(id)argument];

[myThread start];

属性和用法

@property (readonly, getter=isExecuting) BOOL executing;

@property (readonly, getter=isFinished) BOOL finished;

@property (readonly, getter=isCancelled) BOOL cancelled;

@property (nullable, copy) NSString *name;

- (void)start;

- (void)cancel;

+ (void)exit;

+ (NSThread *)mainThread;

+ (NSThread *)currentThread;

+ (void)sleepForTimeInterval:(NSTimeInterval)time;

GCD

苹果为多核开发的多线程解决方案，自动利用CPU内核，自动管理线程的生命周期，使用了C语言和Block，更加方便灵活的管理多线程。

队列

串行队列（连续性）：FIFO（先进先出）串联执行。包括主队列dispatch_get_main_queue和自建队列dispatch_queue_create（第一个参数表示队列名，第二个参数表示队列类型：DISPATCH_QUEUE_SERIAL或NULL创建串行队列，DISPATCH_QUEUE_CONCURRENT创建并行队列）。

并行队列（并发性）：全局并行队列dispatch_get_global_queue（priority指定优先级，flag作为保留参数备用）。

注：dispatch_queue_create+DISPATCH_QUEUE_CONCURRENT创建自建并行队列是没有必要的，所有并发操作应放在全局并行队列中以节省开销。

任务（即一段代码）

dispatch_sync：创建同步执行任务，阻塞当前线程直到block结束，在主线程直接调用会死锁：

dispatch_sync(any queue, ^{ // 死锁 });

在其他串行线程中，创建同步任务也会死锁：

dispatch_sync(create_queue, ^{

        // 当前调用栈向其他队列（自建队列）提交block是可以执行的

        dispatch_sync(dispatch_get_main_queue(), ^{  // 死锁  });

});

dispatch_async：创建异步执行任务，不阻塞当前线程（或者说新开了线程执行任务）。

参数：一个队列，一个block，block会在指定的队列里按照其串行或并行属性执行。

用法和实例

1、不阻塞当前线程的情况下，在主队列中强行插入串行任务

dispatch_async(dispatch_get_main_queue(), ^{ });

注：如sdwebimage下载图片时，processblock回调中的UI更新操作应插入主线程，否则不能实时更新UI。

2、不阻塞当前线程的情况下，在全局队列中加入并行任务

dispatch_async(dispatch_get_global_queue(0, 0), ^{ });

3、异步在自定义队列中插入串行任务

dispatch_queue_t urls_queue = dispatch_queue_create(“test.myQueue", NULL);

dispatch_async(urls_queue, ^{ });

dispatch_release(urls_queue); //释放队列（提前结束线程）

4、队列组

dispatch_group_t group = dispatch_group_create();  //创建队列组

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  //全局并行队列

dispatch_group_async(group, queue, ^{  //任务一  });

dispatch_group_async(group, dispatch_get_main_queue(), ^{  //任务二  });

dispatch_group_enter(group); //标志队列组内的异步任务开始，类似引用计数+1

dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{

      //任务三（任务中可嵌套处理异步操作，即处理异步任务的同步）

     sleep(5);  //异步操作

     dispatch_group_leave(group);  //标志异步任务结束，一般写在异步操作完成的block内实现队列组内任务完成的统一通知

});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{   //当group组中的任务都完成后，会自动通知   });

dispatch_async(dispatch_get_global_queue(0, 0), ^{

    dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC));  //监听group队列组中的全部任务并设置超时时间

    //此处执行和dispatch_group_notify的block参数中一样的内容

});

注：上述三个任务（全局队列+主队列+全局队列中的异步任务）执行顺序严格上来说是完全并行无顺序的，但实际会按照三个任务的执行顺序打印，任务内的每行代码才会穿插并行。

5、其他用法

//生命周期内的一次性执行（单例模式）

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{  });

//延迟执行

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2.0 * NSEC_PER_SEC), dispatch_get_main_queue(), ^(void){  });

GCD源码分析

15+1个队列

4-15这12个队列可以用GCD的各种方法获取，1是main-thread主线程管理池

dispatch_queue_create

执行_dispatch_lane_create_with_target(const char* label, dispatch_queue_attr_t  dqa, dispatch_queue_t tq, bool legacy) 方法，步骤如下：

1、_dispatch_queue_attr_to_info：解析attr生成dqai（如果是串行队列直接返回{}），并赋值qos（优先级）、overcommit（没有空余线程时是否开新的，串行默认true）、concurrent（区分并行和串行）等。

2、_dispatch_root_queues：创建target队列——根据qos和overcommit，从root中拿一个（由于qos*6和overcommit的组合，root queue一共有12个）

3、_dispatch_object_alloc，_dispatch_queue_init：创建队列，legacy释放相关，根据dqai中的concurrent设置DISPATCH_VTABLE类对象，调用_dispatch_object_alloc(vtable，sizeof(struct dispatch_lane_s))申请队列的内存空间，_dispatch_queue_init初始化queue设置最大并发数和激活状态。

_dispatch_queue_init的三个参数：_dispatch_object_alloc生成的dispatch_lane_t、legacy转来的dispatch_queue_flags_t、串行并行决定的的width最大线程数、dqai.dqai_inactive决定initial_state_bits激活状态。

4、dq -> dq_label，dq -> dq_priority，_dispatch_retain，dq->do_targetq，设置各种属性

5、return _dispatch_trace_queue_create(dq)._dq; 返回最终创建的队列。

dispatch_get_main_queue

return DISPATCH_GLOBAL_OBJECT(dispatch_queue_main_t,_dispatch_main_q);

dispatch_queue_main_t：主队列类型，define了

1、_dispatch_get_default_queue(overcommit)为true

2、root queue为_dispatch_root_queues[DISPATCH_ROOT_QUEUE_IDX_DEFAULT_QOS + \ !!(overcommit)]._as_dq。（由此可知是_dispatch_root_queues中的第7个，和串行队列一致）

_dispatch_main_q：初始化dispatch_queue_static_s结构体，并赋值state、label、atomic_flags、serialnum等。

dispatch_get_global_queue

return _dispatch_get_root_queue(qos, flags & DISPATCH_QUEUE_OVERCOMMIT);

获取方式和结构与主队列略有区别，但最终也是去root queue中获取，根据qos和overcommit = 0拿到第6个queue。

create自建队列 和 main/global queue 获取方式的区别

create需要自己alloc和init，最后从root queue里拿一个系统queue作为target queue。

main和global是根据qos和overcommit直接拿出对应的queue。

NSOperation和NSOperationQueue

对GCD的封装，完全面向对象。NSOperation对应GCD的任务；NSOperationQueue对应GCD的队列。将任务添加到队列中，系统自动执行。

NSOperation

内部任务执行状态机：ready→executing→finished/cancelled。

NSOperation是个抽象类不能直接使用，一般使用它的子类NSBlockOperation（用block传递任务）和NSInvocationOperation（用@selector传递任务）。

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{  }];

NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

[operation start]; //默认asynchronous = NO，阻塞当前线程

NSBlockOperation有个addExecutionBlock的方法，可以给一个任务添加多个block且在多个线程中并发执行，add一定要在start前。

注：当我们在自定义operation中构建异步任务时（自定义同步任务无意义因为可以直接用它的两个子类），应重写asynchronous属性（默认是NO时任务执行完operation状态自动变成finished）的getter返回YES，在异步任务完成的block中手动设置finished状态（此操作涉及KVO的手动触发）。重写main方法时一定要加入@autoreleasepool自动释放池，因为无法访问主线程的自动释放池。如果要完全控制状态机，也要重写start方法判断或者手动触发任务执行状态的KVO（cancelled，executing等）。同GCD中的dispatch_group_enter/leave。

注2：NSInvocation用于主动调用对象的方法，处理performSelector无法处理的多参数或有返回值的方法调用。

注3：addDependency可以添加依赖让NSOperation在队列中按顺序串行，相互依赖会死锁。

NSOperationQueue

NSOperation的直接执行还是会占用当前线程，所以应把任务加到队列中，添加完成后，任务会自动start，并根据NSOperationQueue的maxConcurrentOperationCount属性决定并行数（= 1时即为串行），并根据waitUntilFinished决定是否阻塞当前线程（同步异步）。

NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];  //创建主队列

NSOperationQueue *otherQueue = [[NSOperationQueue alloc] init];  //创建其他队列

[mainQueue addOperation:operation]; //传入NSOperation任务对象

[otherQueue addOperationWithBlock:^{  //传入任务block }];

[operation2 addDependency:operation1]; //设置依赖，按顺序执行任务

[otherQueue addOperations:@[operation1, operation2] waitUntilFinished:NO];  //不阻塞当前线程

注：主队列是在主线程中执行的，所以默认最大并发数就是1，且设置无效。

注2：监听队列的完成需要手动添加KVO监听operationCount。

其他方法和属性

@property (getter=isSuspended) BOOL suspended;  //暂停和继续队列

- (void)cancelAllOperations;  //取消队列所有任务

- (void)waitUntilAllOperationsAreFinished;  //阻塞线程直至队列任务全部完成