Please enable JavaScript.

Coggle requires JavaScript to display documents.

iOS之锁 ((基本概念 (自旋锁：是用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了…

iOS之锁

互斥锁
pthread_mutex

代码:

pthread_mutexattr_t attr;  
pthread_mutexattr_init(&attr); 
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);  // 定义锁的属性

pthread_mutex_t mutex; 
pthread_mutex_init(&mutex, &attr) // 创建锁
pthread_mutex_lock(&mutex); // 申请锁 
...
pthread_mutex_unlock(&mutex); // 释放锁 

参数:
PTHREAD_MUTEX_NORMAL  即普通锁
PTHREAD_MUTEX_RECURSIVE  即嵌套锁/递归锁
PTHREAD_MUTEX_ERRORCHECK  即纠错锁

NSLock
特点:OC形式暴露给开发者的使一种锁.
场景:适合简单的锁定,一旦获取锁，执行则进入临界区，且不会允许超过一个线程并行执行。释放锁则标记临界区结束。

NSLock 只是在内部封装了一个 pthread_mutex，属性为 PTHREAD_MUTEX_ERRORCHECK，它会损失一定性能换来错误提示。

NSLock 是 Objective-C 以对象的形式暴露给开发者的一种锁，它的实现非常简单，通过宏，定义了 lock 方法:
#define    MLOCK \
- (void) lock\
{\
  int err = pthread_mutex_lock(&_mutex);\
  //错误处理 ……
}

注意:
1.使用宏定义的原因是，OC 内部还有其他几种锁，他们的 lock 方法都是一模一样，仅仅是内部 pthread_mutex 互斥锁的类型不同。通过宏定义，可以简化方法的定义。
2.NSLock 比 pthread_mutex 略慢的原因在于它需要经过方法调用，同时由于缓存的存在，多次方法调用不会对性能产生太大的影响。

NSCondition

特点:可以lock也可以wait 可以unlock也可以signal
场景:使用NSCondition解决标准的生产者—消费者问题.有些情况需要协调线程之间的执行。例如，一个线程可能需要等待其他线程返回结果。NSCondition 可以原子性的释放锁，从而使得其他等待的线程可以获取锁，从初始的线程继续等待。 

NSCondition 的底层是通过条件变量(condition variable) pthread_cond_t 来实现的。条件变量有点像信号量，提供了线程阻塞与信号机制，因此可以用来阻塞某个线程，并等待某个数据就绪，随后唤醒线程，比如常见的生产者-消费者模式。

void consumer () { // 消费者 
  pthread_mutex_lock(&mutex);
  while (data == NULL) {
    pthread_cond_wait(&condition_variable_signal, &mutex); // 等待数据
  }
  // --- 有新的数据，以下代码负责处理 ↓↓↓↓↓↓
  // temp = data;
  // --- 有新的数据，以上代码负责处理 ↑↑↑↑↑↑
  pthread_mutex_unlock(&mutex);
}
void producer () {  
  pthread_mutex_lock(&mutex);
  // 生产数据
  pthread_cond_signal(&condition_variable_signal); // 发出信号给消费者，告诉他们有了新的数据
  pthread_mutex_unlock(&mutex);
}

注意:使用 condition 有一个好处，我们可以调用 pthread_cond_broadcast 方法通知所有等待中的消费者，这是使用信号量无法实现的。

NSRecursiveLock

特点:同一个线程可以加锁N次而不会引发死锁。
场景:用在循环或递归操作中. 

递归锁也是通过 pthread_mutex_lock 函数来实现，在函数内部会判断锁的类型，如果显示是递归锁，就允许递归调用，仅仅将一个计数器加一，锁的释放过程也是同理。
NSRecursiveLock 与 NSLock 的区别在于内部封装的 pthread_mutex_t 对象的类型不同，前者的类型为 PTHREAD_MUTEX_RECURSIVE。

NSConditionLock

特点:NSConditionLock好处是可以设置条件，条件符合时获得锁。设置时间，指定时间之前获取锁。
场景:需要特定条件才能触发的锁操作.

NSConditionLock 借助 NSCondition 来实现，它的本质就是一个生产者-消费者模型。“条件被满足”可以理解为生产者提供了新的内容。NSConditionLock 的内部持有一个 NSCondition 对象，以及 _condition_value 属性，在初始化时就会对这个属性进行赋值

// 简化版代码
- (id) initWithCondition: (NSInteger)value {
  if (nil != (self = [super init])) {
  _condition = [NSCondition new]
  _condition_value = value;
  return self;
}

//它的 lockWhenCondition 方法其实就是消费者方法:
- (void) lockWhenCondition: (NSInteger)value {
  [_condition lock];
  while (value != _condition_value) {
    [_condition wait];
  }
}

//对应的 unlockWhenCondition 方法则是生产者，使用了 broadcast 方法通知了所有的消费者:
- (void) unlockWithCondition: (NSInteger)value {
  _condition_value = value;
  [_condition broadcast];
  [_condition unlock];
}

自旋锁

特点:忙等状态不需要切换上下文状态.
场景:适合临界区执行时间较短或者实时性要求比较高的场合.(自旋锁在 while 循环中，线程处于忙等状态，白白浪费 CPU 时间，最终因为超时被操作系统抢占时间片。如果临界区执行时间较长，比如是文件读写，这种忙等是毫无必要的。)

自旋锁的实现 - 忙等
思路很简单，理论上来说只要定义一个全局变量，用来表示锁的可用情况即可，伪代码如下:
bool lock = false; // 一开始没有锁上，任何线程都可以申请锁 
do {
  while(lock); // 如果 lock 为 true 就一直死循环，相当于申请锁
  lock = true; // 挂上锁，这样别的线程就无法获得锁
    Critical section  // 临界区
  lock = false; // 相当于释放锁，这样别的线程可以进入临界区
    Reminder section // 不需要锁保护的代码
}

这段代码存在一个问题: 如果一开始有多个线程同时执行 while 循环，他们都不会在这里卡住，而是继续执行，这样就无法保证锁的可靠性了。解决思路也很简单，只要确保申请锁的过程是原子操作即可。大多CPU都提供了原子操作。CPU保证了某些对单个变量的比较和交换操作是原子的。

OSSpinLock lock = OS_SPINLOCK_INIT;
OSSpinLockLock(&lock);
...
OSSpinLockUnlock(&lock);

苹果官方推荐的替换OSSpinLock的方案，iOS10.0以上:
os_unfair_lock_t unfairLock;
unfairLock = &(OS_UNFAIR_LOCK_INIT);
os_unfair_lock_lock(unfairLock);
...
os_unfair_lock_unlock(unfairLock);

注意:
1.spin lock在实现的时候，有一个__pthread_spin_count限制，如果空转次数超过这个限制，线程依旧会挂起（__shed_yield）。
2.自旋锁因为优先级翻转问题,不在安全;除非开发者能保证访问锁的线程全部都处于同一优先级，否则iOS系统中所有类型的自旋锁都不能再使用了。

spin lock申请加锁的实现：

/////////////////////////////pthread_src/sysdeps/posix/pt-spin.c
/* Lock the spin lock object LOCK.  If the lock is held by another thread spin until it becomes available.  */
int _pthread_spin_lock (__pthread_spinlock_t *lock)
{
  int i;
  while (1){
    for (i = 0; i < __pthread_spin_count; i++){
      if (__pthread_spin_trylock (lock) == 0)
        return 0;
     }
    __sched_yield ();
   }
}

synchronized
OC 层面的锁，主要是通过
牺牲性能换来语法上的简洁与可读.

synchronized和dispatch_once区别
synchronized采用的是递归互斥锁来实现线程安全，而dispatch_once的内部则使用了很多原子操作来替代锁，以及通过信号量来实现线程同步，而且有很多针对处理器优化的地方，甚至在if判断语句上也做了优化(逼格有点高)，苹果也推荐使用dispatch_once来创建单例.

每次调用dispatch_once的时候，都会先判断predicate的值是否是~0l(也就是DISPATCH_ONCE_DONE)，如果是则意味着block已经执行过了，便不再执行，代码如下：
void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block);
#ifdef __GNUC__
#define dispatch_once(x, ...) do { if (__builtin_expect(*(x), ~0l) != ~0l) dispatch_once((x), (__VA_ARGS__)); } while (0)
#endif

__builtin_expect()目的是将“分支转移”的信息提供给编译器，这样编译器可以对代码进行优化，以减少指令跳转带来的性能下降。
__builtin_expect((x),1) 表示 x 的值为真的可能性更大；
__builtin_expect((x),0) 表示 x 的值为假的可能性更大。

https://www.jianshu.com/p/ef3f77c8b320

单例的创建与销毁

static BNCounter * _instance = nil;
static dispatch_once_t onceToken;
+(instancetype)shared{
    dispatch_once(&onceToken, ^{
        _instance = [[self alloc]init];
    });
    return _instance;
}
+(void)destoryShared{
    _instance = nil;
    onceToken = 0;
}