OC底层探究 – 多线程

多线程

iOS中常见的多线程方案：

GCD的常用函数：

• 用同步的方式执行任务

  dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
  复制代码

• 用异步的方式执行任务

  dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
  复制代码

GCD源码

GCD的队列：

• 并发队列（Concurrent Dispatch Queue）

  • 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
  • 并发功能只有在异步（dispatch_async）函数下才有效

• 串行队列（Serial Dispatch Queue）

  • 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

容易混淆的术语

有4个术语比较容易混淆：同步、异步、并发、串行

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

各种队列的执行效果

死锁问题

产生死锁的根本原因：

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

- (void)interview01
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？会！
    NSLog(@"执行任务1");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"执行任务2");
    });
    
    NSLog(@"执行任务3");
    // dispatch_sync立马在当前线程同步执行任务
  	/*
  	*	执行任务1
  	*/
}

- (void)interview02
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
    NSLog(@"执行任务1");
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        NSLog(@"执行任务2");
    });
    
    NSLog(@"执行任务3");
    // dispatch_async不要求立马在当前线程同步执行任务
  	/*
  	*	执行任务1
  	*	执行任务3
  	*	执行任务2
  	*/
}

- (void)interview03
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？会！
    NSLog(@"执行任务1");
    
    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{ // 0
        NSLog(@"执行任务2");
        
        dispatch_sync(queue, ^{ // 1
            NSLog(@"执行任务3");
        });
    
        NSLog(@"执行任务4");
    });
    
    NSLog(@"执行任务5");
  	/*
  	*	执行任务1
  	*	执行任务5
  	*	执行任务2
  	*/
}

- (void)interview04
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
    NSLog(@"执行任务1");
    
    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
//    dispatch_queue_t queue2 = dispatch_queue_create("myqueu2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue2 = dispatch_queue_create("myqueu2", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{ // 0
        NSLog(@"执行任务2");
        
        dispatch_sync(queue2, ^{ // 1
            NSLog(@"执行任务3");
        });
        
        NSLog(@"执行任务4");
    });
    
    NSLog(@"执行任务5");
  	/*
  	*	执行任务1
  	*	执行任务5
  	*	执行任务2
  	* 执行任务3
  	* 执行任务4
  	*/
}

- (void)interview05
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
    NSLog(@"执行任务1");
    
    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{ // 0
        NSLog(@"执行任务2");
        
        dispatch_sync(queue, ^{ // 1
            NSLog(@"执行任务3");
        });
        
        NSLog(@"执行任务4");
    });
    
    NSLog(@"执行任务5");
  	/*
  	*	执行任务1
  	*	执行任务5
  	*	执行任务2
  	* 执行任务3
  	* 执行任务4
  	*/
}
复制代码

GCD队列组（Dispatch Group）

DispatchGroup 可以把多个并发执行的任务合并成一组，然后监听所有任务都完成的事件。比如，多个网络请求同时发出去，等网络请求都完成后 reload UI。

创建 Dispatch Group 的方式如下：

dispatch_group_t dispatch_group_create(void);
复制代码

dispatch group 就是个简单的数据结构，这种结构彼此之间没有什么区别，它不像派发队列，后者还有个用来区别身份的标识符。

使用 Dispatch Group 有两种方式：

• 使用 dispatch_group_async 函数

  它是普通 dispatch_async 函数的变体。group 参数用于表示执行的块所归属的组，queue 表示执行任务的队列，block 内包含要执行的任务。所以 dispatch_group_async 可以方便的向 dispatch group 中添加不同队列的不同任务。此函数中的 queue 既可以是串行队列，又可以是并发队列。

• 使用 dispatch_group_enter 和 dispatch_group_leave 一对函数

  前者能够使 dispatch group 里正要执行的任务数递增，而后者则使之递减。所以，调用完 dispatch_group_enter 以后，必须有与之对应的 dispatch_group_leave 才行。如果调用 enter 之后，没有相应的 leave 操作，那么这一组任务就永远执行不完。

当向 Group 中添加完所有任务之后，有两种方式可以等待任务完成：

• 使用 dispatch_group_wait 函数

  // 等待2秒，之后不管是否所有任务都已经完成，就直接往下执行代码
  dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)));
  // 一直等待，直到所有任务全部完成，才往下执行代码
  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
  复制代码

  dispatch_group_wait 是同步的，会阻塞当前线程，所以不能放在主线程执行。

• 使用 dispatch_group_notify 函数

  // 创建队列组
  dispatch_group_t group = dispatch_group_create();
  // 创建并发队列
  dispatch_queue_t queue = dispatch_queue_create("my_queue", DISPATCH_QUEUE_CONCURRENT);
      
  // 添加异步任务
  dispatch_group_async(group, queue, ^{
  		for (int i = 0; i < 5; i++) {
          sleep(1);
          NSLog(@"任务1-%@", [NSThread currentThread]);
      }
  });
  
  dispatch_group_async(group, queue, ^{
  		for (int i = 0; i < 5; i++) {
          sleep(1);
          NSLog(@"任务2-%@", [NSThread currentThread]);
      }
  });
  
  // 等前面的任务执行完毕后，会自动执行这个任务
  dispatch_group_notify(group, queue, ^{
  		dispatch_async(dispatch_get_main_queue(), ^{
  				for (int i = 0; i < 5; i++) {
  						NSLog(@"任务3-%@", [NSThread currentThread]);
          }
      });
  });
  复制代码

多线程安全隐患

示例一：存钱取钱

示例二：卖票

/**
 存钱、取钱演示
 */
- (void)moneyTest
{
    self.money = 100;
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self saveMoney];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self drawMoney];
        }
    });
}

/**
 存钱
 */
- (void)saveMoney
{
    int oldMoney = self.money;
    sleep(.2);
    oldMoney += 50;
    self.money = oldMoney;
    
    NSLog(@"存50，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
}

/**
 取钱
 */
- (void)drawMoney
{
    int oldMoney = self.money;
    sleep(.2);
    oldMoney -= 20;
    self.money = oldMoney;
    
    NSLog(@"取20，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
}

/**
 卖1张票
 */
- (void)saleTicket
{
    int oldTicketsCount = self.ticketsCount;
    sleep(.2);
    oldTicketsCount--;
    self.ticketsCount = oldTicketsCount;
    
    NSLog(@"还剩%d张票 - %@", oldTicketsCount, [NSThread currentThread]);
}

/**
 卖票演示
 */
- (void)ticketTest
{
    self.ticketsCount = 15;
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
             [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
}
复制代码

多线程安全隐患分析：

多线程安全隐患的解决方案：

• 使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）
• 常见的线程同步技术是：加锁

iOS线程同步方案

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

OSSpinLock

• OSSpinLock 叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源。

• 目前已经不再安全，可能会出现优先级反转问题

  • 如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁

• 需要导入头文件 #import <libkern/OSAtomic.h>

操作系统在多线程的时候，其实采用的是时间片轮转调度算法，给线程分配一个非常小的运行时间，一个线程的运行时间用完之后就执行下一个线程，这样我们看起来就好像多条线程同时在执行异议。这个算法是有优先级的，优先级高的线程，分配的运行时间可能就多一点。

// 初始化
OSSpinLock lock = OS_SPINLOCK_INIT;
// 尝试加锁（如果需要等待，就不加锁，直接返回false，如果不需要等待就加锁，返回true）
bool result = OSSpinLockTry(&lock);
// 加锁
OSSpinLockLock(&lock);
// 解锁
OSSpinUnLockLock(&lock);
复制代码

os_unfair_lock

• os_unfair_lock 用于取代不安全的 OSSpinLock ，从iOS10开始才支持
• 从底层调用看，等待 os_unfair_lock 锁的线程会处于休眠状态，并非忙等
• 需要导入头文件 #import <os/lock.h>

// 初始化
os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
// 尝试加锁（如果需要等待，就不加锁，直接返回false，如果不需要等待就加锁，返回true）
bool result = os_unfair_lock_trylock(&lock);
// 加锁
os_unfair_lock_lock(&lock);
// 解锁
os_unfair_lock_unlock(&lock);
复制代码

pthread_mutex

• mutex 叫做”互斥锁”，等待锁的线程会处于休眠状态
• 需要导入头文件 #import <pthread.h>

自旋锁和互斥锁在汇编层面的区别，自旋锁会导致汇编代码在某一段代码里重复执行，而互斥锁会让汇编代码退出线程，因为当前线程已经休眠，没有事情可做了。

断点执行汇编代码，遇到 syscall 就退出，说明线程已经休眠了。

普通锁

// 初始化属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
// 初始化锁
pthread_mutex_t *mutex;
pthread_mutex_init(mutex, &attr);
// 尝试加锁
pthread_mutex_trylock(&mutex);
// 加锁
pthread_mutex_lock(&mutex);
// 解锁
pthread_mutex_unlock(&mutex);
// 销毁属性
pthread_mutexattr_destroy(&attr);
// 销毁锁
pthread_mutex_destroy(&mutex);

// 初始化锁，如果属性传NULL，默认使用PTHREAD_MUTEX_DEFAULT
// pthread_mutex_init(mutex, NULL);

// 静态初始化
// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

/*
 * Mutex type attributes
 */
#define PTHREAD_MUTEX_NORMAL		0			// 普通锁
#define PTHREAD_MUTEX_ERRORCHECK	1		
#define PTHREAD_MUTEX_RECURSIVE		2		// 递归锁
#define PTHREAD_MUTEX_DEFAULT		PTHREAD_MUTEX_NORMAL  // 默认是普通锁
复制代码

递归锁

递归锁：允许同一个线程对一把锁进行重复加锁

#import "MutexDemo2.h"
#import <pthread.h>

@interface MutexDemo2()
@property (assign, nonatomic) pthread_mutex_t mutex;
@end

@implementation MutexDemo2

- (void)__initMutex:(pthread_mutex_t *)mutex
{
    // 递归锁：允许同一个线程对一把锁进行重复加锁
    
    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    // 初始化锁
    pthread_mutex_init(mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
}

- (instancetype)init
{
    if (self = [super init]) {
        [self __initMutex:&_mutex];
    }
    return self;
}

- (void)otherTest
{
    pthread_mutex_lock(&_mutex);
    
    NSLog(@"%s", __func__);
    
    static int count = 0;
    if (count < 10) {
        count++;
        [self otherTest];
    }
    
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc
{
    pthread_mutex_destroy(&_mutex);
}

@end
复制代码

条件

有些时候，我们在处理一件事情时，需要先验证某些条件是否成立，成立就执行，不成立就等待，知道条件成立以后再执行。多线程里也有相关的内容：

常用API：

// 初始化锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
// 初始化条件
pthread_cond_t cond;
pthread_cond_init(&cond, NULL);
// 等待条件（当前线程进入休眠，放开mutex锁；被唤醒后，会再次对线程进行加锁）
pthread_cond_wait(&cond, &mutex);
// 激活一个等待该条件的线程
pthread_cond_signal(&cond);
// 激活所有等待该条件的线程
pthread_cond_broadcast(&cond);
// 销毁资源
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
复制代码

示例：

#import <pthread.h>

@interface MutexDemo3()
@property (assign, nonatomic) pthread_mutex_t mutex;
@property (assign, nonatomic) pthread_cond_t cond;
@property (strong, nonatomic) NSMutableArray *data;
@end

@implementation MutexDemo3

- (instancetype)init
{
    if (self = [super init]) {
        // 初始化属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        // 初始化锁
        pthread_mutex_init(&_mutex, &attr);
        // 销毁属性
        pthread_mutexattr_destroy(&attr);
        
        // 初始化条件
        pthread_cond_init(&_cond, NULL);
        
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 线程1
// 删除数组中的元素
- (void)__remove
{
    pthread_mutex_lock(&_mutex);
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待条件（当前线程进入休眠，放开mutex锁；被唤醒后，会再次对线程进行加锁）
        pthread_cond_wait(&_cond, &_mutex);
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    
    pthread_mutex_unlock(&_mutex);
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    pthread_mutex_lock(&_mutex);
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    
    // 信号
    pthread_cond_signal(&_cond);
    // 广播
//    pthread_cond_broadcast(&_cond);
    
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc
{
    pthread_mutex_destroy(&_mutex);
    pthread_cond_destroy(&_cond);
}

@end
复制代码

NSLock

NSLock 是对 mutex 普通锁的封装

@protocol NSLocking
- (void)lock;
- (void)unlock;
@end

@interface NSLock : NSObject <NSLocking> {
- (BOOL)tryLock;
/*
*	传入一个时间，在这个时间之前，线程处于休眠状态
* - 如果在这个时间之前我能等到这个锁放开，就加锁成功，返回true，代码继续执行
* - 如果过了这个时间，锁还没有放开，那么就加锁失败，返回false，代码也继续执行
*/
- (BOOL)lockBeforeDate:(NSDate *)limit;
@end
复制代码

NSRecursiveLock

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

NSCondition

NSCondition 是对 mutex 和 cond 的封装

@interface NSCondition : NSObject <NSLocking> {
- (void)wait;
/*
*	传入一个时间，在这个时间之前，线程处于休眠等待状态
* - 如果在这个时间之前收到了激活信号，就醒来加锁，返回true，代码继续执行
* - 如果过了这个时间，还没有收到激活信号，那么就自动醒来加锁，返回false，代码也继续执行
*/
- (BOOL)waitUntilDate:(NSDate *)limit;
// 激活一个等待该条件的线程
- (void)signal;
// 激活所有等待该条件的线程
- (void)broadcast;
@end
复制代码

源码：

- (void) broadcast
{
  pthread_cond_broadcast(&_condition);
}

- (void) finalize
{
  pthread_cond_destroy(&_condition);
  pthread_mutex_destroy(&_mutex);
}

- (id) init
{
  if (nil != (self = [super init])) {
    if (0 != pthread_cond_init(&_condition, NULL)) {
	  	DESTROY(self);
		} else if (0 != pthread_mutex_init(&_mutex, &attr_reporting)) {
	  	pthread_cond_destroy(&_condition);
	  	DESTROY(self);
		}
  }
  return self;
}

- (void) signal
{
  pthread_cond_signal(&_condition);
}

- (void) wait
{
  pthread_cond_wait(&_condition, &_mutex);
}

- (BOOL) waitUntilDate: (NSDate*)limit
{
  NSTimeInterval ti = [limit timeIntervalSince1970];
  double secs, subsecs;
  struct timespec timeout;
  int retVal = 0;

  // Split the float into seconds and fractions of a second
  subsecs = modf(ti, &secs);
  timeout.tv_sec = secs;
  // Convert fractions of a second to nanoseconds
  timeout.tv_nsec = subsecs * 1e9;

  retVal = pthread_cond_timedwait(&_condition, &_mutex, &timeout);
  if (retVal == 0)
    {
      return YES;
    }
  if (retVal == ETIMEDOUT)
    {
      return NO;
    }
  if (retVal == EINVAL)
    {
      NSLog(@"Invalid arguments to pthread_cond_timedwait");
    }
  return NO;
}
复制代码

由源码可以看出来，NSCondition 遵循了 NSLocking 协议，而且NSCondition内部已经实现了锁，可以直接使用加锁解锁操作。

NSConditionLock

NSConditionLock 是对 NSCondition 的进一步封装，可以设置具体的条件值

@interface NSConditionLock : NSObject <NSLocking> {
- (instancetype)initWithCondition:(NSInteger)condition;
@property (readonly) NSInteger condition;
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;
@end
复制代码

示例

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one
{
    [self.conditionLock lock];
    
    NSLog(@"__one");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    
    NSLog(@"__three");
    
    [self.conditionLock unlock];
}

@end
复制代码

SerialQueue

直接使用GCD的串行队列，也是可以实现线程同步的

dispatch_queue_t ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL)
dispatch_sync(ticketQueue, ^{
		// 任务
});
复制代码

Dispatch_semaphore

semaphore叫做”信号量”

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

// 信号量的初始值
int value = 1;
// 初始化信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);
// 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
// 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// 让信号量的值+1
dispatch_semaphore_signal(self.semaphore);
复制代码

@synchronized

• @synchronized 是对 mutex 递归锁的封装
• 源码查看：objc4中的 objc-sync.mm 文件
• @synchronized(obj) 内部会生成obj对应的递归锁，然后进行加锁、解锁操作

@synchronized(obj) {
		// 任务
}
复制代码

线程同步方案比较

性能从高到低排序：

• os_unfair_lock（iOS10之后才支持）
• OSSpinLock（不再推荐）
• dispatch_semaphore
• pthread_mutex
• dispatch_queue(DISPATCH_QUEUE_SERIAL)
• NSLock
• NSCondition
• pthread_mutex(recursive)
• NSRecursiveLock
• NSConditionLock
• @synchronized

自旋锁、互斥锁比较

什么情况使用自旋锁比较划算？

• 预计线程等待锁的时间很短
• 加锁的代码（临界区）经常被调用，但竞争情况很少发生
• CPU资源不紧张
• 多核处理器

什么情况使用互斥锁比较划算？

• 预计线程等待锁的时间较长
• 单核处理器
• 临界区有IO操作
• 临界区代码复杂或者循环量大
• 临界区竞争非常激烈

在iOS里其实已经不需要考虑这个问题了，因为OSSpinLock自旋锁已经不再推荐，其他的基本都是互斥锁

atomic

• atomic用于保证属性setter、getter的原子性操作，相当于在 getter 和 setter 内部加了线程同步的锁

• 可以参考源码 objc4 的 objc-accessors.mm

• 它并不能保证使用属性的过程是线程安全的

atomic 在iOS中基本不会使用，因为太耗性能，一般用于MacOS。

iOS中的读写安全方案

思考如何实现以下场景：

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

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

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

pthread_rwlock

等待锁的线程会进入休眠，核心API：

// 初始化锁
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_destroy(&lock);
复制代码

dispatch_barrier_async

假设我们有一个并发的队列用来读写一个数据对象。如果这个队列里的操作是读的，那么可以多个同时进行。如果有写的操作，则必须保证在执行写入操作时，不会有读取操作在执行，必须等待写入完成后才能读取，否则就可能会出现读到的数据不对。这个时候我们会用到 dispatch_barrier_async。

• 以 dispatch_barrier_async 提交的任务能够保证其在并发队列执行的时候，是唯一的一个任务。

• 只对自己创建的队列有效，对 gloablQueue 无效

• 如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于 dispatch_async 函数的效果

dispatch_queue_t queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(self.queue, ^{
		[self read];
});

dispatch_barrier_async(self.queue, ^{
		[self write];
});        
复制代码

dispatch_once的实现原理

if (dispatch_atomic_cmpxchg(vval, NULL, &dow)) {
    _dispatch_client_callout(ctxt, func);
    tmp = dispatch_atomic_xchg(vval, DISPATCH_ONCE_DONE);
    tail = &dow;
    while (tail != tmp) {
        while (!tmp->dow_next) {
            _dispatch_hardware_pause();
        }
        sema = tmp->dow_sema;
        tmp = (struct _dispatch_once_waiter_s*)tmp->dow_next;
        _dispatch_thread_semaphore_signal(sema);
    }
} else {
    dow.dow_sema = _dispatch_get_thread_semaphore();
    for (;;) {
        tmp = *vval;
        if (tmp == DISPATCH_ONCE_DONE) {
            break;
        }
        dispatch_atomic_store_barrier();
        if (dispatch_atomic_cmpxchg(vval, tmp, &dow)) {
            dow.dow_next = tmp;
            _dispatch_thread_semaphore_wait(dow.dow_sema);
        }
    }
    _dispatch_put_thread_semaphore(dow.dow_sema);
}
复制代码

1. 第一次调用: 此时外部传进来的 onceToken 还是空指针，所以 vval 为 NULL，if 判断成立。首先执行 block，然后让将 vval 的值设为 DISPATCH_ONCE_DONE 表示任务已经完成，同时用 tmp 保存先前的 vval。此时，dow 也为空，因此 while 判断不成立，代码执行结束。

2. 同一线程第二次调用: 由于 vval 已经变成了 DISPATCH_ONCE_DONE，因此 if 判断不成立，进入 else 分支的 for 循环。由于 tmp 就是 DISPATCH_ONCE_DONE，所以循环退出，没有做任何事。

3. 多个线程同时调用: 由于 if 判断中是一个原子性操作，所以必然只有一个线程能进入 if 分支，其他的进入 else 分支。由于其他线程在调用函数时，vval 还不是 DISPATCH_ONCE_DONE，所以进入到 for 循环的后半部分。这里构造了一个链表，链表的每个节点上都调用了信号量的 wait 方法并阻塞，而在 if 分支中，则会依次遍历所有的节点并调用 signal 方法，唤醒所有等待中的信号量。

CADisplayLink、NSTimer使用注意

CADisplayLink、NSTimer 会对 target 产生强引用，如果 target 又对它们产生强引用，那么就会引发循环引用。

**解决方案一：**NSTimer可以使用block

__weak typeof(self) weakSelf = self;
[NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
		[weakSelf timerTest];
}];
复制代码

解决方案二：使用代理对象（继承自NSObject）

@implementation MJProxy

+ (instancetype)proxyWithTarget:(id)target
{
    MJProxy *proxy = [[MJProxy alloc] init];
    proxy.target = target;
    return proxy;
}

- (id)forwardingTargetForSelector:(SEL)aSelector
{
    return self.target;
}

@end
  
/*--------------------------------------------------*/

@interface ViewController ()
@property (strong, nonatomic) NSTimer *timer;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[MJProxy proxyWithTarget:self] selector:@selector(timerTest) userInfo:nil repeats:YES];
}

- (void)timerTest
{
    NSLog(@"%s", __func__);
}

- (void)dealloc
{
    NSLog(@"%s", __func__);
  	// 记得要销毁
    [self.timer invalidate];
}

@end
复制代码

**解决方案三：**使用代理对象（继承自NSProxy）

#import "MJProxy.h"

@interface MJProxy()
@property (weak, nonatomic) id target;
@end

@implementation MJProxy

+ (instancetype)proxyWithTarget:(id)target
{
    // NSProxy对象不需要调用init，因为它本来就没有init方法
    MJProxy *proxy = [self alloc];
    proxy.target = target;
    return proxy;
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel
{
    return [self.target methodSignatureForSelector:sel];
}

- (void)forwardInvocation:(NSInvocation *)invocation
{
    [invocation invokeWithTarget:self.target];
}
@end
  
/*--------------------------------------------------*/

@interface ViewController ()
@property (strong, nonatomic) NSTimer *timer;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[MJProxy proxyWithTarget:self] selector:@selector(timerTest) userInfo:nil repeats:YES];
}

- (void)timerTest
{
    NSLog(@"%s", __func__);
}

- (void)dealloc
{
    NSLog(@"%s", __func__);
  	// 记得要销毁
    [self.timer invalidate];
}

@end
复制代码

可以看到，方案二和方案三都是使用了消息转发，虽然看上去方案二的代码更简洁，但是我们推荐使用方案三，因为它的执行效率比较高。方案二在执行的时候，还是要走一遍 msgSend 流程，也就是找到类对象，然后查找方法是否存在，不存在，再去找类对象的父类，等等，而方案三会直接走到消息转发流程。

NSProxy是专门用来做代理的类，所以它更适合。

我们来看一下下面的代码会输出什么结果：

ViewController *vc = [[ViewController alloc] init];
// 继承自NSProxy
MJProxy *proxy1 = [MJProxy proxyWithTarget:vc];
// 继承自NSObject
MJProxy1 *proxy2 = [MJProxy1 proxyWithTarget:vc];
// 输出：1 0
NSLog(@"%d %d",
	[proxy1 isKindOfClass:[ViewController class]],
	[proxy2 isKindOfClass:[ViewController class]]);
复制代码

proxy1 在调用 isKindOfClass 的时候，会直接走到消息转发流程，相当与是让 vc 自己去调用 isKindOfClass 方法，所以结果肯定是 true；proxy2 在调用 isKindOfClass 时是去自己的类对象中查找对应的方法调用，结果是 false。

GCD定时器

NSTimer依赖于RunLoop，如果RunLoop的任务过于繁重，可能会导致NSTimer不准时。

使用GCD的定时器会更加准确。

// 创建队列
dispatch_queue_t queue = dispatch_queue_create("timer", DISPATCH_QUEUE_SERIAL);
// 创建定时器
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
// 设置时间
int64_t start = 2.0; // 2秒后开始执行
uint64_t interval = 1.0; // 时间间隔为1秒
dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC),
interval * NSEC_PER_SEC, 0);
// 设置回调
dispatch_source_set_event_handler(timer, ^{
		NSLog(@"1111");
});
// 启动定时器
dispatch_resume(timer);
复制代码

封装一个定时器工具类：

@interface MJTimer : NSObject

+ (NSString *)execTask:(void(^)(void))task
           start:(NSTimeInterval)start
        interval:(NSTimeInterval)interval
         repeats:(BOOL)repeats
           async:(BOOL)async;

+ (NSString *)execTask:(id)target
              selector:(SEL)selector
                 start:(NSTimeInterval)start
              interval:(NSTimeInterval)interval
               repeats:(BOOL)repeats
                 async:(BOOL)async;

+ (void)cancelTask:(NSString *)name;

@end

@implementation MJTimer

static NSMutableDictionary *timers_;
dispatch_semaphore_t semaphore_;
+ (void)initialize
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        timers_ = [NSMutableDictionary dictionary];
        semaphore_ = dispatch_semaphore_create(1);
    });
}

+ (NSString *)execTask:(void (^)(void))task start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
    if (!task || start < 0 || (interval <= 0 && repeats)) return nil;
    
    // 队列
    dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
    
    // 创建定时器
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    
    // 设置时间
    dispatch_source_set_timer(timer,
                              dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC),
                              interval * NSEC_PER_SEC, 0);
    
    
    dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
    // 定时器的唯一标识
    NSString *name = [NSString stringWithFormat:@"%zd", timers_.count];
    // 存放到字典中
    timers_[name] = timer;
    dispatch_semaphore_signal(semaphore_);
    
    // 设置回调
    dispatch_source_set_event_handler(timer, ^{
        task();
        
        if (!repeats) { // 不重复的任务
            [self cancelTask:name];
        }
    });
    
    // 启动定时器
    dispatch_resume(timer);
    
    return name;
}

+ (NSString *)execTask:(id)target selector:(SEL)selector start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
    if (!target || !selector) return nil;
    
    return [self execTask:^{
        if ([target respondsToSelector:selector]) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
            [target performSelector:selector];
#pragma clang diagnostic pop
        }
    } start:start interval:interval repeats:repeats async:async];
}

+ (void)cancelTask:(NSString *)name
{
    if (name.length == 0) return;
    
    dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
    
    dispatch_source_t timer = timers_[name];
    if (timer) {
        dispatch_source_cancel(timer);
        [timers_ removeObjectForKey:name];
    }

    dispatch_semaphore_signal(semaphore_);
}

@end
复制代码

面试题

1. 你理解的多线程？

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

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

4. GCD 的队列类型

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

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

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

   1. 追问一：自旋和互斥对比？
   2. 追问二：使用以上锁需要注意哪些？
   3. 追问三：用C/OC/C++，任选其一，实现自旋或互斥？口述即可！

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

   dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
   dispatch_async(queue, ^{
   		NSLog(@"1");
   		[self performSelector:@selector(test) withObject:nil afterDelay:.0];
   		NSLog(@"3");
   });
   // 结果输出： 1 3
   复制代码

   performSelector:withObject:afterDelay: 的本质是往 Runloop 中添加定时器，而子线程默认是没有启动 Runloop 的。