文件读写安全方案

本质就是多读单写，单位时间内读写操作只允许存在一种。

多读单写

同一时间，只能有一个线程进行写的操作。

同一时间，允许有多个线程进行读的操作。

同一时间，不允许既有写的操作，又有读的操作。

读写锁 -> pthread_rwlock

读写锁使用起来非常简单，属于互斥锁，等待锁的线程会进入休眠。

导入
#import <pthread.h>

声明
@property (assign, nonatomic) pthread_rwlock_t lock;

初始化锁
pthread_rwlock_init(&_lock, NULL);

读取操作的加锁
pthread_rwlock_rdlock(&_lock);

写入操作的加锁
pthread_rwlock_wrlock(&_lock);

读取和写入共用一种解锁
pthread_rwlock_unlock(&_lock);

dealloc方法中销毁锁
pthread_rwlock_destroy(&_lock);
复制代码

异步栅栏调用 -> dispatch_barrier_async

这个函数传入的并发队列必须是通过 dispatch_ queue_ create创建的。

声明
@property (strong, nonatomic) dispatch_queue_t queue;

初始化锁
self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);

读取操作的加锁
dispatch_async(self.queue, ^{
    [self read];
});

写入操作的加锁
dispatch_barrier_async(self.queue, ^{
    [self write];
});
复制代码

线程同步安全方案

OSSpinLock

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

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

导入
#import <libkern/OSAtomic.h>

声明
@property (assign, nonatomic) OSSpinLock lock;

初始化锁
self.lock = OS_SPINLOCK_INIT;

加锁
OSSpinLockLock(&_lock);

解锁
OSSpinLockUnlock(&_lock);
复制代码

os_unfair_lock

os_unfair_lock用于取代不安全的OSSpinLock，从iOS10开始オ支持。

导入
#import <os/lock.h>

声明
@property (assign, nonatomic) os_unfair_lock moneyLock;

初始化锁
self.moneyLock = OS_UNFAIR_LOCK_INIT;

加锁
os_unfair_lock_lock(&_moneyLock);

解锁
os_unfair_lock_unlock(&_moneyLock);
复制代码

pthread_mutex

多个平台使用的互斥锁。 可以作为普通锁，递归锁，或者条件锁。

dispatch_semaphore

semaphore叫做”信号量”。

信号量的初始值，可以用来控制线程并发访问的最大数量。

信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步。

dispatch_queue(DISPATCH_QUEUE_SERIAL)

线程同步的本质是不让多个线程同时访问同一个资源，只要按顺序访问资源就行，所以直接使用GCD的串行队列，也是可以实现线程同步的。

NSLock

NSLock是对pthread_mutex普通互斥锁进行了面向对象的封装。

NSRecursiveLock

NSRecursiveLock是对pthread_mutex递归互斥锁进行了面向对象的封装。

NSCondition

NSCondition是对pthread_mutex条件互斥锁进行了面向对象的封装，没有条件具体值。

NSConditionLock

NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值，使线程按照指定顺序执行。

@synchronized

@synchronized是对mutex递归锁的封装。

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

实现方式最简单，但是性能最差，不推荐使用。

同步方案性能从高到低排序

os_unfair_lock

OSSpinLock

dispatch_semaphore

pthread_mutex

dispatch_queue(DISPATCH_QUEUE_SERIAL)

NSLock

NSCondition

pthread_mutex(recursive)

NSRecursiveLock

NSConditionLock

@synchronized

什么情况使用自旋锁?

1> 预计线程等待锁的时间很短

2> 加锁的代码经常被调用,但多个线程竞争情况很少发生

3> CPU源不紧张

4> 多核处理器

什么情况使用互斥锁?

1> 预计线程等待锁的时间较长

2> 单核处理器

3> 加锁的代码有IO操作

4> 加锁的代码代码复杂或者循环量大

5> 加锁的代码竟争非常激烈

自旋锁和互斥锁的区别

自旋锁等待的时候，会忙等，消耗CPU。

互斥锁等待的时候，会休眠，不消耗CPU。

补充

1.ios的自旋锁从10开始被禁用了，现在都是互斥锁。

2.使用pthread_mutex需要导入#import <pthread.h>

3.推荐优先使用os_unfair_lock，dispatch_semaphore，pthread_mutex这三种锁。

4.本文如有侵犯隐私或其他请联系我，我将在第一时间整改或删除。