iOS 锁

临界区

指的是一块对公共资源进行访问的代码，并非一种机制或是算法

自旋锁

是用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。

互斥锁

是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区而达成。

读写锁

计算机程序的并发控制的一种同步机制，也称“共享-互斥锁”、多读者-单写者锁) 用于解决多线程对公共资源读写问题。读操作可并发重入，写操作是互斥的。读写锁通常用互斥锁、条件变量、信号量实现。

信号量

更高级的同步机制，互斥锁可以说是semaphore在仅取值0/1时的特例。信号量可以有更多的取值空间，用来实现更加复杂的同步，而不单单是线程间互斥。

条件锁

进程的某些资源不满足进入休眠，满足了（条件锁打开）才继续运行

自旋锁

os_unfair_lock

os_unfair_lock_t unfairLock;
unfairLock = &(OS_UNFAIR_LOCK_INIT);
os_unfair_lock_lock(unfairLock);
os_unfair_lock_unlock(unfairLock);

os_unfair_lock是苹果官方推荐的替换OSSpinLock的方案，但是在iOS10.0以上的系统才可以调用

需要导入 #import <os/lock.h>

互斥锁

NSLock

Foundation框架中以对象形式暴露的一种锁，（Foundation框架同时提供了NSConditionLock，NSRecursiveLock，NSCondition）定义如下：

@protocol NSLocking
- (void)lock;
- (void)unlock;
@end
@interface NSLock : NSObject <NSLocking> {
@private
    void *_priv;
}
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;
@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));
@end

tryLock 和lock 方法都会请求加锁，唯一不同的是trylock在没有获得锁的时候可以继续做一些任务和处理。lockBeforeDate方法也比较简单，就是在limit时间点之前获得锁，没有拿到返回NO

pthread_mutex

使用方式如下
�```
// 互斥锁
void init() {
pthread_mutex_init(&mutex, NULL);
}

(void) initMutex {
pthread_once(&once, init);
dispatch_async(dispatch_get_main_queue(), ^{
pthread_mutex_lock(&mutex);
NSLog(@"这里加锁了，5秒后解锁");
sleep(5);
pthread_mutex_unlock(&mutex);
});
dispatch_async(dispatch_get_main_queue(), ^{
pthread_mutex_lock(&mutex);
NSLog(@"5秒后解锁了");
pthread_mutex_unlock(&mutex);
});
}


###### @synchronized
使用方法

(void)initSynchornized {
[self synchornizedA];
[self synchornizedB];
[self synchornizedC];
// 先执行完A 再执行B 再执行C
}
(void) synchornizedA {
@synchronized (self) {
sleep(1);
NSLog(@"@synchronized 1");
}
}
(void) synchornizedB {
@synchronized (self) {
sleep(2);
NSLog(@"@synchronized 2");
}
}
(void) synchornizedC {
@synchronized (self) {
sleep(3);
NSLog(@"@synchronized 3");
}
}


##### 读写锁
###### pthread_rwlock

__block pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);

dispatch_async(dispatch_get_main_queue(), ^{
    sleep(1);
    NSLog(@"线程0：加锁");
    pthread_rwlock_rdlock(&rwlock);
    NSLog(@"线程0：读");
    pthread_rwlock_unlock(&rwlock);
    NSLog(@"线程0：解锁");
});
dispatch_async(dispatch_get_main_queue(), ^{
    sleep(3);
    NSLog(@"线程0：加锁");
    pthread_rwlock_rdlock(&rwlock);
    NSLog(@"线程0：读");
    pthread_rwlock_unlock(&rwlock);
    NSLog(@"线程0：解锁");
});


##### 信号量
###### dispatch_semaphore
可以通过信号量控制异步线程  执行时间

/**
等待时间选FORVER,如果选NOW,
*/
__block dispatch_semaphore_t _semaphore_t = dispatch_semaphore_create(1);

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    long aaa =  dispatch_semaphore_wait(_semaphore_t, DISPATCH_TIME_FOREVER);
    NSLog(@"消耗一个时间变量%ld",aaa);
    
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    long aaa = dispatch_semaphore_wait(_semaphore_t, DISPATCH_TIME_FOREVER);
    NSLog(@"没有时间变量就不执行%ld", aaa);
    
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    long aaa = dispatch_semaphore_wait(_semaphore_t, DISPATCH_TIME_FOREVER);
    NSLog(@"没有时间变量就不执行%ld",aaa);
});

for (NSNumber *a in @[@1,@2,@3]) {
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)([a intValue] * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        dispatch_semaphore_signal(_semaphore_t);
    });
}


##### 条件锁
###### NSCondition

NSCondition *condition = [[NSCondition alloc] init];
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [condition lock];
    NSLog(@"延时执行的第一步");
    sleep(3);
    [condition unlock];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    [condition lock];
    NSLog(@"延时执行第二部");
    
    // 等待
    [condition wait];
    // 无需等待
    [condition signal];
    
    [condition unlock];
});

###### NSConditionLock



##### 递归锁
1. NSRecursiveLock