多线程探索四-锁

本文属于多线程系列：
多线程探索一-概念
多线程探索二-GCD
多线程探索三-NSOperation
多线程探索四-锁

iOS当中都有哪些锁

1. 互斥锁

   • NSLock foundation

   不支持重入

   - (void)A {
      [lock lock];
      B();
      [lock unlock];
   }
   - (void)B {
      [lock lock];
      //do something
      [lock unlock];
   }
   

   上面的写法容易导致死锁，这种情况下就需要用递归锁来解决

   • pthread_mutex

   pthread_mutex是跨平台，iOS系统自带多线程技术pthread的线程锁

   
   pthread_mutex_t pthreadmutex;
   
   /*
    #define PTHREAD_MUTEX_NORMAL           0     默认
    #define PTHREAD_MUTEX_ERRORCHECK       1     检错锁
    #define PTHREAD_MUTEX_RECURSIVE        2  递归锁
    #define PTHREAD_MUTEX_DEFAULT        PTHREAD_MUTEX_NORMAL  默认
    */
   
   pthread_mutex_init(&pthreadmutex, PTHREAD_MUTEX_NORMAL);
   dispatch_queue_t q = dispatch_get_global_queue(0, 0);
   __block int count = 0;
   for (int i = 0; i<10000; i++) {
       dispatch_async(q, ^{
           pthread_mutex_lock(&pthreadmutex);
           count ++;
           NSLog(@"%d",count);
           pthread_mutex_unlock(&pthreadmutex);
       });
   }
   pthread_mutex_destroy(&pthreadmutex);
   
   

   • @synchronized

     • 创建单例对象的时候，保证多线程下 对象唯一

2. 递归锁/重入锁

   递归锁/重入锁有一个特点，就是同一个线程可以加锁N次而不会引发死锁。

   • @synchronized

     创建单例对象的时候，保证多线程下 对象唯一

   • NSRecursiveLock

   • pthread_mutex(recursive)

3. 自旋锁

   • OSSpinLock

     循环等待询问，不释放当前资源
     用于轻量级数据访问，简单的int值 +1/-1 操作
     runtime
     iOS10以后被弃用

   • os_unfair_lock

   何时使用自旋锁，何时使用互斥锁：
   当预计线程等待锁的时间很短，或者加锁的代码（临界区）经常被调用，但竞争情况很少发生，再或者CPU资源不紧张，拥有多核处理器的时候使用自旋锁比较合适。
   而当预计线程等待锁的时间较长，CPU是单核处理器，或者临界区有IO操作，或者临界区代码复杂或者循环量大，临界区竞争非常激烈的时候使用互斥锁比较合适

4. 读写锁 pthread的API

    pthread_rwlock
    //加读锁
    pthread_rwlock_rdlock(&rwlock);
    //解锁
    pthread_rwlock_unlock(&rwlock);
    //加写锁
    pthread_rwlock_wrlock(&rwlock);
    //解锁
    pthread_rwlock_unlock(&rwlock);
   
   

5. 条件锁 NSCondition/NSConditionLock

   dispatch_queue_t q = dispatch_queue_create("struggle3g", DISPATCH_QUEUE_CONCURRENT);
   
   NSCondition *lock = [[NSCondition alloc] init];
   //第一个线程
   __block BOOL finished = NO;
   dispatch_async(q, ^{
       [lock lock];
       while (!finished) {
           [lock wait];
           NSLog(@"第一个线程得到第二个线程的通知");
       }
       [lock unlock];
       NSLog(@"第一个线程使用完毕");
   });
   
   //第二个线程
   dispatch_async(q, ^{
       [lock lock];
       sleep(2);
       finished = YES;
       NSLog(@"我做了一些事情，告诉第一个线程");
       [lock signal];
       [lock unlock];
       NSLog(@"第二个线程使用完毕");
   });
   

6. 信号量 dispatch_semaphore_t

   • dispatch_semaphore_create

    struct semaphore {
        int value;
        List<thread>;
    }
   

   • dispatch_semaphore_wait()

   {
       S.value = S.value - 1;
       if S.value < 0 then Block(S.List); //阻塞时一个主动行为 
   }
   
   

   • dispatch_semaphore_singal()

   {
       S.value = S.value + 1;
       if S.value <= 0 then wakeup(S.List);//唤醒是一个被动行为
   }
   
   

7. atomic

   • 关键字
   • 被修饰对象 是原子操作的（赋值有效）

   self.array = array1; //有效   
   [self.array addObject: @1]; //无效
   

参考文章