1、读写规则

同一时间，只能有1个线程进行写的操作
同一时间，允许有多个线程进行读的操作
同一时间，不允许既有写的操作，又有读的操作
如果使用普通的同步方案，比如用信号量保证只有一个线程进行read、write操作：

  1. - (void)read {
  2.     dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
  4.     NSLog(@"%s", __func__);
  6.     dispatch_semaphore_signal(self.semaphore);
  7. }
  9. - (void)write {
  10.     dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
  12.     NSLog(@"%s", __func__);
  14.     dispatch_semaphore_signal(self.semaphore);
  15. }

这样就会造成每次只有一个线程可以进行read操作，效率很低，如果不给read加锁，就有可能造成read和write同时进行。所有普通的同步方案不适合读写操作。

2、pthread_rwlock_t（读写锁）

pthread_rwlock_t是专门用于读写安全的锁
有如下API：

  1. - (void)rwlockAPI {
  2.     // 初始化
  3.     pthread_rwlock_t lock;
  4.     pthread_rwlock_init(&lock, NULL);
  6.     // 读-加锁
  7.     pthread_rwlock_rdlock(&lock);
  8.     // 读-尝试加锁
  9.     pthread_rwlock_tryrdlock(&lock);
  11.     // 写-加锁
  12.     pthread_rwlock_wrlock(&lock);
  13.     // 写-尝试加锁
  14.     pthread_rwlock_trywrlock(&lock);
  16.     // 解锁
  17.     pthread_rwlock_unlock(&lock);
  18.     // 销毁
  19.     pthread_rwlock_destroy(&lock);
  20. }

应用举例：

  1. - (void)read {
  2.     pthread_rwlock_rdlock(&_lock);
  4.     NSLog(@"%s", __func__);
  5.     sleep(1);
  7.     pthread_rwlock_unlock(&_lock);
  8. }
  10. - (void)write {
  11.     pthread_rwlock_wrlock(&_lock);
  13.     NSLog(@"%s", __func__);
  14.     sleep(1);
  16.     pthread_rwlock_unlock(&_lock);
  17. }

3、dispatch_barrier_async（栅栏函数）

这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的，如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果。
当执行任务时会建立栅栏，屏蔽其他线程，比如写入操作使用dispatch_barrier_async调用，读取操作使用dispatch_async调用，来实现多读单写的效果：

  1. - (void)read {
  2.     dispatch_async(self.queue, ^{
  3.         NSLog(@"%s", __func__);
  4.         sleep(1);
  5.     });
  6. }
  8. - (void)write {
  9.     dispatch_barrier_async(self.queue, ^{
  10.         NSLog(@"%s", __func__);
  11.         sleep(1);
  12.     });
  13. }

执行效果如下：
image.png