iOS的各种锁

2018-09-11  本文已影响19人  只敲代码不偷桃

本文主要是一个对各种锁的简单整理，方便后续查看回顾，毕竟锁在实际项目中用的比较少，再牛逼的知识点，老不用也记不住。好记性不如烂笔头。

说到锁肯定是涉及多线程了，所以先简单的介绍一下iOS里的多线程GCD。
先介绍几个比较容易混淆的术语：

各种队列的执行效果

并发队列 手动创建的串行队列 主队列
同步（sync） 没有开启新的线程；串行执行任务 没有开启新的线程；串行执行任务 没有开启新的线程；串行执行任务
异步（async） 有开启新的线程；并发执行任务 有开启新的线程；串行执行任务 没有开启新的线程；串行执行任务

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

队列组的使用

使用GCD实现：异步并发执行任务1、任务2。等任务1和2执行完之后，回到主线程执行任务3

dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_async(group, queue, ^{
        NSLog(@"执行任务一");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"执行任务二");
    });
    dispatch_group_notify(group, queue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"回到主线程执行任务三");
        });
    });

多线程的安全隐患：

iOS中的线程同步方案

GNUstep

1. OSSpinLock

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

2. os_unfair_lock

    // 初始化
    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);

3. pthread_mutex

    // 初始化锁的属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
    // 初始化锁
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, &attr);
    
    // 注意 如果属性值传NULL，则属性的默认值为上面的代码
    <!--pthread_mutex_init(&mutex, NULL);-->
    
    // 尝试加锁
    pthread_mutex_trylock(&mutex);
    // 加锁
    pthread_mutex_lock(&mutex);
    // 解锁
    pthread_mutex_unlock(&mutex);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
    // 销毁锁
    pthread_mutex_destroy(&mutex);

pthread_mutex递归锁

// 初始化锁的属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    // 初始化锁
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, &attr);

pthread_mutex条件锁

    // 初始化锁 NULL代表使用默认属性
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL);
    // 初始化条件
    pthread_cond_t condition;
    pthread_cond_init(&condition, NULL);
    // 等待条件（进入休眠，放开mutex锁，被唤醒后，会再次对mutex加锁）
    pthread_cond_wait(&condition, &mutex);
    // 激活一个等待该条件的线程
    pthread_cond_signal(&condition);
    // 激活所有等待该条件的线程
    pthread_cond_broadcast(&condition);
    // 销毁资源
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&condition);

4. dispatch_semaphore

    // 初始化信号量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    // 如果信号量的值 <= 0，当前线程就会进入休眠等待（直到信号量的值 > 0）
    // 如果信号量的值 > 0，就减1，然后往下执行后面的代码
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    // 让信号量的值加1
    dispatch_semaphore_signal(semaphore);

5. dispatch_queue(DISPATCH_QUEUE_SERIAL)

dispatch_queue_t queue = dispatch_queue_create("lock_queue", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        // 任务
    });

6. NSLock

- (void)lock;
- (void)unlock;
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

7. NSRecursiveLock

8. NSCondition

- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

9. NSConditionLock

- (instancetype)initWithCondition:(NSInteger)condition NS_DESIGNATED_INITIALIZER;

@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;

10. @synchronized

@synchronized(obj) {
    // 任务
}

iOS线程同步方案性能大比拼 (从高到低)

自旋锁与互斥锁的比较

什么时候用自旋锁比较划算？

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

注意：苹果其实不推荐使用自旋锁

atomic

iOS中的读写安全方案

应用场景：

对于上面的“多读单写”，经常用于文件等数据的读写操作，iOS中有两种方案：

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);

dispatch_barrier_async

     // 初始化队列
    dispatch_queue_t queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
    // 读
    dispatch_async(queue, ^{
        
    });
    
    // 写
    dispatch_barrier_async(queue, ^{
        
    });
上一篇 下一篇

猜你喜欢

热点阅读