多线程的安全隐患
资源共享
一块资源可能被多个线程共享，也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题
两个经典的例子
存钱取钱
卖票
死锁
什么是死锁？
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。
死锁产生的4个必要条件？
互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程–资源的环形链。
解除死锁:
当发现有进程死锁后，便应立即把它从死锁状态中解脱出来，常采用的方法有：
剥夺资源：从其它进程剥夺足够数量的资源给死锁进程，以解除死锁状态；
撤消进程：可以直接撤消死锁进程或撤消代价最小的进程，直至有足够的资源可用，死锁状态消除为止；所谓代价是指优先级、运行代价、进程的重要性和价值等。
更多学习关于死锁：
死锁面试题（什么是死锁，产生死锁的原因及必要条件）
#import "ViewController.h"
@interface ViewController ()
@property (assign, nonatomic) int ticketsCount;
@property (assign, nonatomic) int money;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
}
- (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(0.3);
oldMoney += 50;
self.money = oldMoney;
NSLog(@"存50，还剩%d元--%@", self.money, [NSThread currentThread]);
}
- (void)drawMoney
{
int oldMoney = self.money;
sleep(0.3);
oldMoney -= 20;
self.money = oldMoney;
NSLog(@"取20，还剩%d元--%@", self.money, [NSThread currentThread]);
}
- (void)saleTicket
{
sleep(1.2);
self.ticketsCount--;
NSLog(@"还剩%d张票--%@", self.ticketsCount, [NSThread currentThread]);
}
- (void)saleTickets
{
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];
}
});
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
// [self saleTickets];
[self moneyTest];
}
@end
多线程安全隐患的解决方案
使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）
常见的线程同步技术是： 加锁
iOS中的线程同步方案
OSSpinLock
os_unfair_lock
pthread_mutex
dispatch_semaphore
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock
NSRecursiveLock
NSCondition
NSConditionLock
@synchronized
OSSpinLock
spin：旋转；
lock：锁。
OSSpinLock叫做”自旋锁“。等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源。
OSSpinLock使用方法：
导入头文件
#import <libkern/OSAtomic.h>
将OSSpinLock全局拥有
@property (assign, nonatomic) OSSpinLock lock;
//初始化锁
self.lock = OS_SPINLOCK_INIT;
//加锁
OSSpinLockLock(&_lock);
//尝试加锁
if (OSSpinLockTry(&_lock)) {
//做任务
OSSpinLockUnlock(&_lock);
}
//解锁
OSSpinLockUnlock(&_lock);
OSSpinkLock目前已经不再安全，可能会出现优先级反转问题
如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁
不建议使用
os_unfair_lock
os_unfair_lock用于取代不安全的OSSpinLock，从iOS10开始支持
从底层调用来看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等。
os_unfair_lock的使用方法：
导入头文件
#import <os/lock.h>
//初始化锁
self.moneyLock = OS_UNFAIR_LOCK_INIT;
//加锁
os_unfair_lock_lock(&_moneyLock);
//解锁
os_unfair_lock_unlock(&_moneyLock);
pthread_mutex
mutex：互斥。等待锁的线程会处于休眠状态
pthread_mutex的使用方法：
- (void)__initMutex:(pthread_mutex_t *)mutex
{
//静态初始化锁
// pthread_mutex_t moneyLock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutexattr_t attr;
//初始化属性
pthread_mutexattr_init(&attr);
pthread_mutexattr_setprotocol(&attr, PTHREAD_MUTEX_NORMAL);
//初始化锁
pthread_mutex_init(mutex, &attr);
//销毁属性
pthread_mutexattr_destroy(&attr);
}
其中，pthread_mutexattr_setprotocol的第二个参数的代表含义：
#define PTHREAD_MUTEX_NORMAL 0//普通锁
#define PTHREAD_MUTEX_ERRORCHECK 1//错误锁，一般用不到
#define PTHREAD_MUTEX_RECURSIVE 2//递归锁
#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL//默认锁=普通锁常
//加锁
pthread_mutex_lock(&_moneyLock);
//解锁
pthread_mutex_unlock(&_moneyLock);
- (void)dealloc
{
//销毁锁
pthread_mutex_destroy(&_moneyLock);
pthread_mutex_destroy(&_ticketLock);
}
需要注意的是：
不能这样赋值，这是因为：
define PTHREAD_MUTEX_INITIALIZER {_PTHREAD_MUTEX_SIG_init, {0}}
PTHREAD_MUTEX_INITIALIZER是一个结构体，结构体只能在创建的时候初始化，不能在后面赋值。
也就是pthread_mutex_t moneyLock = PTHREAD_MUTEX_INITIALIZER;是可以这样写的。
当调用递归函数，而递归函数里面有锁的情况下，我们需要使用PTHREAD_MUTEX_RECURSIVE递归锁即可满足要求。
递归锁，允许同一个线程，对同一把锁进行重复加锁。
pthread_mutex-条件
NSLock和NSRecursiveLock
NSLock其实是对mutex的普通锁的一种封装
NSLock的使用方法：
//锁成为属性
@property (strong, nonatomic) NSLock *moneyLock;
//初始化锁
self.moneyLock = [[NSLock alloc] init];
//加锁
[self.moneyLock lock];
//解锁
[self.moneyLock unlock];
//尝试加锁
- (BOOL)tryLock;
//在limit时间前，一直等待休眠，一旦在这个时间前加锁成功，则返回YES；超过limit时间则加锁失败返回NO
- (BOOL)lockBeforeDate:(NSDate *)limit;
NSRecursiveLock是对mutex中的递归锁的封装。
Recursive：循环递归
NSCondition是对mutex和条件(conditon)的封装。
NSCondition可以实现:
一个数组，可以添加元素，也可以删除元素。两个方法同时执行，有可能是先删后加。而删的时候里面元素个数为0，可以做到删的时候，如果元素个数为0，则等待，然后执行加元素，等加完元素后，单个通知或者多个通知删除操作，再执行删元素操作。
具体源码可以参考GUNSteps。
NSconditonLock是对NSCondition的进一步封装
汇编下查看自旋锁 与 互斥锁
汇编下的lldb指令:
si = stepi = step instruction = 下一步 指令，可以做到汇编一条一条的过
nexti也可以让汇编一条一条的过
区别是：
nexti遇到函数会过函数，到函数下面的汇编
si遇到函数会进函数，到函数里面的汇编
自旋锁
自旋锁，一直重复执行5到13行的汇编，是一个while循环，循环着做事情，等待着锁的解开。
互斥锁
互斥锁，16看出，是psynch_mutexwait，是等待休眠。等着锁的解开。
一般来说，高级锁是循环，低级锁是休眠
也就是说，高级锁是自旋锁，低级锁是互斥锁。
线程同步： 即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多，临界区对象就是其中一种。
利用串行队列dispatch_queue_t实现线程同步
import “SerialQueueDemo.h”
@interface SerialQueueDemo()
@property (strong, nonatomic) dispatch_queue_t ticketQueue;
@property (strong, nonatomic) dispatch_queue_t moneyQueue;
@end
@implementation SerialQueueDemo
- (instancetype)init
{
if (self = [super init]) {
self.ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL);
self.moneyQueue = dispatch_queue_create("moneyQueue", DISPATCH_QUEUE_SERIAL);
}
return self;
}
- (void)__saveMoney
{
//加锁
dispatch_sync(self.moneyQueue, ^{
[super __saveMoney];
});
}
- (void)__drawMoney
{
//加锁
dispatch_sync(self.moneyQueue, ^{
[super __drawMoney];
});
}
- (void)__saleTicket
{
//加锁
dispatch_sync(self.ticketQueue, ^{
[super __saleTicket];
});
}
dispatch_semaphore 信号量
semaphore 信号量的意思
信号量的初始值，可以控制线程并发访问的最大数量。
信号量的初始值为1，代表同时只允许一条线程访问资源，保证线程同步。
过程很简单，就是在wait处，根据value的值，做-1操作。
如果value=5，100个线程任务，那么5条线程进去后信号量的值为0，再进去一条线程，信号量的值为-1，则等待。
前面进去的线程任务执行完毕后，到signal，信号量值+1，若信号量的值<=0，则通知wait等待的线程去执行任务。
最大接收5个。从而保证线程的最大并发数量。
@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@end
@implementation SemaphoreDemo
- (instancetype)init
{
if (self = [super init]) {
self.semaphore = dispatch_semaphore_create(5);
}
return self;
}
- (void)otherTest
{
for (int i = 0; i<20; i++) {
[[[NSThread alloc] initWithTarget:self selector:@selector(test) object:nil] start];
}
}
- (void)test
{
//DISPATCH_TIME_FOREVER，永远等待
//DISPATCH_TIME_NOW 不等
dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
sleep(2);
NSLog(@"test - %@", [NSThread currentThread]);
dispatch_semaphore_signal(self.semaphore);
}
synchronized同步
synchronized是对mutex递归锁的封装
- (void)__saveMoney
{
@synchronized (self) {
[super __saveMoney];
}
}
- (void)__drawMoney
{
@synchronized (self) {
[super __drawMoney];
}
}
- (void)__saleTicket
{
@synchronized (self) {
[super __saleTicket];
}
}
iOS线程同步方案性能比较
性能从高到低排序
os_unfair_lock
OSSpinLock
dispatch_semaphore
pthread_mutex
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock
NSCondition
pthread_mutex(recursive)
NSRecursiveLock
NSConditionLock
@synchronized
自旋锁、互斥锁比较
什么情况使用自旋锁比较划算？
- 预计线程等待锁的时间很短
- 加锁的代码(临界区)经常被调用，但竞争情况很少发生
- CPU资源不紧张
什么情况使用互斥锁比较划算
- 预计线程等待锁的时间较长
- 单核处理器
- 临界区有IO操作
- 临界区代码复杂或者循环量大
- 临界区竞争非常激烈
atomic
nonatomic和atomic
atomic：原子性
给属性加上atomic修饰，可以保证属性的setter和getter都是原子性操作，也就是说，保证setter和getter内部是线程同步的。
@property (assign, atomic) int age;
- (void)setAge:(int)age
{
//加锁操作
_age = age;
//解锁操作
}
- (int)age
{
//加锁操作
return _age;
//解锁操作
}
atomic并不能保证使用属性的过程是线程安全的
atomic加锁解锁太消耗性能，一般不使用
iOS中的读写安全方案
IO操作，也就是文件操作。
如何实现以下场景：
同一时间，只能有1个线程进行写的操作
同一时间，允许有多个线程进行读的操作
同一时间，不允许读和写的操作同时执行
上面的场景，就是典型的“多读单写”
经常应用于文件等数据的读写操作
iOS实现以上场景的方案有：
pthread_rwlock：读写锁
dispatch_barrier_async：异步栅栏调用
pthread_rwlock
等待锁的线程会进入休眠
pthread_rwlock使用方法：
举个例子:
#import <pthread.h>
@interface ViewController ()
@property (assign, nonatomic) pthread_rwlock_t lock;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
//初始化s锁
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);
sleep(0.3);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)write
{
pthread_rwlock_wrlock(&_lock);
sleep(1);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)dealloc
{
//销毁锁
pthread_rwlock_destroy(&_lock);
}
dispatch_barrier_async
dispatch_barrier_async注意事项：
dispatch_barrier_async这个函数传入的并发队列必须是自己通过dispatch_queue_create创建的
如果传入的是一个串行或者是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果
dispatch_barrier_async使用方法：
举个例子:
@interface ViewController ()
@property (strong, nonatomic) dispatch_queue_t queue;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i<10; i++) {
[self read];
[self read];
[self read];
[self write];
[self write];
[self write];
}
}
- (void)read
{
dispatch_async(self.queue, ^{
sleep(1);
NSLog(@"%s", __func__);
});
}
- (void)write
{
dispatch_barrier_async(self.queue, ^{
sleep(1);
NSLog(@"%s", __func__);
});
}