iOS多线程

1.你理解的多线程？

2.iOS的多线程方案哪有几种？你更倾向于哪一种?

3.你在项目中用过GCD吗？

4.GCD的队列类型

5.说一下OperationQueue和GCD的区别，以及各自的优势

6.线程安全的处理手段有哪些？

7.OC你了解的锁有哪些？在你回答基础上进行二次提问

• 自旋和互斥对比？使用以上锁需要注意哪些？用C/OC/C++，任选其一，实现自旋或互斥，口述即可

1.请问下面代码的打印结果是什么？

    dispatch_queue_t queue = dispatch_get_global(0, 0);
    dispatch_async(queue, ^{
        NSLog(@"1");
        [self performSelector:@selector(test) withObject:nil afterDelay:.0];
        NSLog(@"3");
    });
    - (void)test {
        NSLog(@"2");
    }

• 打印结果是1，3
• 原因：
  • performSelector:withObject:afterDelay:的本质是往Runloop中添加定时器
  • 子线程默认没有启动Runloop

2.请问下面代码打印结果是什么？

    - (void)test {
        NSLog(@"2");
    }
    - (void)touchesBegan:(NSSet<UITouch *>)touches withEvent(UIEvent *)event {
        NSThread *thread = [[NSThread alloc] initWithBlock:^{
            NSLog(@"1");
        }];
        [thread start];
        [self performSelector:@selector(test) onThread:thread withObject:nil waitUntilDone:YES];
    }

• 闪退报错：target thread exited while waiting for the perform

iOS中的常见多线程方案

• 1.pthread

  • 简介
    • 一套通用的多线程API
    • 适用于Unix\Linux\Windows等系统
    • 跨平台\可移植
    • 使用难度大
  • 语言
    • C
  • 线程生命周期
    • 程序员管理
  • 使用频率
    • 几乎不用

• 2.NSThread

  • 简介
    • 使用更加面向对象
    • 简单易懂，可直接操作线程对象
  • 语言
    • OC
  • 线程生命周期
    • 程序员管理
  • 使用频率
    • 偶尔使用

• 3.GCD
  • 简介
    • 旨在替代NSThread等线程技术
    • 充分利用设备的多核
  • 语言
    • C
  • 线程生命周期
    • 自动管理
  • 使用频率
    • 经常使用

• 4.NSOperation
  • 简介
    • 基于GCD（底层是GCD）
    • 比GCD多了一些更简单使用的功能
    • 使用更加面向对象
  • 语言
    • OC
  • 线程生命周期
    • 自动管理
  • 使用频率
    • 经常使用

GCD的常用函数

• GCD中有2个用来执行任务的函数
  • 用同步的方式执行任务
    • dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
      • queue: 队列
      • block: 任务
  • 用异步的方式执行任务
    • dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

GCD的队列

• GCD的队列可以分为2大类型
  • 并发队列（Concurrent Dispatch Queue）
    • 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
    • 并发功能只有在异步（dispatch_async）函数下才有效
  • 串行队列（Serial Dispatch Queue）
    • 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

容易混淆的术语

• 有4个术语比较容易混淆：同步、异步、并发、串行
  • 同步和异步主要影响：能不能开启新的线程
    • 同步：在当前线程中执行任务，不具备开启新线程的能力
    • 异步：在新的线程中执行任务，具备开启新线程的能力
  • 并发和串行主要影响：任务的执行方式
    • 并发：多个任务并发（同时）执行
    • 串行：一个任务执行完毕后，再执行下一个任务

各队列的执行效果

• 同步
  • 并发队列
    • 没有开启新线程
    • 串行执行任务
  • 手动创建的串行队列
    • 没有开启新线程
    • 串行执行任务
  • 主队列
    • 没有开启新线程
    • 串行执行任务
• 异步
  • 并发队列
    • 有开启新线程
    • 并发执行任务
  • 手动创建的串行队列
    • 有开启新线程
    • 串行执行任务
  • 主队列
    • 没有开启新线程
    • 串行执行任务

使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）

队列组的使用

• 思考：如何用GCD实现以下功能
  • 异步并发执行任务1、任务2
  • 等任务1、任务2执行完毕后，再回到主线程执行任务3

    dispatch_group_t group = dispatch_grout_create();
    dispatch_quque_t queue = dispatch_quque_create("myQueue", DISPATCH_QUQUE_CONCURRENT);
    dispatch_group_async(group, queue, ^{
        NSLog(@"执行任务1");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"执行任务2");
    });
    dispatch_group_notify(group, queue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"执行任务3");
        });
    });
    

多线程的安全隐患

• 资源共享
  • 1块资源可能被多个线程共享，也就是多个线程可能同时访问同一块资源
  • 比如多个线程访问同一个对象、同一个变量、同一个文件
• 当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

iOS中的线程同步方案

• OSSpinLock
• os_unfair_lock
• pthread_mutex
• dispatch_semaphore
• dispatch_queue(DISPATCH_QUEUE_SERIAL)
• NSLock
• NSRecursiveLock
• NSCondition
• NSConditionLock
• @synchronized

NSLock、NSRecursiveLock

• NSLock是对mutex普通锁的封装

    @interface NSLock : NSObject <NSLocking> 
    - (BOOL)tryLock;
    - (BOOL)lockBeforeDate:(NSDate *)limit;
    @end
    
    @protocol NSLocking
    - (void)lock;
    - (void)unlock;
    @end

• NSRecursiveLock也是对mutex递归锁的封装，API跟NSLock基本一致

dispatch_semaphore

• semaphore叫做“信号量”
• 信号量的初始值，可以用来控制线程并发访问的最大数量
• 信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

    // 信号量的初始值
    int value = 1;
    // 初始化信号量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);
    // 如果信号量的值<=0,当前线程就会进入休眠等待（知道信号量的值>0）
    // 如果信号量的值>0,就会减1，然后往下执行后面的代码
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    // 让信号量的值加1
    dispatch_semaphore_signal(semaphore)

@synchronized

• @synchronized是对mutex递归锁的封装
• @synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

    @synchronized(obj) {
        // 任务
    }

自旋锁、互斥锁比较

• 什么情况使用自旋锁比较划算？
  • 预计线程等待锁的时间很短
  • 加锁的代码（临界区）经常被调用，但竞争情况很少发生
  • CPU资源不紧张
  • 多核处理器
• 什么情况使用互斥锁比较划算？
  • 预计线程等待锁的时间较长
  • 单核处理器
  • 临界区有IO操作
  • 临界区代码复杂或者循环量大
  • 临界区竞争非常激烈

iOS中的读写安全方案

• 思考如何实现以下场景

  • 同一时间，只能有1个线程进行写的操作
  • 同一时间，允许有多个线程进行读的操作
  • 同一时间，不允许既有写的操作，又有读的操作

• 上面的场景就是典型的“多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有

  • pthread_rwlock：读写锁
  • dispatch_barrier_async：异步栅栏调用

phread_rwlock

• 等待锁的线程会进入休眠

    // 初始化锁
    pthread_rwlock_t lock;
    pthread_rwlock_init(&lock, NULL);
    // 读-加锁
    pthread_rwlock_rdlock(&lock);
    // 读-尝试加锁
    pthread_rwlock_tryrdlock(&lock);
    // 写-加锁
    pthread_rwlock_wrlock(&lock);
    // 写-尝试加锁
    pthread_rwlock_trywrlock(&lock);
    // 解锁
    pthread_rwlock_unlock(&lock);
    // 销毁
    pthread_rwlock_destory(&lock);

dispatch_barrier_async

• 这个函数传入的并发队列必须是自己通过dispatch_queue_create创建的
• 如果传入的是一个串行或是一个全局的并发队列，那这个函数变等同于dispatch_async函数的效果

    dispatch_queue_t queue = dispatch_queuq_create("rw_queue", DISPATCH_QUQUE_CONCURRENT);
    // 读
    dispatch_async(queue, ^{
        
    });
    // 写
    dispatch_barrier_async(queue, ^{
    
    });