使用GCD为代码加锁

#import "EOCGCD.h"

@interface EOCGCD()
{
    NSLock *_lock;
    dispatch_queue_t _syncQueue;
    dispatch_queue_t _asyncQueue;
}
@end
@implementation EOCGCD
@synthesize someString1,someString2,someString3,someString4;

-(void)initSomething
{
    _lock = [[NSLock alloc] init];
    
    _syncQueue = dispatch_queue_create("come.affect.syncQueue", NULL);
    _asyncQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
}

//1.同步块加锁
//根据给对的对象，自动创建一个锁，并等待块中的代码执行完毕。执行完这段代码，锁就释放了。
-(void)setSomeString1:(NSString *)someString1
{
    @synchronized(self){
        //safe
        self.someString1 = someString1;
    }
}

-(NSString *)someString1
{
    @synchronized(self){
        //safe
        return self.someString1;
    }
}



//2.锁对象加锁
//可以避免了给self频繁加@synchronized锁，这里始终用1个全局锁，但是效率还是非常低。因为只有该任务执行完，下一个任务才能继续
- (void)synchronizedMethod2 {
    [_lock lock];
    //safe
    [_lock unlock];
}
-(void)setSomeString2:(NSString *)someString2
{
    [_lock lock];
    //safe
    self.someString2 = someString2;
    [_lock unlock];
}

-(NSString *)someString2
{
    return self.someString2;
}


//3.GCD-串行同步队列
//将读取操作以及写入操作都安排在同一个队列里，可保证数据同步
-(NSString *)someString3
{
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = self.someString3;
    });
    return localSomeString;
}
-(void)setSomeString3:(NSString *)someString3
{
    dispatch_sync(_syncQueue, ^{
        self.someString3 = someString3;
    });
}


//4.GCD-并行同步队列
//理论上写入方法可以不同步，这样操作会更快
//但实际上是更慢的，因为执行异步队列，是需要拷贝块的
-(NSString *)someString4
{
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = self.someString4;
    });
    return localSomeString;
}
-(void)setSomeString4:(NSString *)someString4
{
    dispatch_async(_asyncQueue, ^{
        self.someString3 = someString4;
    });
}

//5.GCD-栅栏
/*
 如果采用异步写入，这样不能保证数据同步
 在队列中，栅栏块必须要单独执行，不能与其他块并行。这只对并发队列有效，因为串行队列本来就是按顺序逐个进行。
 并行队列如果发现接下来要处理的块是栅栏块，就会等所有的块都执行了，才会单独执行栅栏块
 这种意义是使异步队列有同步队列的功能,但效率币同步更快
 */
-(NSString *)someString5
{
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = self.someString4;
    });
    return localSomeString;
}
-(void)setSomeString5:(NSString *)someString5
{
    dispatch_barrier_async(_asyncQueue, ^{
        self.someString3 = someString4;
    });
}
@end