iOS中的线程安全问题

为了保证线程安全，不会因为多个线程访问造成资源抢夺，出现的运行结果的偏差问题，我们需要使用到线程同步技术，最常用的就是 @synchronized互斥锁（同步锁）、NSLock、dispatch_semaphore、原子锁等。

使用方法：

一、

@synchronized（实例化对象）｛

要加锁的代码

｝

注：实例化对象要保证唯一性，一般使用self当前类对象。

和下面的信号量方式相比，性能不是很好。

二、

dispatch_semaphore：

dispatch_semaphore是GCD用来同步的一种方式，是使用信号量来控制线程是继续等待，还是继续执行下面的代码。

    dispatch_semaphore_t signal = dispatch_semaphore_create(1);    ／／传入的参数为long，输出一个dispatch_semaphore_t类型且值为
                           value的信号量。值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL

    dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);  ／／超时时间，线程加锁之后等待的时间

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        dispatch_semaphore_wait(signal, overTime);  ／／这个函数会使传入的信号量dsema的值减1；这个函数的作用是这样的，如果dsema信号量的值大于0，
                                                   该函数所处线程就继续执行下面的语句，并且将信号量的值减1；如果desema的值为0，那么这个函数就
                                                   阻塞当前线程等待timeout（注意timeout的类型为dispatch_time_t，不能直接传入整形或float
                                                   型数），如果等待的期间desema的值被dispatch_semaphore_signal函数加1了，且该函数
                                                  （即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。
                                                 如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行其后语句。
            NSLog(@"需要线程同步的操作1 开始");
            sleep(2);
            NSLog(@"需要线程同步的操作1 结束");
        dispatch_semaphore_signal(signal);  ／／这个函数会使传入的信号量的值加1；
    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        dispatch_semaphore_wait(signal, overTime);
            NSLog(@"需要线程同步的操作2");
        dispatch_semaphore_signal(signal);
    });

 

三、

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(@"超时，没有获得锁");
        }

    });

NSLock是Cocoa提供给我们最基本的锁对象，这也是我们经常所使用的，除lock和unlock方法外，NSLock还提供了tryLock和lockBeforeDate:两个方法，前一个方法会尝试加锁，如果锁不可用(已经被锁住)，刚并不会阻塞线程，并返回NO。lockBeforeDate:方法会在所指定Date之前尝试加锁，如果在指定时间之前都不能加锁，则返回NO。

四、单例模式的线程安全问题：

+(AccountManager *)sharedManager

{

static AccountManager *sharedAccountManagerInstance = nil;

static dispatch_once_t predicate; dispatch_once(&predicate, ^{

sharedAccountManagerInstance = [[self alloc] init];

});

return sharedAccountManagerInstance;

}

在方法中先声明了一个实例，并初始化为nil，前面的static关键字可以保证只执行一次为nil的操作。dispatch_once_t是多线程中的，保证只执行一次。dispatch_once这个函数用于检查该代码块是否已经被调用过，通过它不仅可以保证块里面初始化的代码仅被运行一次，还能保证线程的安全。

访问单例的成员变量、静态变量、进行i/o操作应该要考虑线程安全问题。