底层原理：多线程

iOS中常见多线程方案

NSThread 、 GCD 和 NSOperation 底层都是依赖于 pthread

GCD

GCD的常用函数

GCD中有两个用来执行任务的函数

用同步方式执行任务（在当前线程执行任务）

 dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
 // queue：队列
 // block：任务

用异步的方式执行任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

GCD源码：https://github.com/apple/swift-corelibs-libdispatch

GCD的队列

GCD的队列可以分为两大类型

并发队列（Concurrent Dispatch Queue）

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

串行队列

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

容易混淆的术语

有4个术语比较容易混淆：同步、异步、并发、串行
1. 同步和异步主要影响：能不能开启新的线程
- 同步：在当前线程中执行任务，不具备开启新线程的能力
- 异步：在新的线程中执行任务，具备开启新线程的能力
1. 并发和串行主要影响：任务的执行方式
- 并发：多个任务并发（同时）执行
- 串行：一个任务执行完毕后，再执行下一个任务
1. dispatch_async和dispatch_sync用来控制是否要开启新的线程，其只是具备开启新线程的能力。
2. 主队列也是一种特殊的串行队列

各种队列的执行效果

	并发队列	串行队列	主队列
同步	没有开启新线程串行执行任务	同左	同左
异步	有开启新线程并发执行任务	有开启新线程串行执行	同上

总结：只要是同步函数或者是主队列就不会开启新线程，且为串行执行任务

队列组

GCD的带有 Create 的是不需要释放的，带有 CF 的是需要释放的。

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

死锁

以下代码会出现死锁

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"任务2");
    });
    NSLog(@"任务3");
}

出现死锁的原因：dispatch_sync为同步执行，同步的意思是立马在当前线程执行任务，执行完毕才能继续向下执行，因此只有执行完任务2才能执行任务3，但是执行任务2必须等上一个任务执行完才能执行2，也就是viewDidLoad执行完才能执行任务2，最终任务3在等任务2执行完，任务2又在等viewDidLoad执行完，而viewDidLoad需要等任务3执行完，最终导致死锁。

这种情况不会产生死锁

- (void)test2
{
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        NSLog(@"任务2");
    });
    NSLog(@"任务3");
}

执行的结果是先输出任务1，再输出任务3，最后任务2，不会死锁的原因是dispatch_async不要求立马在当前线程同步执行任务，在执行任务2的时候已经出了test2的栈了。

这种情况也可以产生死锁

- (void)test3
{
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{ //0
        NSLog(@"任务2");
        dispatch_sync(queue, ^{ //1
            NSLog(@"任务3");
        });
        
        NSLog(@"任务4");
    });
    
    NSLog(@"任务5");
}

产生死锁的原因是：dispatch_sync要求立马在当前线程执行block1，但要执行block1有个前提条件是block0要从队列中执行完block1才能执行，block0要执行的话block1要执行完它才能执行任务4，因此产生死锁。

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

以下代码的输出结果

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        NSLog(@"1");

        [self performSelector:@selector(testLog) withObject:nil afterDelay:.0];
        NSLog(@"3");

//        [[NSRunLoop currentRunLoop]addPort:[NSPort port] forMode:NSDefaultRunLoopMode];
//        [[NSRunLoop currentRunLoop]runMode:NSDefaultRunLoopMode beforeDate: [NSDate distantFuture]];
    });
}

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

输出结果是：1和3，2是不会输出的，因为有afterDelay的方法是跟runloop有关的，之所以会延迟本质是向Runloop里面添加timer，其因为在子线程里runloop没有启动故不会输出，如果想要其正常输出，需要将子线程的runloop启动，即把注释的代码打开即可。

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    NSLog(@"1");
    [self performSelector:@selector(testLog) withObject:nil afterDelay:.0];
    NSLog(@"3");
}

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

这种情况下输出结果是：1，3，2

performSelector里没有 'afterDelay' 的只是被转换成了 Objc_msgSend，而有 afterDelay 的是跟 RunLoop 相关的。

多线程的安全隐患

可能会出现的隐患有：

资源共享

一块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件

当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题，如买票和存钱取钱问题

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

使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）
常见的线程同步技术是：加锁，目的是保证当前只有一条线程访问，加锁后记得要解锁

线程阻塞

常见的线程阻塞有两种：

一种是sleep
另外一种是while循环，忙等，始终在等待直到锁打开。

iOS中的线程同步方案

OSSpinLock 自旋锁
os_unfair_lock
pthread_mutex
dispatch_semaphore 信号量
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock
NSRecursiveLock
NSCondition
NSConditionLock
synchronized

1. OSSpinLock(已过期)

OSSpinLock叫做“自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源
目前已经不再安全，可能会出现优先级反转问题：如两条线程同时访问saleTicket方法，如果优先级低的线程先加了锁，然后优先级高的线程执行到这个方法时发现有锁，其会在此处忙等（while (是否有锁) nil），但其由于优先级高CPU给予了大量时间从而导致优先级低的线程虽然进入了方法内部，但因优先级低而导致无法执行下一句代码，导致这把锁有可能放不开，造成类似死锁的现象。
如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁
需要导入头文件#import

以卖票为例，完整的代码是下面这样子的

@interface ViewController ()

@property (nonatomic, assign) NSInteger ticketCount;
@property (nonatomic, assign) OSSpinLock lock; //C语言类型的，故用assign

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    //初始化锁
    OSSpinLock lock = OS_SPINLOCK_INIT;
    
    [self ticketTest];
}

- (void)ticketTest
{
    self.ticketCount = 15;
    dispatch_queue_t queue = dispatch_get_global_queue(0, DISPATCH_QUEUE_PRIORITY_DEFAULT);
    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];
        }
    });
}

- (void)saleTicket
{
    //加锁
    OSSpinLockLock(&_lock);
    
    NSInteger count = self.ticketCount;
    sleep(.2);
    count--;
    self.ticketCount = count;
    NSLog(@"%@-------ticketCount = %ld",[NSThread currentThread],self.ticketCount);
    //解锁
    OSSpinLockUnlock(&_lock);
}

@end

注意事项：在创建锁时不能把创建锁的操作放在saleTicket里，这样的话会在这个方法每次执行时创建一个锁，各个线程之间的锁不共用，因此不能实现同步的功能。
计算机在调度进程和线程时用的都是：时间片轮转调度算法，即给每一条线程分配很短的时间，看越来像多条线程一块执行一梓，然后如果哪条线程的优先级高的点就会多执行一点时间。
OSSpinLock之前是性能最高的一种锁，因为它是处于忙等，忙等的好处是不会让线程睡眠，线程一旦睡着，再想把它唤醒，中间也是要耗性能的，也要花时间。

2. os_unfair_lock

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

完整的代码如下

@interface ViewController ()

@property (nonatomic, assign) NSInteger ticketCount;
@property (nonatomic, assign) os_unfair_lock lock;

@end

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.

    //初始化
    os_unfair_lock unfairLock = OS_UNFAIR_LOCK_INIT;
    self.lock = unfairLock;
}

- (void)saleTicket
{
    //尝试加锁 
    //os_unfair_lock_trylock(&_lock);
    //加锁2
    os_unfair_lock_lock(&_lock);
    NSInteger count = self.ticketCount;
    sleep(.2);
    count--;
    self.ticketCount = count;
    NSLog(@"%@-------ticketCount = %ld",[NSThread currentThread],self.ticketCount);
    //如果忘记解锁，专业术语叫死锁
    os_unfair_lock_unlock(&_lock);
}

3. pthread_mutex

带P开头的一般都是跨平台的
mutex叫做“互斥锁”，等待锁的线程会处于休眠状态，而“自旋锁”刚好与这相反，是不休眠，一直旋转，一直在等和执行代码。

完整代码如下：

#import 

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
   
    //初始化属性
    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_mutexattr_destroy(&attr);

    //尝试加锁
    pthread_mutex_trylock(&mutex);
    //加锁
    pthread_mutex_lock(&_mutex);
    //减票操作
    //解锁
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc
{
   //销毁锁
   pthread_mutex_destroy(&_mutex);
}

4.NSLock

NSLock 是对 mutex 普通锁的封装，其实现了 NSLocking 协议

@interface NSLock : NSObject  
- (BOOL)tryLock; //尝试加锁，如果不能加，返回NO
- (BOOL)lockBeforeDate:(NSDate *)limit;  //在这个时间点之前如果没有等到这个锁则休眠，如果到了这个时间点还没有等到这个锁，则加锁失败，返回NO
@end

使用方式

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLock *lock = [[NSLock alloc]init];
    [lock lock];
    [my test];
    [lock unLock];
}

5. NSRecursiveLock

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

6. NSCondition

NSCondition 是对 mutex 和 cond 的封装

@interface NSCondition : NSObject  
- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;
@end

用法如下：

- (void)run
{
    [self.condition lock];
    //信号，其他锁也可以用 signal，用于唤醒等待的线程
    [self.condition signal];
    //等待，一旦设置为 wait 则其他线程可以加锁
    [self.condition wait];
    [self.condition unLock];
}

7. NSConditionLock

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

@interface NSConditionLock : NSObject  

@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

8. dispatch_semaphore

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

- (void)viewDidLoad {
    [super viewDidLoad];

    //信号量的初始值,可以用来控制线程并发访问的最大数量
    int value = 1;
    //初始化信号量
    dispatch_semaphore_t phore = dispatch_semaphore_create(value);
    //如果信号量的值<=0，当前线程就会进入休眠等待（直到信号量的值>0）
    //如果信号的值>0，就减1，然后往下执行后面的代码，DISPATCH_TIME_FOREVER表示一直等，直到有信号量的值大于1为止
    dispatch_semaphore_wait(phore, DISPATCH_TIME_FOREVER); // 这句代码使value - 1
    //即最多有初始个值访问下面的代码
    NSLog(@"%@",[NSThread currentThread]);
    //让信号量的值加1
    dispatch_semaphore_signal(phore);
}

9. @synchronized

@synchronized 是对 mutex 递归锁的封装

- (void)viewDidLoad {
    [super viewDidLoad];

    //拿self对象来做把锁
    @synchronized (self)
    {
        NSLog(@"%@",[NSThread currentThread]);
    }
}

iOS 线程同步方案性能比较

性能从高到低排序

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

其中递归锁的效率最差，不推荐使用，推荐使用的是：dispatch_queue(DISPATCH_QUEUE_SERIAL) 和 pthread_mutex

自旋锁与互斥锁对比

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

atomic

atomic 一般在Mac上用，在iOS上基本上不用，给属性加上atomic属性，可以保证属性的 setter 和 getter 都是原子性操作，相当于在 getter 和 setter 内部增加了线程同步的锁，但仅限于 setter 和 getter 内部
可以参考源码 objc4 的 objc-accesstors.mm
atomic 很耗性能，因此不常用，如果真的需要加锁，在外面使用的时候加锁。

iOS读写安全方案

IO操作，即文件操作
- 1.从文件中读取内容
- 2.往文件中写入内容，和读取不能同时进行

思考如何实现以下场景

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

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

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

pthread_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_destroy(&lock);

pthread_rwlock例子如下：

#import "SecondViewController.h"
#import >
@interface SecondViewController ()
@property (nonatomic, assign) pthread_rwlock_t lock;
@end

@implementation SecondViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    pthread_rwlock_init(&_lock,NULL);
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 10; i++)
    {
        dispatch_async(queue, ^{
            [self read];
        });
        
        dispatch_async(queue, ^{
            [self write];
        });
    }
}

- (void)read
{
    pthread_rwlock_rdlock(&_lock);
    NSLog(@"%s",__func__);
    pthread_rwlock_unlock(&_lock);
}

- (void)write
{
    pthread_rwlock_wrlock(&_lock);
    NSLog(@"%s",__func__);
    pthread_rwlock_wrlock(&_lock);
}
@end

dispatch_barrier_async用法

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

#import "ThirdViewController.h"

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

@implementation ThirdViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    self.queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i < 10; i++)
    {
        [self read];
        [self read];
        [self read];
        [self write];
    }
}

- (void)read
{
    dispatch_async(_queue, ^{
        NSLog(@"read");
    });
}

- (void)write
{
    dispatch_barrier_sync(_queue, ^{
        NSLog(@"write");
    });
}
@end

GUNStep

GNUStep是GNU计划的项目之一，它将Cocoa的OC库重新开源实现了一遍，其里面有runloop、runtime等不开源代码的实现方式
源码地址：http://www.gnustep.org/resources/downloads.php
虽然GNUStep不是苹果官方源码，但还是具有一定的参考价值