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