关于多线程同步的简单记录

开发中经常遇到一些多线程同时读写某一块数据的问题，关于这个问题，我也没能研究的比较深，所以只能做简单的记录。
iOS中常见的锁有：

• NSLock、NSConditionLock、NSRecursiveLock、NSCondition：都遵循NSLocking协议。
• @synchronized：使用简单方便，但耗时最大。
• dispatch_semaphore：信号量，个人最常用
• atomic：只可以用于单个属性
• pthread_mutex_t：C语言中的互斥锁
• pthread_rwlock_t：C语言中的读写锁

NSLock

NSLock具体的实现方式不清楚，但是在使用时，还有两点注意事项：
1.unlock方法必须和lock方法在同一线程。否则，会报错unlocked from thread which did not lock it
2.不支持递归操作，如果在同一线程连续调用两次lock方法，会造成死锁。如下图所示：

递归调用NSLock造成死锁

NSLock的实例，借鉴一个别人的例子：

NSLock *lock = [[NSLock alloc] init];  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //[lock lock];
        [lock lockBeforeDate:[NSDate date]];
            NSLog(@"需要线程同步的操作1 开始");
            sleep(2);
            NSLog(@"需要线程同步的操作1 结束");
        [lock unlock];

    });

 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        if ([lock tryLock]) {//尝试获取锁，如果获取不到返回NO，不会阻塞该线程
            NSLog(@"锁可用的操作");
            [lock unlock];
        }else{
            NSLog(@"锁不可用的操作");
        }

        NSDate *date = [[NSDate alloc] initWithTimeIntervalSinceNow:3];
        if ([lock lockBeforeDate:date]) {//尝试在未来的3s内获取锁，并阻塞该线程，如果3s内获取不到恢复线程, 返回NO,不会阻塞该线程
            NSLog(@"没有超时，获得锁");
            [lock unlock];
        }else{
            NSLog(@"超时，没有获得锁");
        }

    });

作者：景铭巴巴
链接：http://www.jianshu.com/p/938d68ed832c
來源：

NSLock运行结果

NSRecursiveLock

NSRecursiveLock和NSLock的不同点在于，NSRecursiveLock在同一个线程可以进入多次，且不会引起死锁，所以称为递归锁，如下图：

NSRecursiveLock递归锁

NSConditionLock

条件锁，即线程A需要在线程B的某种条件下才能继续，适用于生产者-消费者模式。

NSCondition

个人感觉这个东西比较像信号量，区别就是NSCondition在调用wait或signal时需要用lock和unlock包裹，同时，一些需要做线程同步的数据可以在lock和unlock之间处理。

@synchronized

用起来最方便的一种方式，但同时也是最耗时的一种方式，追求性能者慎用！

dispatch_semaphore

信号量，可以设置同时允许访问的最大并发量，个人最喜欢用。可以有以下用途：

• 异步方法变同步方法：

- (void)sync {
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [self async:^{
        dispatch_semaphore_signal(semaphore);
    }];
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
}

- (void)async:(void(^)())success {
    NSLog(@"啦啦啦，啦啦啦，我是卖报的小行家");
    success();
}

• 实现有限并发数的多任务并发设计，参见：iOS多任务并发设计
• 将信号量设为1，则变为互斥锁

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1); //最大并发数为1，即形成互斥锁
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//相当于lock    
    //do something...
    dispatch_semaphore_signal(semaphore);// 相当于unlock

atomic

OC中默认的属性修饰，对于非属性操作就爱莫能助了。

pthread_mutex_t

C的所有特性对于OC都是可以使用的，所以pthread_mutex_t同样适用于OC，至于使用方面，可以参考最后的资料，自己没有在实际工作中用过。

pthread_rwlock_t

系统自带的读写锁，默认支持写优先。即同时有读操作在等待和写操作在等待时，会优先完成写操作，防止造成“写饥饿”。对于读写锁，可以实现同时多线程读，同时只有一个线程写，对于读操作比写操作的需求大的多时，是比较适用的。但如果读操作很少，基本都是写操作，这时候适用读写锁反而不如普通互斥锁来的效率高，所以还是需要根据具体情况而定。
下面用信号量自己实现了一个简单的读写锁，不支持写优先：

@interface RWLock () {
    //经测试，下面几个变量在声明为属性时，性能会大大降低，所以在这里声明为变量
    dispatch_semaphore_t lockWrite;
    dispatch_semaphore_t lockRead;
    NSUInteger nReaders;
}
@end

@implementation RWLock

- (instancetype)init {
    self = [super init];
    lockRead = dispatch_semaphore_create(1);  //形成互斥锁
    lockWrite = dispatch_semaphore_create(1);
    return self;
}

- (void)readLock {
    dispatch_semaphore_wait(lockRead, DISPATCH_TIME_FOREVER);
    nReaders++;
    if (nCount == 1) {
        dispatch_semaphore_wait(lockWrite, DISPATCH_TIME_FOREVER);
    }
    dispatch_semaphore_signal(lockRead);
}

- (void)readUnLock {
    dispatch_semaphore_wait(lockRead, DISPATCH_TIME_FOREVER);
    nReaders--;
    if (nCount == 0) {
        dispatch_semaphore_signal(lockWrite);
    }
    dispatch_semaphore_signal(lockRead);
}

- (void)writeLock {
    dispatch_semaphore_wait(lockWrite, DISPATCH_TIME_FOREVER);
}

- (void)writeUnLock {
    dispatch_semaphore_signal(lockWrite);
}

参考资料：
起底多线程同步锁(iOS)
深入理解 iOS 开发中的锁