iOS 多线程简析

主要讲解多线程的基础概念和经典题目;

1. 多线程的分类

分类	简介	语言	内存管理
pthread	1. 通用多线程 API 2. 适用于 Unix/Linux/Windows 等系统 3. 跨平台可移植, 使用难度较大	C	程序员管理
NSThread	更加面相对象, 使用简单	OC	程序员管理
GCD	充分利用设备多核, 旨在替代NSThread	C	系统管理
NSOperation	基于 GCD,使用更更加简单,更加面相对象	OC	系统管理

关于多线程的常用术语:同步, 异步, 并发, 串行;

同步: 在当前线程执行任务, 不具备开启新线程能力;
异步: 在新的线程执行任务, 具备开启新线程的能力;
并发: 指并发队列, 多个任务同时执行, 并发功能只有在异步函数下才有效;(dispatch_async);;
串行: 指串行队列, 一个任务执行完指向下一个任务;

2. 以GCD为例简单分析线程和队列的关系;

1. 异步函数`dispatch_async`和同步函数 `dispatch_sync`

dispatch_async() :异步执行; 将传入的block块放入指定的queue中执行, 如果这个queue是非主队列那么它会立即返回block执行的结果(并不是block内部代码执行的结果),不会阻塞UI线程(处理一些耗时操作, 例如网络请求之类的); 如果这个queue是主队列那么它会等待block中代码执行完成后才会继续向下执行;
dispatch_sync() :同步执行; 不会创建新的线程, 只会在当前线程逐次执行;不论是添加到串行队列还是并行队列都是这个效果;

2. 获取队列方式

1 dispatch_get_global_queue(): 获取全局并行队列; 任务的执行不会相互依赖;
2 dispatch_get_main_queue(): 获取主队列, 配合异步async函数使用;
3 dispatch_queue_create(): 手动创建并发或者串行队列

SerialQueue:串行队列, 任务依赖,后面的任务依赖前面执行完才会执行;

dispatch_queue_t serialQueue = dispatch_queue_create("获取串行队列", NULL);
dispatch_queue_t serialQueue = dispatch_queue_create("获取串行队列",   DISPATCH_QUQUE_SERIAL);

ConcurrentQueue:并发队列, 任务不依赖;

 dispatch_queue_t serialQueue = dispatch_queue_create("获取并行队列", DISPATCH_QUQUE_CONCURRENT);

总结

执行方式/队列	主队列mainQueue()	全局并发队列globalQueue()	手动创建并发队列ConcurrentQueue()	手动创建串行队列SerialQueue()
同步执行 dispatch_sync()	死锁	`当前`线程,`串行`执行 `注解1`	`当前`线程, `串行`执行 `注解1`	`当前`线程,`串行`执行 `注解2`
异步执行 dispatch_async()	主线程只有一个, 在`主队列`依次执行任务	`开辟`新线程, `并发`执行 (线程会复用, 无序执行)	`开辟`新线程, `并发`执行	`开辟`新线程, `串行`执行

补充:

注解1 同步方式, 并发队列时候: 任务依次添加到队列中然后顺序执行, 但是并没有依赖关系, 只是依次将任务添加到队列中, 具体谁先执行完未知;
注解2 同步方式, 串行队列时候: 任务依次添加到队列中然后顺序执行, 并且! 上一个任务执行完毕后, 才能执行下一个任务;
注解1验证代码详见 情景4补充

3. 常见问题/情景分析

情景1:这段代码为什么会死锁?

- (void)viewDidLoad {
    [super viewDidLoad];
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"造成死锁");
    });
    
    // Do any additional setup after loading the view.
}

死锁原因:

1. 不论是viewDidLoad还是NSLog最后都要到主线程中去执行;
1. 在图的右列可以看出由于是dispatch_sync同步队列, 所以在执行完viewDidLoad才会去执行Block;
1. viewDidLoad首先到主线程中,执行到Block时需要等到Block执行完才能继续往下执行, 另一方面由于是dispatch_sync的原因; Block要在viewDidLoad执行完才会去执行;
1. 这样就造成了一个死循环, 成为死锁;

情景2: 这段代码执行结果为什么是 1, 3?

- (void)testCase1 {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"1");
        [self performSelector:@selector(print2) withObject:nil afterDelay:0];
        NSLog(@"3");
    });
}

- (void)print2 {
    NSLog(@"2");
}

原因:首先程序入口是async, 异步方式分发在全局队列中是会开辟子线程的,而performSelector: withObject: afterDelay:的调用本质上是往runloop中添加一个定时器; 但是我们知道只有在主线程才会默认开启runloop, 子线程中不会默认开启, 所以- (void)print2方法不会被触发;子线程中默认没有开启 Runloop

针对上面的代码稍微改进下就能打印出1, 2, 3了

- (void)testCase1 {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"1");
        [self performSelector:@selector(print2) withObject:nil ];
        NSLog(@"3");
      ///为 runloop 中添加 source1
        [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
         ///runloop 的 run 方法的本质就是不停的调用runMode:beforeDate:所以直接写成这样即可
        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    });
}

- (void)print2 {
    NSLog(@"2");
}

情景3: 这段代码执行结果为什么是 A>B>C>D>E?

- (void)viewDidLoad {
    [super viewDidLoad];
    [self testCase2];
}
- (void)testCase2 {
    NSLog(@"A");
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"B");
        dispatch_sync(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"C");
        });
        NSLog(@"D");
    });
    NSLog(@"E");
}

原因:首先testCase2函数入口是viewDidLoad在主线程;因为是sync函数, 所以往下执行都是在主线程中, 由于是全局并行队列,NSLog(@"B")和NSLog(@"C")会在全局队列中并发执行不会相互依赖;最终打印出A>B>C>D>E;

并发队列：并发队列中的任务可以并发执行，例如依次进入队列A,B,C,D四个任务那么顺序一定是先执行A再执行B的顺序, 但是在执行B,C,D时A是否执行完毕是不一定的;具体可以并发执行几个任务由系统控制(GCD中不能直接设置并发数，可以通过创建信号量的方式实现，NSOperationQueue可以直接设置);

情景4: 这段代码执行结果为什么会崩溃?

- (void)viewDidLoad {
    [super viewDidLoad];
    [self testCase3];
}
- (void)testCase3 {
    dispatch_queue_t  queue = dispatch_queue_create("queue1", NULL);
    NSLog(@"A");
    dispatch_sync(queue, ^{
        NSLog(@"B");
        dispatch_sync(queue, ^{
            NSLog(@"C");
        });
        NSLog(@"D");
    });
    NSLog(@"E");
}

原因:首先testCase3函数入口是viewDidLoad在主线程;因为是sync函数, 所以往下执行都是在主线程中, 由于queue是串行队列,所以在执行完NSLog(@"B");程序会因为队列的死锁而崩溃; 具体分析祥看情形1:这段代码为什么会死锁?;
将queue从串行队列改为并行队列即可解决死锁崩溃问题;示例代码

#稍微改下, 将串行队列改为并行后, 则不会再崩溃, 且可以正常依次打印 A>B>C>D>E
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"A");
    dispatch_sync(queue, ^{
        NSLog(@"B");
        dispatch_sync(queue, ^{
            NSLog(@"C");
        });
        NSLog(@"D");
    });
    NSLog(@"E");

情景4 `补充`: 验证同步方式的并行队列执行方式

    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"A");
    dispatch_sync(queue, ^{
        NSLog(@"B");
        dispatch_sync(queue, ^{
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"C");
            });
        });
        dispatch_sync(queue, ^{
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"C1");
            });
        });
        NSLog(@"D");
    });
    NSLog(@"E");

最终的执行结果是: A>B>D>E>C1>C 可以验证 同步, 并发队列时候: 任务依次添加到队列中然后顺序执行, 但是并没有依赖关系

情景5:如何实现一个多读单写模型?

实现此模型要用到这两个函数;示例代码

dispatch_barrier_async(<#dispatch_queue_t  _Nonnull queue#>, <#^(void)block#>)
dispatch_barrier_sync(<#dispatch_queue_t  _Nonnull queue#>, <#^(void)block#>)

多个读的线程可以并发,读和写的线程互斥, 多个写的线程互斥;

注意:dispatch_barrier_async只能配合自定义并行队列使用; 不用使用global_queue, 不然dispatch_barrier_async的效果会跟dispatch_async的效果一样;

#多读单写模型示例
@interface Model ()
///并发队列
@property (nonatomic, strong) dispatch_queue_t      queue;
///用户数据, 期间可能多线程同时访问
@property (nonatomic, strong) NSMutableDictionary  *dataDic;
@end


@implementation Model
- (instancetype)init {
    self = [super init];
    if (self) {
        self.queue = dispatch_queue_create("CONCURRENT_QUEUE", DISPATCH_QUEUE_CONCURRENT);
        self.dataDic = [NSMutableDictionary dictionaryWithCapacity:0];
    }
    return self;
}

- (id)objectForKey:(NSString *)key {
    __block id object;
    ///采用同步方式获取数据, 执行block然后返回
    dispatch_sync(self.queue, ^{
        object = [self.dataDic objectForKey:key];
    });
    return object;
}

- (void)setObject:(id)object forKey:(NSString *)key {
    ///采用barrier, 确保唯一一个线程在写
    dispatch_barrier_async(self.queue, ^{
        [self.dataDic setObject:object forKey:key];
    });
}

@end

情景6:如何实现并发执行A和B任务, 在A和B都完成后继续执行C任务?

日常开发中用到的场景, 两个接口请求的数据都返回后才能刷新UI;
使用dispatch_group_t达到预期效果;示例代码

@interface GroupModel  ()
@property (nonatomic, strong) dispatch_queue_t queue;
@end


@implementation GroupModel
- (instancetype)init {
    self = [super init];
    if (self) {
        self.queue = dispatch_queue_create("CONCURRENT_QUEUE", DISPATCH_QUEUE_CONCURRENT);
    }
    return self;
}

- (void)testGroupCase {
    dispatch_group_t group = dispatch_group_create();
    [self requestHTTP_AWithGroup:group];
    [self requestHTTP_BWithGroup:group];
    ///多个group全部leave后,即全部执行完后. 刷新UI
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        [self layoutUI];
    });
    
}


- (void)requestHTTP_AWithGroup:(dispatch_group_t)group {
    /**
     方式1: 将需要执行的内容放在block中, 但是这种由于是异步并不能立即获取到回调, 日常开发一般采用第二种方式
     dispatch_group_async(group, self.queue, ^{
     
     });
    */
    /**方式2*/
    if (group == nil) {
        return;
    }
    dispatch_group_enter(group);
    dispatch_async(self.queue, ^{
        for (int i = 0; i < 100; i ++) {
            NSLog(@"AAA");
        }
        dispatch_group_leave(group);
    });
}

- (void)requestHTTP_BWithGroup:(dispatch_group_t)group {
    if (group == nil) {
        return;
    }
    dispatch_group_enter(group);
    dispatch_async(self.queue, ^{
        for (int i = 0; i < 100; i ++) {
            NSLog(@"BBB");
        }
        dispatch_group_leave(group);
    });
}


- (void)layoutUI {
    NSLog(@"AAA和BBB各打印100次后更新UI");
}
@end

情景7:`NSOperation`多线程如何使用?

首先NSOpetaion是基于GCD封装的;
它是一个抽象类, 使用NSInvocationOperation和NSBlockOperation或者自定义子类;
相比其他多线程它有以下优点:

操作之间可以添加依赖, 方便控制执行的顺序;
可以设置任务的并发量(对比:GCD的globalQueue并发量是不可控的);
任务的执行状态是可以控制的;
通过KVO的方式监听isExecuteing、isFinished、isCancelled等操作;

详解可阅读这篇文章

文中示例代码

参考文章
iOS iOS 多线程--GCD 串行队列、并发队列以及同步执行、异步执行
 iOS 解决performSelector afterDelay在子线程不调用问题
 iOS dispatch_async 与 dispatch_get_global_queue 区别
 iOS GCD的Dispatch Queue（串行队列、并发队列、主队列)
iOS 多线程：『NSOperation、NSOperationQueue』详尽总结