锁

自旋锁 OSSpinLock

特点：不是一个安全的锁, 等待锁的线程会处于忙等(busy-wait)状态, 一直占用着CPU资源; (类似一个while(1)循环一样,不停的查询锁的状态, 注意区分Runloop的机制, 同样是阻塞, 但是Runloop是类似休眠的阻塞, 不会耗费CPU资源, 自旋锁的这种忙等机制使它相比其他锁效率更高, 因为没有唤醒-休眠这些类似操作, 从而能更快去处理事情);

自旋锁同一线程重复加锁会造成死锁问题。iOS10以上废弃，不推荐使用

互斥锁 os_unfair_lock

os_unfair_lock是iOS 10及以上版本引入的一种自旋锁，也被称为不公平锁。它是取代OSSpinLock的一种更为高效、更为安全的锁机制。
os_unfair_lock采用了更复杂的底层实现，可以避免OSSpinLock可能存在的优先级反转问题。它不会忙等待，而是采用了更智能的等待策略。当锁被占用时，等待线程会进入休眠状态，不再占用CPU资源，直到锁可用时被唤醒。
使用os_unfair_lock要比OSSpinLock更加安全，也更不容易出现死锁等问题。而且，相较于传统的互斥锁pthread_mutex_t，os_unfair_lock的性能也有所提升，因为它避免了不必要的系统调用。

需要注意的是，os_unfair_lock并不是递归锁，因此在同一线程中重复加锁会导致死锁。另外，由于os_unfair_lock是iOS 10及以上版本引入的，如果要兼容旧版本的iOS系统，建议在代码中进行系统版本的判断。

总结来说，os_unfair_lock是iOS中一种高效且安全的自旋锁，推荐使用它来代替OSSpinLock和传统的互斥锁，以确保线程安全性和性能优化。

互斥/递归/条件锁 pthread_mutex_t

pthread_mutex_t是一种互斥锁（Mutex Lock），它是POSIX线程库（Portable Operating System Interface for Unix）中提供的一种线程同步机制。互斥锁用于保护共享资源，确保在同一时间只有一个线程可以访问临界区，从而避免多个线程同时对共享资源进行修改造成的数据不一致和竞争条件。

pthread_mutex_t的使用非常灵活，可以根据需要设置不同的锁属性，如锁类型、锁的递归性、锁的协议等。互斥锁有多种类型，包括：

  1. PTHREAD_MUTEX_NORMAL：普通锁，不支持递归，一个线程多次加锁会导致死锁。
  2. PTHREAD_MUTEX_RECURSIVE：递归锁，支持同一线程多次加锁，只有最后一个解锁时才会释放锁。
  3. PTHREAD_MUTEX_ERRORCHECK：检错锁，如果同一线程多次加锁，会返回错误而不是导致死锁。
  4. PTHREAD_MUTEX_DEFAULT：根据实现的选择来确定锁的类型，默认是普通锁。

在iOS开发中，pthread_mutex_t是一种比较底层的线程同步机制，通常较少直接使用。

互斥锁NSLock

NSLock是Foundation框架中的一种互斥锁，用于多线程同步。它是对pthread_mutex_t互斥锁的一种Objective-C封装，提供了更简单易用的接口来实现线程同步。
NSLock是非递归锁，即同一线程多次加锁会导致死锁。如果一个线程在未解锁的情况下再次尝试加锁，会导致死锁。

递归锁NSRecursiveLock

性能较互斥锁略差，适用于同一线程需要多次加锁的情况，支持同一线程多次加锁，不会产生死锁。
@ synchronized 关键字实际上用的是NSRecursiveLock，是系统帮创建使用。

条件锁NSCondition

NSCondition允许一个或多个线程等待某个条件成立，当条件成立时，它可以唤醒等待的线程。NSCondition通常与NSLock配合使用，以实现更复杂的线程同步需求。

条件锁NSConditionLock

NSConditionLock是Foundation框架中的一种条件锁，是对NSCondition的进一步封装，用于多线程同步。它允许一个或多个线程等待多个条件中的一个成立，并在条件成立时唤醒等待的线程。相比于NSCondition，NSConditionLock提供了更为方便的接口来管理多个条件的等待和唤醒。

NSConditionLock可以用于实现多个线程按照特定条件的先后顺序执行。它是一个基于整数的锁，通过指定条件的整数值来进行线程的等待和唤醒。

递归锁@synchronized

当一个线程进入@synchronized代码块时，它会尝试获取lockObject对象的锁。如果当前线程已经持有该锁，那么它可以继续进入临界区。如果当前线程没有持有该锁，那么它会等待直到获得锁为止。
当线程多次进入@synchronized代码块时，它仍然只需要一次释放锁。只有在所有进入@synchronized代码块的递归调用都完成后，锁才会被释放。
@synchronized使用简单，但在一些高并发的场景下，可能会存在性能问题。

读写锁pthrad_rwlock_t

读取加锁可以同时多个线程进行,写入同时只能一个线程进行, 等待的线程处于休眠状态;
1 pthread_rwlock_init()初始化一个读写锁;
2 pthread_rwlock_rdlock()读写锁的读取加锁;
3 pthread_rwlock_wrlock()读写锁的写入加锁;
4 pthread_rwlock_unlock()解锁;
5 pthread_rwlock_destroy()销毁锁;

示例代码：

/***********************************pthread_rwlock_t*************************************/
- (void)rwLockType {
    pthread_rwlock_init(&_lock, NULL);
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    __weak typeof(self) weakSelf = self;
    for (int i = 0; i < 100; i ++) {
        ///同时创建多个线程进行写入操作
        dispatch_async(queue, ^{
            [weakSelf lockWriteAction];
        });
        dispatch_async(queue, ^{
            [weakSelf lockWriteAction];
        });
        dispatch_async(queue, ^{
            [weakSelf lockWriteAction];
        });
        
        ///同时创建多个线程进行读操作
        dispatch_async(queue, ^{
            [weakSelf lockReadAction];
        });
        dispatch_async(queue, ^{
            [weakSelf lockReadAction];
        });
        dispatch_async(queue, ^{
            [weakSelf lockReadAction];
        });
    }
}
- (void)lockReadAction {
    pthread_rwlock_rdlock(&_lock);
    sleep(1);
    NSLog(@"RWLock Read Action   %@", [NSThread currentThread]);
    pthread_rwlock_unlock(&_lock);
}
- (void)lockWriteAction {
    pthread_rwlock_wrlock(&_lock);
    sleep(1);
    NSLog(@"RWLock Write Action   %@", [NSThread currentThread]);
    pthread_rwlock_unlock(&_lock);
}
- (void)dealloc {
    pthread_rwlock_destroy(&_lock);
}
/***********************************pthread_rwlock_t*************************************/

信号量dispatch_semaphore

本来使用于控制线程的最大并发数量的, 我们将dispatch_semaphore_create()并发数量设置为1也可以认为是加锁的功能;
判断信号量的值dispatch_semaphore_wait()如果大于0, 则可以继续往下执行(同时信号量的值减去一),如果信号量的值为0, 则线程进入休眠状态等待(此方法的第二个参数就是设置要等多久, 一般都是使用永久DISPATCH_TIME_FOREVER) ;
释放信号量dispatch_semaphore_signal()同时使信号量的值加上一;

#import "ViewController10.h"
@interface ViewController10 ()
@property (nonatomic, strong) dispatch_semaphore_t semaphore;
@end
@implementation ViewController10
- (void)viewDidLoad {
    [super viewDidLoad];
    self.semaphore = dispatch_semaphore_create(1);
    [self handleMoney];
}
- (void)handleMoney {
    self.money = 100;
    __weak typeof(self) weakSelf = self;
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i ++) {
            [weakSelf saveMoney];
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i ++) {
            [weakSelf drawMoney];
        }
    });
}
- (void)saveMoney{
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    [super saveMoney];
    dispatch_semaphore_signal(self.semaphore);
}
- (void)drawMoney {
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    [super drawMoney ];
    dispatch_semaphore_signal(self.semaphore);
}
@end

异步栅栏dispath_barrier_async

dispatch_queue_create()创建并发队列;
dispatch_barrier_async()异步栅栏;

传入的并发队列队列必须是手动创建, dispatch_queue_create()方式;
如果传入串行队列或者通过dispatch_get_global_queue()方式创建, 则dispath_barrier_async的作用就跟dispath_async变得一样;


/*********************************dispatch_barrier_async**********************************/
- (void)barrierAsyncType {
     self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i < 100; i ++) {
        ///同时创建多个线程进行写入操作
        [self barrierWriteAction];
        [self barrierWriteAction];
        [self barrierWriteAction];
        ///同时创建多个线程进行读取操作
        [self barrierReadAction];
        [self barrierReadAction];
        [self barrierReadAction];
    }
}
- (void)barrierReadAction {
    dispatch_async(self.queue, ^{
     sleep(1);
    NSLog(@"barrier Read Action   %@", [NSThread currentThread]);
    });
 }
- (void)barrierWriteAction {
    dispatch_barrier_async(self.queue, ^{
     sleep(1);
    NSLog(@"barrier Write Action   %@", [NSThread currentThread]);
    });
 }
/*********************************dispatch_barrier_async**********************************/

总结

效率排序
1）os_unfair_lock(iOS10之后)
2）OSSpinLock(iOS10之前)
3）dispatch_semaphore(iOS版本兼容性好)
4）pthread_mutex_t(iOS版本兼容行好)
5）NSLock( 基于pthread_mutex_t封装)
6）NSCondition( 基于pthread_mutex_t封装)
7）pthread_mutex_t(recursive)(递归锁的优先推荐)
8）NSRecursiveLock(基于pthread_mutex_t封装)
9）NSConditionLock(基于NSCondition封装)
@synchronized
10.1 iOS12之前基于pthread_mutex_t封装
10.2 iOS12之后基于os_unfair_lock封装(iOS12之后它的效率应该不是最低, 应该在3/4左右);

注意

加锁和解锁的实现一定要配套出现, 不然就会出现死锁的现象;

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 线程安全与锁
    UIKit和Foundation的线程安全 在UIKit和Foundation中，有很多操作都是非线程安全的，比如...
    Jason1226阅读 577评论 0赞 0
  • iOS中的锁
    iOS中的锁 前言 写在前面: 临界区：指的是一块对公共资源进行访问的代码，并非一种机制或是算法。 自旋锁：是用于...
    ROBIN2015阅读 912评论 0赞 7
  • iOS中锁的使用及其原理
    1、锁的归类 锁的分类只有两大类自旋锁和和互斥锁。这两大类下又分成很多不同的小类。了解锁之前建议先了解一下线程及线...
    希尔罗斯沃德_董阅读 2,026评论 2赞 4
  • iOS中锁的总结
    在多线程中，当多个线程同时访问同一块资源的时候，就容易引起数据错乱和数据安全问题 (1).OSSpinLock O...
    雪碧童鞋阅读 320评论 0赞 0
  • 多线程二:线程同步,OC中的各种锁
    在多线程一:GCD[//www.greatytc.com/p/4edf7c930095]中我们详细了解了...
    小心韩国人阅读 926评论 0赞 1