多线程 之 多线程的读写安全

1、前言

在前面我们已经讲过了iOS中的线程同步技术，主要通过加锁实现。
对于读写操作，一般都比较耗时耗性能，为了保持其安全性，我们一般要采取“多读单写”模式：
（1）同一时间，只能有1个线程进行写的操作
（2）同一时间，允许有多个线程进行读的操作
（3）同一时间，不允许既有写的操作，又有读的操作

iOS中提供了以下两种方法去实现：
pthread_rwlock 读写锁
dispatch_barrier_async 异步栅栏调用

2、pthread_rwlock和dispatch_barrier_async的用法

pthread_rwlock读写锁

 //初始化读写锁
pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);
//读 - 加锁
pthread_rwlock_rdlock(&rwlock);
//读 - 尝试加锁
pthread_rwlock_tryrdlock(&rwlock);
//写 - 加锁
pthread_rwlock_wrlock(&rwlock);
//写 - 尝试加锁
pthread_rwlock_trywrlock(&rwlock);
//解锁
pthread_rwlock_unlock(&rwlock);
//销毁锁
pthread_rwlock_destroy(&rwlock);

这个例子就是读写操作下的线程保护操作：pthread_rwlock读写锁的运用
============================================================
#import "ViewController.h"
#import 

@interface ViewController ()

@property(nonatomic,assign)pthread_rwlock_t rwLock;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    //初始化_rwLock
    pthread_rwlock_init(&_rwLock, NULL);
    
    for (int i=0; i<5; i++) {
        [[[NSThread alloc] initWithTarget:self selector:@selector(read) object:nil] start];
        [[[NSThread alloc] initWithTarget:self selector:@selector(write) object:nil] start];
    }
}

-(void)read{
    pthread_rwlock_rdlock(&_rwLock);
    sleep(1);
    NSLog(@"%s",__func__);
    pthread_rwlock_unlock(&_rwLock);
}

-(void)write{
    pthread_rwlock_wrlock(&_rwLock);
    sleep(1);
    NSLog(@"%s",__func__);
    pthread_rwlock_unlock(&_rwLock);
}

-(void)dealloc{
    pthread_rwlock_destroy(&_rwLock);
}
@end

dispatch_barrier_async异步栅栏调用
dispatch_barrier_async函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的。如果传入的是串行队列或者系统提供的全局并发队列,这个栅栏函数的作用等dispatch_async()。

//初始化队列
dispatch_queue_t queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
//读
dispatch_async(queue, ^{        
});
//写
dispatch_barrier_async(queue, ^{    
});

#import "ViewController.h"

@interface ViewController ()

@property(nonatomic,strong)dispatch_queue_t queue;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.queue = dispatch_queue_create("rwQueue", DISPATCH_QUEUE_CONCURRENT);
    for (int i=0; i<5; i++) {
        [self read];
        [self write];
    }
}

-(void)read{
    dispatch_async(self.queue, ^{
        sleep(1);
        NSLog(@"%s",__func__);
    });
}

-(void)write{
    dispatch_barrier_async(self.queue, ^{
        sleep(1);
        NSLog(@"%s",__func__);
    });
}

@end

3、扩展

nonatomic 和 atomic
atomic：原子，不可分割
atomic用于保证属性setter、getter的原子性操作，相当于在getter和setter内部加了线程同步的锁
但是它并不能保证使用属性的过程是线程安全的