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 互斥锁 需要引入头文件 <pthread.h>
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还可以实现任务之间的依赖。
