【线程】线程安全-多读单写

多读单写

理解多读单写：

- 同时有多个读操作，读操作的时候，不能有写的操作；
- 在写操作时，不能有别的写操作；在写操作之前，所有的读操作都完成；
- 读操作是并行的，写操作时互斥的；

一、采用dispatch_barrier实现；

@interface Test () {
  dispatch_queue_t current_queue;
  NSMutableDictionary *dic;
}
@end

@implementation Test

- (id)init {
  self = [super init];
  if  (self) {
    dic = [[NSMutableDictionary alloc] init];
    // 创建并行队列
    current_queue = dispatch_queue_create("testQueue", DISPATCH_QUEUE_CONCURRENT);
  }
  return self;
}

- (void)setSafeObject:(id)object forKey:(NSString *)key {
  key = [key copy];
  // 异步栅栏写数据
  // barrier阻塞队列
  dispatch_barrier_async(current_queue, ^{
    if (key && object) {
      [dic setObject:object forKey:key];
    }
  });
}

- (id)getSafeObjectForKey:(NSString *)key {
  __block id result = nil;
  // 同步读取指定数据 (同步并行)
  dispatch_sync(current_queue, ^{
    result = [dic valueForKey:key];
  });
  return result;
}

- (BOOL)containObject:(id)object {
  __block BOOL isExist;
   //同步读取
  dispatch_sync(current_queue, ^ {
    isExist = [dic.allValues containsObject: object]
  });
}

@end

• 总结

1- 读操作：为什么用dispatch_sync？
一般读操作通常是直接想要结果，需要`同步返回`；如果`异步`获取的话，可能`会延迟`；

2- 写操作：为什么写用dispatch_barrier_async？
异步栅栏dispatch_barrier_async会阻塞`读写操作的队列`，
不会阻塞主队列和其他队列，不会影响其他操作；

二、采用rwlock读写锁实现

pthread_rwlock_t lock; //声明
pthread_rwlock_init(&lock,NULL); //初始化
pthread_rwlock_rdlock(&lock);//加读锁，可以加锁个
pthread_rwlock_wrlock(&lock); //加写锁，互斥的，只能加一个
pthread_rwlock_unlock(&lock);  //解锁

示例代码：

#import 

@interface Test() {
    pthread_rwlock_t lock;//读写锁
    NSMutableDictionary *dic;
}
@end

@impletation 
- (id)init {
  self = [super init];
  if  (self) {
    [self initTestRwLock];
  }
  return self;
}

- (void)initTestRwLock {
    pthread_rwlock_init(&lock,NULL); //1- 初始化读写锁
    dic = [NSMutableDictionary dictionary];
}


- (id)objectForKey:(NSString *)key {
    pthread_rwlock_rdlock(&lock); //加读锁
    NSLog(@"读写锁：读操作-加锁: %@",key);
    
    id obj = [dic objectForKey:key];
    sleep(2);
    
    pthread_rwlock_unlock(&lock); //解锁
    NSLog(@"读写锁：读操作-解锁: %@",key);
    return obj;
}

- (void)setObject:(id)obj forKey:(NSString *)key {
    pthread_rwlock_wrlock(&lock); //加写锁，写锁是互斥的
    NSLog(@"读写锁：写操作-加锁: %@",key);
    
    [dic setObject:obj forKey:key];
    sleep(2);
    
    pthread_rwlock_unlock(&lock); //解锁
    NSLog(@"读写锁：写操作-解锁: %@",key);
}

@end

• 异步并行调用：

dispatch_queue_t queue = dispatch_queue_create("test_queue", DISPATCH_QUEUE_CONCURRENT);
    
dispatch_async(queue, ^{
  [self setObject:@"测试1" forKey:@"key1"];
  [self objectForKey:@"key1"];
});
    
dispatch_async(queue, ^{
  [self setObject:@"测试2" forKey:@"key2"];
  [self objectForKey:@"key2"];
});

dispatch_async(queue, ^{
  [self setObject:@"测试3" forKey:@"key3"];
  [self objectForKey:@"key3"];
});

• 输出结果：

// 写 - 排他性
2021-12-31 15:30:32.041620+0800 读写锁：写操作-加锁: key1
2021-12-31 15:30:34.047163+0800 读写锁：写操作-解锁: key1
2021-12-31 15:30:34.047252+0800 读写锁：写操作-加锁: key2
2021-12-31 15:30:36.051089+0800 读写锁：写操作-解锁: key2
2021-12-31 15:30:36.051185+0800 读写锁：写操作-加锁: key3
2021-12-31 15:30:38.056850+0800 读写锁：写操作-解锁: key3
// 读 - 并发
2021-12-31 15:30:38.056931+0800 读写锁：读操作-加锁: key1
2021-12-31 15:30:38.056944+0800 读写锁：读操作-加锁: key2
2021-12-31 15:30:38.057284+0800 读写锁：读操作-加锁: key3
2021-12-31 15:30:40.062497+0800 读写锁：读操作-解锁: key2
2021-12-31 15:30:40.062497+0800 读写锁：读操作-解锁: key1
2021-12-31 15:30:40.062643+0800 读写锁：读操作-解锁: key3

• 结论：

写锁`互斥`，读锁可`并行`；

读写锁：

- 是一种特殊的自旋锁；
- 读写锁对于自旋锁而言，能`提高并发性`，在多核系统中，允许`多个读者`来访问共享资源；
- 写者是排他性的，一个读写锁同时`只能有一个写者`或`多个读者`，但不能同时既有写者又有写者；

- 如果读写锁当前`没有读者，也没有写者`，那么`写者`可以`立即获得`读写锁，
  否则它必须`自旋`在那里，直到`没有任何的写者或读者`；
  即在`读加锁`状态时，所有以`读模式`对它加锁的线程都`可以获得访问权`；
  当有写模式试图加锁时，读写锁通常会`阻塞随后的读模式锁请求`，防止读模式锁长期被占用，而写模式锁长期被阻塞；

- 如果读写锁`没有写者`，那么`读者`可以`立即获得`读写锁，
  否则读者必须`自旋`在那里，知道`写者释放读写锁`；
  即以`写模式`进行加锁，必须等`所有线程释放锁`；