OSSpinLock
NSString *phoneVersion = [UIDevice currentDevice].systemVersion;
if (phoneVersion.floatValue >= 10.0) {
// 线程1
__block os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"准备上锁1");
if (os_unfair_lock_trylock(&lock)) { // 尝试加锁 可以加锁则立即加锁并返回YES,反之返回NO
// 这里顺便提一下trylock和lock使用场景:
// 当前线程锁失败,也可以继续其它任务,用 trylock 合适
// 当前线程只有锁成功后,才会做一些有意义的工作,那就 lock,没必要轮询 trylock
}
os_unfair_lock_lock(&lock); // 加锁
os_unfair_lock_unlock(&lock); // 解锁
});
}else {
// 线程1
__block OSSpinLock lock = OS_SPINLOCK_INIT;
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"准备上锁1");
if (OSSpinLockTry(&lock)) { // 尝试加锁
// 这里顺便提一下trylock和lock使用场景:
// 当前线程锁失败,也可以继续其它任务,用 trylock 合适
// 当前线程只有锁成功后,才会做一些有意义的工作,那就 lock,没必要轮询 trylock
}
OSSpinLockLock(&lock); // 加锁
OSSpinLockUnlock(&lock); // 解锁
});
}
- 如果一个低优先级的线程获得锁并访问共享资源,这时一个高优先级的线程也尝试获得这个锁,它会处于
spin lock
的忙等状态从而占用大量CPU
。此时低优先级线程无法与高优先级线程争夺CPU
时间,从而导致任务迟迟完不成、无法释放lock
。这并不只是理论上的问题,libobjc
已经遇到了很多次这个问题了,于是苹果的工程师停用了OSSpinLock
。
dispatch_semaphore_t 信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(10); // 传入的值必须大于等于0,若传入0则阻塞线程并等待timeout,时间到后会执行其后的语句
dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3.0f * NSEC_PER_SEC);
// 线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
dispatch_semaphore_wait(semaphore, overTime); // signal值 +1
NSLog(@"执行耗时操作");
dispatch_semaphore_signal(semaphore); // signal值 -1
});
关于信号量,我们可以用停车来比喻:
- 停车场剩余4个车位,那么即使同时来了四辆车也能停的下。如果此时来了五辆车,那么就有一辆需要等待。
- 信号量的值
(signal)
就相当于剩余车位的数目,dispatch_semaphore_wait
函数就相当于来了一辆车,dispatch_semaphore_signal
就相当于走了一辆车。停车位的剩余数目在初始化的时候就已经指明了(dispatch_semaphore_create(long value))
,调用一次dispatch_semaphore_signal
,剩余的车位就增加一个;调用一次dispatch_semaphore_wait
剩余车位就减少一个;当剩余车位为 0 时,再来车(即调用 dispatch_semaphore_wait)
就只能等待。有可能同时有几辆车等待一个停车位。有些车主没有耐心,给自己设定了一段等待时间,这段时间内等不到停车位就走了,如果等到了就开进去停车。而有些车主就像把车停在这,所以就一直等下去。
pthread_mutex 互斥锁 需要引入头文件
static pthread_mutex_t pLock;
pthread_mutex_init(&pLock, NULL);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
pthread_mutex_lock(&pLock); // 加锁
sleep(3); // 模拟耗时
pthread_mutex_unlock(&pLock); // 解锁
});
pthread_mutex(recursive) 递归锁
static pthread_mutex_t pLock2;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr); // 初始化attr并且给它赋予默认
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); // 设置锁类型,这边是设置为递归锁
pthread_mutex_init(&pLock2, &attr);
pthread_mutexattr_destroy(&attr); // 销毁一个属性对象,在重新进行初始化之前该结构不能重新使用
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void (^RecursiveBlock)(int);
RecursiveBlock = ^(int value) {
pthread_mutex_lock(&pLock2);
if (value > 0) {
NSLog(@"value : %d",value);
RecursiveBlock(value - 1);
}
pthread_mutex_unlock(&pLock2);
};
RecursiveBlock(5);
});
NSLock 普通锁
NSLock *lock = [[NSLock alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[lock lock]; // 加锁
[lock unlock]; // 解锁
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 尝试加速
BOOL x = [lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:4]];
if (x) {
[lock unlock];
}else {
NSLog(@"失败");
}
});
NSCondition
NSCondition *cLock = [[NSCondition alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[cLock lock]; // 加锁
[cLock waitUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]]; // 线程等待两秒
[cLock wait]; // 线程等待
[cLock signal]; // 唤醒一个等待的线程
[cLock broadcast]; // 唤醒所有等待的线程
[cLock unlock]; // 解锁
});
NSRecursiveLock 递归锁
NSRecursiveLock *rLock = [[NSRecursiveLock alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void(^RecursiveBlock)(int);
RecursiveBlock = ^(int value){
[rLock tryLock];
if (value > 0) {
RecursiveBlock(value - 1);
}
[rLock unlock];
};
RecursiveBlock(4);
});
@synchronized 条件锁
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
@synchronized (self) {
sleep(2);
NSLog(@"@synchronized线程");
}
});
NSConditionLock 条件锁
NSConditionLock *cLock2 = [[NSConditionLock alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
if ([cLock2 tryLockWhenCondition:0]) {
NSLog(@"NSConditionLock线程1");
[cLock2 unlockWithCondition:1];
} else {
NSLog(@"失败");
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
if ([cLock2 tryLockWhenCondition:3]) {
// [cLock2 lockWhenCondition:3];
NSLog(@"NSConditionLock线程2");
[cLock2 unlockWithCondition:2];
} else {
NSLog(@"失败");
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
if ([cLock2 tryLockWhenCondition:1]) {
NSLog(@"NSConditionLock线程3");
[cLock2 unlockWithCondition:3];
}
});
- 我们在初始化
NSConditionLock
对象时,给了他的标示为 0- 执行
tryLockWhenCondition:
时,我们传入的条件标示也是 0,所 以线程1 加锁成功- 执行
unlockWithCondition:
时,这时候会把condition
由 0 修改为 1- 因为
condition
修改为了 1, 会先走到 线程3,然后 线程3 又将condition
修改为 3- 最后 走了 线程2 的流程
- 从上面的结果我们可以发现,
NSConditionLock
还可以实现任务之间的依赖。