Objective-C 中各种锁的使用与区别

飞猪666
1,658 阅读6分钟

简介

OC 中锁的类型有以下10种：

  • OSSpinLock
  • os_unfair_lock
  • pthread_metex
  • dispatch_semaphore
  • dispatch_queue(DISPATCH_QUEUE_SERIAL)
  • NSLock
  • NSRecursiveLock
  • NSCondition
  • NSConditionLock
  • @synchronized

下面就讲解一下这些锁如何使用，以及各自的特点。

OSSpinLock

OSSpinLock叫做自旋锁，等待锁的线程会处于忙等(busy-wait)的状态, 一直占用CPU的资源。

  • 目前已经不安全(iOS10 之后废弃了)，可能会出现优先级反转的问题。
    • 优先级反转：如果等待锁的线程优先级较高，会一直占用CPU的资源，优先级低的线程一直无法释放锁。(造成死锁的现象)
  • 使用OSSpinLock需要导入头文件import <libkern/OSAtomic.h>

简单使用：

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

os_unfair_lock

  • os_unfair_lock 用于取代OSSpinLock从iOS10开始才支持。
  • 从底层调用看，等待os_unfair_lock的线程会进入休眠状态，并非忙等。
  • 需要导入头文件import <os/lock.h>

简单使用：

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

pthread_mutex

pthread_mutex叫做互斥锁，等待锁的线程会进入休眠状态。

使用需要导入import <pthread>

简单使用:

// 初始化锁的属性
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);
// 销毁相关资源
pthread_mutex_destroy(&mutex);

相关宏：

/*
 * Mutex type attributes
 */
#define PTHREAD_MUTEX_NORMAL		0  // 常规锁。
#define PTHREAD_MUTEX_ERRORCHECK	1  // 错误检查锁
#define PTHREAD_MUTEX_RECURSIVE		2  // 递归锁
#define PTHREAD_MUTEX_DEFAULT		PTHREAD_MUTEX_NORMAL  //默认为normal

递归锁：同一条线程可以多次加锁。最后依次解锁。

pthread_cond_t 条件

// 初始化锁
pthread_mutex_t mutex;
// NULL 代表使用默认属性
pthread_mutex_init(&mutex, NULL);
// 初始化条件
pthread_cond_t condition;
pthread_cond_init(&condition, NULL);
// 等待条件
pthread_cond_wait(&condition, &mutex);
// 激活一个等待条件的线程
pthread_cond_signal(&condition);
// 激活所有等待条件的线程
pthread_cond_broadcast(&condition);
// 销毁资源
pthread_mutex_destroy(&mutex);
pthread_cond_destory(&condition);

NSLock 和 NSRecursiveLock

NSLock是对mutex普通锁的封装。更加面向对象。

API 定义

@interface NSLock : NSObject <NSLocking> {
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit; // 在limit时间内尝试加锁，失败返回NO,成功返回YES
@end

@protocol NSLocking
- (void)lock;
- (void)unlock;
@end

简单使用：

// 初始化
NSLock lock = [[NSLock alloc] init];;
// 加锁
[lock lock];
// 解锁
[lock unlock];
// 尝试加锁
BOOL result = [lock tryLock];

NSRecursiveLock是对mutex递归锁的封装。 API和NSLock基本一致。

NSCondition

NSCondition是对mutex和cond的封装, 更加面向对象。

API定义:

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

@protocol NSLocking
- (void)lock;
- (void)unlock;
@end

示例：

#import "NSConditionDemo.h"

@interface NSConditionDemo()
@property (strong, nonatomic) NSCondition *condition;
@property (strong, nonatomic) NSMutableArray *data;
@end

@implementation NSConditionDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.condition = [[NSCondition alloc] init];
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式

// 线程1
// 删除数组中的元素
- (void)__remove
{
    [self.condition lock];
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待
        [self.condition wait];
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    [self.condition unlock];
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    [self.condition lock];
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    
    // 信号
    [self.condition signal];
    sleep(2);
    [self.condition unlock];
}
@end

NSConditionLock

NSConditionLock是对NSCondition的进一步的封装。可以设置具体的条件值。(可用于保证任务按顺序执行)

API定义

@interface NSConditionLock : NSObject <NSLocking> {

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

// 当满足条件时加锁
- (void)lockWhenCondition:(NSInteger)condition;
//尝试加锁
- (BOOL)tryLock;
// 满足条件时尝试加锁
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
// 解锁并给下一次加锁指定条件
- (void)unlockWithCondition:(NSInteger)condition;
// 在指定时间内尝试获得锁，超时返回false
- (BOOL)lockBeforeDate:(NSDate *)limit;
// 在指定时间内尝试获得某个条件的锁，超时返回false
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

@end

使用：

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one
{
    [self.conditionLock lock];
    
    NSLog(@"__one");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    
    NSLog(@"__three");
    
    [self.conditionLock unlock];
}

@end

dispatch_semaphore

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

简单使用：

// 创建信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

// 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
// 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
// 让信号量的值+1
dispatch_semaphore_signal(self.semaphore);

#import "SemaphoreDemo.h"

@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@end

@implementation SemaphoreDemo

- (instancetype)init
{
    if (self = [super init]) {
    	// 同时可允许5条线程访问资源
        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];
    }
}

// 线程10、7、6、9、8
- (void)test
{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    
    sleep(2);
    NSLog(@"test - %@", [NSThread currentThread]);
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphore);
}
@end

dispatch_queue(DISPATCH_QUEUE_SERIAL) 串行队列

直接使用GCD的串行队列，也是可以实现线程同步的。(串行队列，同一时间只能有一个任务在执行)

dispatch_queue_t queue = dispatch_queue_create("lockQueue", DISPATCH_QUEUE_SERIAL);

dispatch_sync(self.moneyQueue, ^{
     // 任务
});

@synchronized

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

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

使用：

@synchronized(obj) { 
     // 任务
}

iOS线程同步方案性能比较

性能从高到低排序

  • os_unfair_lock
  • OSSpinLock
  • dispatch_semaphore
  • pthread_mutex // 普通锁
  • dispatch_queue(DISPATCH_QUEUE_SERIAL)
  • NSLock
  • NSCondition
  • pthread_mutex(recursive) // 递归锁
  • NSRecursiveLock
  • NSConditionLock
  • @synchronized

日常推荐使用os_unfair_lock、dispatch_semaphore、pthread_mutex(普通锁)

自旋锁和互斥锁的比较

  1. 两者区别？
  • 等待锁的线程是忙等还是休眠。自旋锁是忙等，互斥锁是休眠(调用内核级别的函数)。
  1. 什么情况使用自旋锁比较划算？
  • 预计线程等待锁的时间很短
  • 加锁的代码（临界区）经常被调用，但竞争情况很少发生。
  • CPU资源不紧张(自旋锁会一直占用CPU)
  • 多核处理器
  1. 什么情况使用互斥锁比较划算？
  • 预计线程等待锁的时间较长
  • 单核处理器
  • 临界区有IO操作
  • 临界区代码复杂或者循环量大
  • 临界区竞争非常激烈

备注：临界区指的是相互竞争的资源。

atomic

atomic 用于保证属性setter、getter的原子性操作，相当于在getter和setter里面加了线程同步的锁。但是这样并不能保证使用属性的过程是线程安全的。

iOS中的读写安全方案

思考如何实现以下场景

  • 同一时间，只能有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)

dispatch_barrier_async

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

dispatch_queue_t queue = dispatch_queue_create("com.longchi", DISPATCH_QUEUE_CONCURRENT);  // 并发队列

dispatch_async(queue, ^{
	// 读
});

dispatch_barrier_async(queue, ^{
	// 写
});

Demo 代码

参考

  1. GNUstep : GNUstep是GNU计划的项目之一，它将Cocoa的OC库重新开源实现了一遍,虽然GNUstep不是苹果官方源码，但还是具有一定的参考价值.
  2. MJ 底层班
avatar
文章
阅读
粉丝