多线程的存在导致在不同线程执行任务存在了数据、操作的不安全性，称之为非原子性。为了解决开发遇到的线程不安全的现象，就要用到线程锁。分别有 @synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock，不同的锁有不同的使用场景和性能上的区别。

@synchronized

@synchronized(objc) 为开发中常用的锁，他以一个 objc 为锁的标示对象，在需要互斥的代码之间，这个 objc 必须为同一对象，不然，将达不到互斥的效果。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        @synchronized(self){
            NSLog(@"操作1开始");
            sleep(3);
            NSLog(@"操作1结束");
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        @synchronized(self){
            NSLog(@"操作2");
        }
    });

此段代码执行的结果为：

2018-08-15 15:14:48.387631+0800 Looks[4097:719747] 操作1开始
2018-08-15 15:14:51.391021+0800 Looks[4097:719747] 操作1结束
2018-08-15 15:14:51.391444+0800 Looks[4097:719750] 操作2

特点：简单易用，但性能最差。

dispatch_semaphore

GCD API 里面的信号量，也可以作为锁来使用，使用时搭配相关 API 使用。

dispatch_semaphore_t dispatch_semaphore_create(long value);

信号量的创建，value 为一个 long 类型的数，这里需要注意 value 应为非 0 的数，不然将起不到锁的效果。

long dispatch_semaphore_signal(dispatch_semaphore_t dsema);

这个函数会对 参数 dsema 的值加 1。

long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);

这个函数会对参数 dsema 的值减 1，该函数执行时当 dsema 的值大于0，不阻塞当前线程，执行后面操作，将 dsema 减1，当 dsema 等于 0 时，那么函数将会阻塞线程 timeout 时间，timeout 为 dispatch_time_t 类型，如果等待的期间 dsema 值被 dispatch_semaphore_signal 函数加了1，且获取到了信号量，那么线程将会执行大于0时的一样的操作，如果在等待且信号量没变且到了所设置的等待时间，那么将不再等待，执行后面操作。可设置 timeout 为 DISPATCH_TIME_FOREVER，这样将一直阻塞线程直到信号量改变。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC));
        NSLog(@"操作1开始");
        sleep(3);
        NSLog(@"操作1结束");
        dispatch_semaphore_signal(semaphore);
        
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        sleep(1);
        dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC));
        NSLog(@"操作2");
        dispatch_semaphore_signal(semaphore);
        
    });
    

以上代码 timeout > 2s 时，结果为：

2018-08-15 15:31:22.385087+0800 Looks[4411:738446] 操作1开始
2018-08-15 15:31:25.385388+0800 Looks[4411:738446] 操作1结束
2018-08-15 15:31:25.385653+0800 Looks[4411:738445] 操作2

如果 timeout < 2s 时，结果为：

2018-08-15 15:51:39.012859+0800 Looks[4632:759034] 操作1开始
2018-08-15 15:51:41.019446+0800 Looks[4632:759031] 操作2
2018-08-15 15:51:42.015130+0800 Looks[4632:759034] 操作1结束

特点：在不出现等待的情况下，性能最高。

NSLock

NSLock 也是我们经常用的一种锁。

- (void)lock;
- (void)unlock;

遵循了 NSLocking 协议，搭配的分别为锁和解锁。

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

tryLock：试图加锁并立即返回一个布尔值，该值指示尝试是否成功。如果返回 YES，加锁成功，反之失败。
lockBeforeDate：表示在指定时间之前加锁，如果到指定时间加锁成功，则返回 YES，加锁成功，反之失败。

    NSLock *lock = [NSLock new];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        if ([lock tryLock]) {
            NSLog(@"操作1开始");
            sleep(3);
            NSLog(@"操作1结束");
            [lock unlock];
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        if ([lock tryLock]) {
            NSLog(@"操作2");
            [lock unlock];
        }else{
            NSLog(@"tryLock 失败");
        }
        
        if ([lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:3]]) {
            NSLog(@"lockBeforeData 获取到锁");
            [lock unlock];
        }else{
            NSLog(@"lockBeforeData 超时,未获取到锁");
        }
        
    });
    

以上代码执行结果为：

2018-08-15 16:44:03.240428+0800 Looks[5079:796065] 操作1开始
2018-08-15 16:44:04.241003+0800 Looks[5079:796066] tryLock 失败
2018-08-15 16:44:06.241563+0800 Looks[5079:796065] 操作1结束
2018-08-15 16:44:06.242126+0800 Looks[5079:796066] lockBeforeData 获取到锁

特点：方便简单易用。

NSRecursiveLock （递归锁）

NSRecursiveLock 是常用在处理递归循环操作上的锁，所以叫递归锁。他可以处理同一个线程多次加锁，解锁而不会引起死锁。同样遵循 NSLocking 协议，API 和用法都和 NSLock 相同，不同的只有使用场景。

    NSRecursiveLock *recursiveLock = [NSRecursiveLock new];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        static void (^ RecursiveLock)(int);
        RecursiveLock = ^ (int value){
            
            [recursiveLock lock];
            if (value > 0) {
                NSLog(@"value is %d",value);
                sleep(1);
                value -= 1;
                RecursiveLock(value);
            }
            [recursiveLock unlock];
        };
        
        RecursiveLock(4);
    });

以上代码执行 lock 和 unlock 一一对应，在统一线程中递归加锁解锁，这就是 NSRecursiveLock 的使用场景，执行结果为：

2018-08-16 13:57:30.195998+0800 Looks[3695:302951] value is 4
2018-08-16 13:57:31.197983+0800 Looks[3695:302951] value is 3
2018-08-16 13:57:32.201241+0800 Looks[3695:302951] value is 2
2018-08-16 13:57:33.205673+0800 Looks[3695:302951] value is 1

特点：对同一线程多次加锁、解锁。递归循环条件下适用。

NSConditionLock (条件锁)

这种锁不仅具备了 lock 和 unlock 功能，还有在 lock 和 unlock 的条件操作功能，这也丰富了我们使用的选择和场景。

- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

和之前几个锁的 API 大同小异，唯一不同的就是多了一个参数 condition，这个参数就是我们要说的 lock 和 unlock 的条件， 当 lock 时 condition 的参数和初始化参数一致时，将不阻塞线程，进行加锁继续后续操作，反之，将阻塞线程。而 unlock 时，condition 则是将更改为实参的值，解锁完成操作或者为下一次个 lock 的 condition 做准备。

    NSConditionLock *conditionLock = [NSConditionLock new];
    NSMutableArray *array = [NSMutableArray new];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        while (YES) {
            [conditionLock lockWhenCondition:0];
            [array addObject:[NSString stringWithFormat:@"%d", arc4random() % 10]];
            NSLog(@"arry count is %lu",(unsigned long)array.count);
            [conditionLock unlockWithCondition:1];
            sleep(1);
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        while (YES) {
            NSLog(@"condition 不相同, wait....");
            [conditionLock lockWhenCondition:1];
            [array removeObjectAtIndex:0];
            NSLog(@"arry remove object at index for zero");
            [conditionLock unlockWithCondition:0];
            sleep(1);
        }
    });

以上代码执行结果为：

2018-08-16 14:19:09.390035+0800 Looks[4082:324058] arry count is 1
2018-08-16 14:19:09.390044+0800 Looks[4082:324059] condition 不相同, wait....
2018-08-16 14:19:09.390216+0800 Looks[4082:324059] arry remove object at index for zero
2018-08-16 14:19:10.391602+0800 Looks[4082:324059] condition 不相同, wait....
2018-08-16 14:19:10.391551+0800 Looks[4082:324058] arry count is 1
2018-08-16 14:19:10.391967+0800 Looks[4082:324059] arry remove object at index for zero

特点：当有加锁解锁条件时适用。

NSCondition

也是经常用且简单的一种锁，同样遵循 NSLocking 协议，实现了 lock 和 unlock 方法。

- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

wait：阻塞当前线程，让线程处于等待状态，直到有线程信号，在调用此方法时，锁必须是 lock 状态。
waitUntilDate：阻塞当前线程，让线程处于等待状态直到条件发出信号或达到指定的时间限制。在调用此方法时，锁必须是 lock 状态。
signal：信号条件，唤醒一个等待线程。可以使用此方法唤醒正在等待条件的一个线程。可以多次调用此方法以唤醒多个线程。如果没有线程在等待条件，这个方法什么也不做。
broadcast：信号条件，唤醒所有等待它的线程。如果没有线程在等待条件，这个方法什么也不做。

    NSCondition *codition = [NSCondition new];
    NSMutableArray *array = [NSMutableArray new];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        while (YES) {
            [codition lock];
            if (array.count == 0 ) {
                NSLog(@"wait ....");
                [codition wait];
            }
            [array removeObjectAtIndex:0];
            NSLog(@"array remove object index for zero");
            [codition unlock];
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        while (YES) {
            [codition lock];
            [array addObject:[NSString stringWithFormat:@"%d",arc4random() % 10]];
            NSLog(@"array count is %lu",(unsigned long)array.count);
            [codition signal];
            [codition unlock];
            sleep(1);
        }
    });

以上代码执行的结果为：

2018-08-16 15:26:09.625351+0800 Looks[5145:383490] wait ....
2018-08-16 15:26:09.625543+0800 Looks[5145:383492] array count is 1
2018-08-16 15:26:09.625729+0800 Looks[5145:383490] array remove object index for zero
2018-08-16 15:26:09.626445+0800 Looks[5145:383490] wait ....
2018-08-16 15:26:10.629679+0800 Looks[5145:383492] array count is 1
2018-08-16 15:26:10.630167+0800 Looks[5145:383490] array remove object index for zero

特点：类似于 GCD 的信号量，但更直观面向对象，有更强的 wait 和 signal 操作性。

pthread_mutex

c 语言定义下的线程锁，其他好多锁都是对他的封装，也是性能相对最高的一个。

int pthread_mutex_init(pthread_mutex_t * __restrict, const pthread_mutexattr_t * _Nullable __restrict);
int pthread_mutex_lock(pthread_mutex_t *);
int pthread_mutex_trylock(pthread_mutex_t *);
int pthread_mutex_unlock(pthread_mutex_t *);
int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
int pthread_mutexattr_destroy(pthread_mutexattr_t *) __DARWIN_ALIAS(pthread_mutexattr_destroy);

c 语言下提供了很多有关的操作 API，这里不多说，只列了常用这几个。

pthread_mutex_init：动态创建一个锁，第二个参数，NULL 为默认类型，一共用四种类型：

PTHREAD_MUTEX_NORMAL ：缺省类型，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后先进先出原则获得锁。
PTHREAD_MUTEX_ERRORCHECK ：检错锁，如果同一个线程请求同一个锁，则返回 EDEADLK，否则与普通锁类型动作相同。这样就保证当不允许多次加锁时不会出现嵌套情况下的死锁。
PTHREAD_MUTEX_RECURSIVE ：递归锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock 解锁。
PTHREAD_MUTEX_DEFAULT ：适应锁，动作最简单的锁类型，仅等待解锁后重新竞争，没有等待队列。

还有一种静态创建的方式：pthread_mutex_tmutex = PTHREAD_MUTEX_INITIALIZER static 或者全局变量。

pthread_mutexattr_settype：可以用来设置锁的类型，比如递归锁。

    static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
//    __block pthread_mutex_t lock;
//    pthread_mutex_init(&lock, PTHREAD_MUTEX_NORMAL);
    
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        pthread_mutex_lock(&lock);
        NSLog(@"操作1开始");
        sleep(3);
        NSLog(@"操作1结束");
        pthread_mutex_unlock(&lock);
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        sleep(1);
        pthread_mutex_lock(&lock);
        NSLog(@"操作2");
        pthread_mutex_unlock(&lock);
    });

以上代码执行结果为：

2018-08-16 16:31:19.333924+0800 Looks[6291:445780] 操作1开始
2018-08-16 16:31:22.339330+0800 Looks[6291:445780] 操作1结束
2018-08-16 16:31:22.339820+0800 Looks[6291:445781] 操作2

特点：基于 c 语言的 API，性能相对是最好的，可操作性更强，但 API 较多。

OSSpinLock

OSSpinLock 自旋锁，在线程阻塞等待的时候会一直轮询状态，这样在等待的时候会消耗大量资源。不过有 bug，已被弃用，弃用原因为：如果一个低优先级的线程获得锁并访问共享资源，这时一个高优先级的线程也尝试获得这个锁，它会处于 spinlock 的忙等状态从而占用大量 CPU。此时低优先级线程无法与高优先级线程争夺 CPU 时间，从而导致任务迟迟完不成、无法释放lock。所以 apple 的停用了 OSSpinLock, 所以在这不在做过多的介绍。