iOS多线程安全 - 线程同步

一、atomic介绍

     在iOS中，@property 新增属性时，可以增加atomic选项，atomic会给对应对setter方法加锁，相当于

 - (void)setTestStr:(NSString *)testStr

{

    @synchronizad(lock){

        if (testStr != _testStr) {

            [_testStr release];

            _testStr = [testStr retain];

        }

    }    

}

       那么就有问题了，为什么atomic又不是线程安全的呢？？而且还会代理性能问题，比起nonatomic性能可能要大减20倍，如果频繁的调用，可能更多。

       1、当线程A，给TestStr设置值得时候，会调用对应的setter方法，也就是加锁了，此时B线程也要对TestStr进行设置新值，因为A线程已经锁住了，所以B只能等待，这个时候是线程安全的。

       2、当线程A，给TestStr设置值得时候，此时B线程在读TestStr的值，因为setter和getter方法是没有联系的，这时，A在执行到加锁，只是还没有设置值，然而B线程已经读取走了，本来是想读取A设置之后的值，却读取了设置之前的值，也就线程不安全了。

       3、当线程A，给TestStr设置值得时候，C线程在A之前release了TestStr，此时就会导致崩溃，也就是线程不安全了。

      总的来说，atomic只是保证了setter方法的安全，没有保证对应成员变量的多线程安全，所以不是真正的线程安全。

   

二、线程安全的办法

2.1、synchronizad 给需要加锁的代码进行加锁。

- (IBAction)synchronizad:(id)sender {

    

    FDLog(@"synchronizad 测试");

    

    static NSObject *lock = nil;

    

    if (!lock) {

        lock = [[NSString alloc] init];

        

    }

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        FDLog(@"线程A，准备好");

        @synchronized(lock){

            FDLog(@"线程A lock, 请等待");

            [NSThread sleepForTimeInterval:3];

            FDLog(@"线程A 执行完毕");

        }

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        FDLog(@"线程B，准备好");

        @synchronized(lock){

            FDLog(@"线程B lock, 请等待");

            [NSThread sleepForTimeInterval:1];

            FDLog(@"线程B 执行完毕");

        }

    });

}

上面的AB线程都使用了同一把锁，对相应代码进行加锁，所以锁内的代码是线程安全的。

 

2.2、NSLook 对多线程需要安全的代码加锁

- (IBAction)NSLook:(id)sender {

    static NSLock *lock = nil;

    if (!lock) {

        lock = [[NSLock alloc] init];

    }

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        FDLog(@"线程A，准备好");

        [lock lock];

            FDLog(@"线程A lock, 请等待");

            [NSThread sleepForTimeInterval:3];

            FDLog(@"线程A 执行完毕");

        [lock unlock];

        

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        FDLog(@"线程B，准备好");

        [lock lock];

            FDLog(@"线程B lock, 请等待");

            [NSThread sleepForTimeInterval:1];

            FDLog(@"线程B 执行完毕");

        [lock unlock];

    });

    

}

上面的AB线程都使用了同一把锁，对相应代码进行加锁，所以锁内的代码是线程安全的。

 

2.3、NSCondition 条件锁，只有达到条件之后，才会执行锁操作，否则不会对数据进行加锁

- (IBAction)NSCondition:(id)sender {

#define kCondition_A  1

#define kCondition_B  2

    __block NSUInteger condition = kCondition_B;

    static NSConditionLock *conditionLock = nil;

    if (!conditionLock) {

        conditionLock = [[NSConditionLock alloc] initWithCondition:condition];

    }

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        FDLog(@"线程A，准备好,检测是否可以加锁");

        BOOL canLock = [conditionLock tryLockWhenCondition:kCondition_A];

        

        if (canLock) {

            FDLog(@"线程A lock, 请等待");

            [NSThread sleepForTimeInterval:1];

            FDLog(@"线程A 执行完毕");

            [conditionLock unlock];

        }else{

            FDLog(@"线程A 条件不满足，未加lock");

        }

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        FDLog(@"线程B，准备好,检测是否可以加锁");

        BOOL canLock = [conditionLock tryLockWhenCondition:kCondition_B];

        

        if (canLock) {

            FDLog(@"线程B lock, 请等待");

            [NSThread sleepForTimeInterval:1];

            FDLog(@"线程B 执行完毕");

            [conditionLock unlock];

        }else{

            FDLog(@"线程B 未加lock");

        }

    });

}

 

2.4、NSRecursiveLock 递归锁，同一个线程可以多次加锁，但是不会引起死锁,如果是NSLock，则会导致崩溃

- (void)reverseDebug:(NSUInteger )num lock:(NSRecursiveLock *)lock

{

    [lock lock];

    if (num<=0) {

        FDLog(@"结束");

        return;

    }

    FDLog(@"加了递归锁, num = %ld", num);

    [NSThread sleepForTimeInterval:0.5];

    [self reverseDebug:num-1 lock:lock];

    

    [lock unlock];

}

- (IBAction)NSRecursiveLock:(id)sender {

    

    static NSRecursiveLock *lock = nil;

    

    if (!lock) {

        lock = [[NSRecursiveLock alloc] init];

    }

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        [self reverseDebug:5 lock:lock];

    });

}