当前位置： 移动技术网 > 移动技术>移动开发>IOS > iOS 多线程安全方案

iOS 多线程安全方案

2020年07月29日  | 移动技术网移动技术  | 我要评论

文件读写安全方案

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

多读单写

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

读写锁 -> 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条线程访问资源，保证线程同步
image.png

dispatch_queue(DISPATCH_QUEUE_SERIAL)

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

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.本文如有侵犯隐私或其他请联系我，我将在第一时间整改或删除。

本文地址：https://blog.csdn.net/qq_35734499/article/details/107637403

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网