@synchronized

日常开发中常常需要使用锁，可能大多数是使用OC封装的@synchronized，使用起来非常方便，但是很多文章说synchronized效率很低，如果在不注重效率的情况下，可以使用。为了搞清为什么，某家找到了一些资料。首先我们要搞清楚@synchronized是怎么加锁的，因为它并没有显示的加锁 和 释放。

@synchronized(obj) {
    // do work
}

只需上述那样即可加锁。
翻查资料发现@synchronized实际上是实现了objc_sync_enter和objc_sync_exit两个函数。在xcode查看头文件

/** 
 * Begin synchronizing on 'obj'.  
 * Allocates recursive pthread_mutex associated with 'obj' if needed.
   分配一个递归锁pthread_mutex 给obj
 * @param obj The object to begin synchronizing on.
 * 
 * @return OBJC_SYNC_SUCCESS once lock is acquired.  
 */
OBJC_EXPORT int
objc_sync_enter(id _Nonnull obj)
    OBJC_AVAILABLE(10.3, 2.0, 9.0, 1.0, 2.0);

/** 
 * End synchronizing on 'obj'. 
 * 
 * @param obj The object to end synchronizing on.
 * 
 * @return OBJC_SYNC_SUCCESS or OBJC_SYNC_NOT_OWNING_THREAD_ERROR
 */
OBJC_EXPORT int
objc_sync_exit(id _Nonnull obj)
    OBJC_AVAILABLE(10.3, 2.0, 9.0, 1.0, 2.0);

enum {
    OBJC_SYNC_SUCCESS                 = 0,
    OBJC_SYNC_NOT_OWNING_THREAD_ERROR = -1
};

注意上述代码中文部分哈，实际上是分配一个递归锁pthread_mutex给传进来的obj。
然后在objc_sync_enter的源码中发现

int objc_sync_enter(id obj)
{
    int result = OBJC_SYNC_SUCCESS;

    if (obj) {
        SyncData* data = id2data(obj, ACQUIRE);
        require_action_string(data != NULL, done, result = OBJC_SYNC_NOT_INITIALIZED, "id2data failed");
    
        result = recursive_mutex_lock(&data->mutex);
        require_noerr_string(result, done, "mutex_lock failed");
    } else {
        // @synchronized(nil) does nothing
        if (DebugNilSync) {
            _objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");
        }
        objc_sync_nil();
    }

done: 
    return result;

}

发现其实根据obj生成了SyncData类型的数据，&data->mutex可以看出SyncData里面包含了递归锁，那么SyncData到底是什么呢？

typedef struct SyncData {
    id object;
    recursive_mutex_t mutex;
    struct SyncData* nextData;
    int threadCount;
} SyncData;

typedef struct SyncList {
    SyncData *data;
    spinlock_t lock;
} SyncList;

// Use multiple parallel lists to decrease contention among unrelated objects.
#define COUNT 16
#define HASH(obj) ((((uintptr_t)(obj)) >> 5) & (COUNT - 1))
#define LOCK_FOR_OBJ(obj) sDataLists[HASH(obj)].lock
#define LIST_FOR_OBJ(obj) sDataLists[HASH(obj)].data
static SyncList sDataLists[COUNT];

一目了然，SyncData实际上包含了我们传进来的obj，分配的递归锁，指向下一个SyncData的指针，和一个threadCount。然后往下看是一个 SyncList 结构体数组，大小为16。通过定义的一个哈希算法将传入对象映射到数组上的一个下标。值得注意的是这个哈希算法设计的很巧妙，是将对象指针在内存的地址转化为无符号整型并右移五位，再跟 0xF 做按位与运算，这样结果不会超出数组大小。 LOCK_FOR_OBJ(obj) 和 LIST_FOR_OBJ(obj) 这俩宏就更好理解了，先是哈希出对象的数组下标，然后取出数组对应元素的 lock 或 data。
当你调用objc_sync_enter(obj) 时，它用 obj 内存地址的哈希值查找合适的 SyncData，然后将其上锁。当你调用 objc_sync_exit(obj)时，它查找合适的 SyncData 并将其解锁。
实际上@synchronized 底层是维护了一个哈希表，每次需要根据根据obj算出对应的哈希值，来找到应该加锁和释放的SyncData。
然后根据

// @synchronized(nil) does nothing
        if (DebugNilSync) {
            _objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");
        }
        objc_sync_nil();

看出如果obj传入nil的话，会造成加锁失败的情况，objc_sync_nil()不会起任何效果。

pthread_mutex

NSLock

NSLock实际是封装了一下 pthread_mutex

- (void) lock\
{\
  int err = pthread_mutex_lock(&_mutex);\
  // 错误处理 ……
}

因为要加入错误处理，所以性能会比 pthread_mutex有所下降。
使用方法：

点开NSLock头文件会发现除了NSLock 还有NSConditionLock，NSRecursiveLock，NSCondition三种锁

NSConditionLock

条件锁，可以自己设置一个条件来定义加锁 与 释放锁的时机.注意条件并不是bool类型的，而是一个固定的数字，加锁或者解锁，都会把condition修改为参数

  NSConditionLock *lock = [[NSConditionLock alloc]initWithCondition:CONDITION_NO_DATA];
 lock.name = @"NSConditionLock";
        //默认一个条件  
 
 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            //1. 当满足 【没有数据的条件时】进行加锁
            [lock lockWhenCondition:CONDITION_NO_DATA];
            NSLog(@"有数据了");
            //2. 生产者生成数据
            //.....
            
            //3. 解锁，并设置新的条件，已经有数据了
            [lock unlockWithCondition:CONDITION_HAS_DATA];
        });
  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            //消费者，加锁与解锁的过程
            
            //1. 当满足 【有数据的条件时】进行加锁
            [lock lockWhenCondition:CONDITION_HAS_DATA];
            
            //2. 消费者消费数据
            //.....
            NSLog(@"消费数据了");
            //3. 解锁，并设置新的条件，没有数据了
            [lock unlockWithCondition:CONDITION_NO_DATA];
        });
        }

NSRecursiveLock

递归锁，如果在递归中使用锁，可能会造成死锁的情况，但是若使用递归锁即可解决这个问题，递归锁允许一个线程多次请求锁，保证不会出现死锁的情况。

 NSRecursiveLock *recursiveLock = [[NSRecursiveLock alloc]init];      dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            
            static void (^RecursiveMethod)(int);
            RecursiveMethod = ^(int value) {
                
                [recursiveLock lock];
                if (value > 0) {
                    
                    NSLog(@"value = %d", value);
                    sleep(2);
                    RecursiveMethod(value - 1);
                }
                [recursiveLock unlock];
            };
            
            RecursiveMethod(5);
        });

NSCondition

基本的条件锁，手动的控制。wait是傻等，waitUntilDate:方法是等一会，signal是唤起一个在等待的线程。用法如下：

 NSCondition *condition = [[NSCondition alloc]init];
        condition.name = @"NSCondition";
        NSMutableArray *products = [[NSMutableArray  alloc]initWithCapacity:30];
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            [condition lock];
            while(products.count == 0){
                NSLog(@"等待产品");
                [condition wait];
            }
            [products removeObjectAtIndex:0];
            NSLog(@"消费产品");
            [condition unlock];
        });
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            [condition lock];
            [products addObject:@"一个"];
            [condition signal];
            NSLog(@"生产了一个产品");
            [condition unlock];
        });

信号量

dispatch_semaphore 是一个效率比较高的线程问题解决方案
信号量在初始化时要指定 value，随后内部将这个 value 存储起来。实际操作时会存两个 value，一个是当前的 value，一个是记录初始 value。信号的 wait 和 signal 是互逆的两个操作。如果 value 大于 0，前者将 value 减一，此时如果 value 小于零就一直等待。
初始 value 必须大于等于 0，如果为 0 并随后调用 wait 方法，线程将被阻塞直到别的线程调用了 signal 方法。用法如下

-(void)test_semaphore{
       dispatch_queue_t queque = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
       //异步执行
       dispatch_async(queque, ^{
           dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
           [self getToken:semaphore];
           dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
           [self request];
       });
       
       NSLog(@"main thread");
}
-(void)getToken:(dispatch_semaphore_t)semaphore{
   NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]];
   NSURLSessionTask *task = [session dataTaskWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"https://www.baidu.com"]] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
       NSLog(@"get Token");
       //成功拿到token，发送信号量:
       dispatch_semaphore_signal(semaphore);
   }];
   [task resume];
}
-(void)request{
   dispatch_async(dispatch_get_main_queue(), ^{
       NSLog(@"刷新数据");
   });
}

pthread

pthread是POSIX标准的多线程库，pthread可以实现的锁有很多种，包括互斥锁，读写锁，空转锁，条件锁，信号量（此信号量非上述信号量）等等，pthread很强大，大家如果想深入了解可以参考pthread的各种同步机制。这里只是演示互斥锁的用法

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);  // 定义锁的属性
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, &attr); // 创建锁
pthread_mutex_lock(&mutex); // 申请锁
NSLog(@"pthread_mutexattr_t互斥锁");
 pthread_mutex_unlock(&mutex); // 释放锁

OSSpinLock&os_unfair_lock

由于OSSpinLock不再安全，所以这里我们就直接说一下os_unfair_lock，这个是苹果用于代替OSSpinLock的。效率很高用法很简单如下

os_unfair_lock_t unfairLock;
 unfairLock = &(OS_UNFAIR_LOCK_INIT);
os_unfair_lock_lock(unfairLock);
NSLog(@"os_unfair_lock_t");
os_unfair_lock_unlock(unfairLock);

这么多锁，性能如何呢？我们引用yy大神的一个截图

各类锁性能对比