深入理解iOS开发中的锁
<h1 id="摘要">摘要</h1><p>本文的目的不是介绍 iOS 中各种锁如何使用，一方面笔者没有大量的实战经验，另一方面这样的文章相当多，比如 iOS中保证线程安全的几种方式与性能对比、iOS 常见知识点（三）：Lock。本文也不会详细介绍锁的具体实现原理，这会涉及到太多相关知识，笔者不敢误人子弟。</p>
<p>本文要做的就是简单的分析 iOS 开发中常见的几种锁如何实现，以及优缺点是什么，为什么会有性能上的差距，最终会简单的介绍锁的底层实现原理。水平有限，如果不慎有误，欢迎交流指正。同时建议读者在阅读本文以前，对 OC 中各种锁的使用方法先有大概的认识。</p>
<p>在 ibireme 的 不再安全的 OSSpinLock 一文中，有一张图片简单的比较了各种锁的加解锁性能:</p>
<p><img src="https://upload-images.jianshu.io/upload_images/23675445-ec8d1f482bf1c2c3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240"></p>
<p>本文会按照从上至下(速度由快至慢)的顺序分析每个锁的实现原理。需要说明的是，加解锁速度不表示锁的效率，只表示加解锁操作在执行时的复杂程度，下文会通过具体的例子来解释。</p>
<h1 id="osspinlock">OSSpinLock</h1>
<p>上述文章中已经介绍了 OSSpinLock 不再安全，主要原因发生在低优先级线程拿到锁时，高优先级线程进入忙等(busy-wait)状态，消耗大量 CPU 时间，从而导致低优先级线程拿不到 CPU 时间，也就无法完成任务并释放锁。这种问题被称为优先级反转。</p>
<p>为什么忙等会导致低优先级线程拿不到时间片？这还得从操作系统的线程调度说起。</p>
<p>现代操作系统在管理普通线程时，通常采用时间片轮转算法(Round Robin，简称 RR)。每个线程会被分配一段时间片(quantum)，通常在 10-100 毫秒左右。当线程用完属于自己的时间片以后，就会被操作系统挂起，放入等待队列中，直到下一次被分配时间片。</p>
<h2 id="自旋锁的实现原理">自旋锁的实现原理</h2>
<p>自旋锁的目的是为了确保临界区只有一个线程可以访问，它的使用可以用下面这段伪代码来描述:</p>
<pre><code>do {
Acquire Lock
Critical section// 临界区
Release Lock
Reminder section // 不需要锁保护的代码
}
</code></pre>
<p>在 Acquire Lock 这一步，我们申请加锁，目的是为了保护临界区(Critical Section) 中的代码不会被多个线程执行。</p>
<p>自旋锁的实现思路很简单，理论上来说只要定义一个全局变量，用来表示锁的可用情况即可，伪代码如下:</p>
<pre><code>bool lock = false; // 一开始没有锁上，任何线程都可以申请锁
do {
while(lock); // 如果 lock 为 true 就一直死循环，相当于申请锁
lock = true; // 挂上锁，这样别的线程就无法获得锁
Critical section// 临界区
lock = false; // 相当于释放锁，这样别的线程可以进入临界区
Reminder section // 不需要锁保护的代码
}
</code></pre>
<p>注释写得很清楚，就不再逐行分析了。可惜这段代码存在一个问题: 如果一开始有多个线程同时执行 while 循环，他们都不会在这里卡住，而是继续执行，这样就无法保证锁的可靠性了。解决思路也很简单，只要确保申请锁的过程是原子操作即可。</p>
<blockquote>
<p>作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：519832104 不管你是小白还是大牛欢迎入驻，分享经验，讨论技术，大家一起交流学习成长！</p>
</blockquote>
<p>另附上一份各好友收集的大厂面试题，需要iOS开发学习资料、面试真题，可以添加iOS开发进阶交流群，进群可自行下载！</p>
<p><img src="https://upload-images.jianshu.io/upload_images/23675445-9e32783176c2d07f.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240"></p>
<p>点击此处，立即与iOS大牛交流学习</p>
<h2 id="原子操作">原子操作</h2>
<p>狭义上的原子操作表示一条不可打断的操作，也就是说线程在执行操作过程中，不会被操作系统挂起，而是一定会执行完。在单处理器环境下，一条汇编指令显然是原子操作，因为中断也要通过指令来实现。</p>
<p>然而在多处理器的情况下，能够被多个处理器同时执行的操作任然算不上原子操作。因此，真正的原子操作必须由硬件提供支持，比如 x86 平台上如果在指令前面加上 “LOCK” 前缀，对应的机器码在执行时会把总线锁住，使得其他 CPU不能再执行相同操作，从而从硬件层面确保了操作的原子性。</p>
<p>这些非常底层的概念无需完全掌握，我们只要知道上述申请锁的过程，可以用一个原子性操作 <code>test_and_set</code> 来完成，它用伪代码可以这样表示:</p>
<pre><code>bool test_and_set (bool *target) {
bool rv = *target;
*target = TRUE;
return rv;
}
</code></pre>
<p>这段代码的作用是把 target 的值设置为 1，并返回原来的值。当然，在具体实现时，它通过一个原子性的指令来完成。</p>
<h2 id="自旋锁的总结">自旋锁的总结</h2>
<p>至此，自旋锁的实现原理就很清楚了:</p>
<pre><code>bool lock = false; // 一开始没有锁上，任何线程都可以申请锁
do {
while(test_and_set(&lock); // test_and_set 是一个原子操作
Critical section// 临界区
lock = false; // 相当于释放锁，这样别的线程可以进入临界区
Reminder section // 不需要锁保护的代码
}
</code></pre>
<p>如果临界区的执行时间过长，使用自旋锁不是个好主意。之前我们介绍过时间片轮转算法，线程在多种情况下会退出自己的时间片。其中一种是用完了时间片的时间，被操作系统强制抢占。除此以外，当线程进行 I/O 操作，或进入睡眠状态时，都会主动让出时间片。显然在 while 循环中，线程处于忙等状态，白白浪费 CPU 时间，最终因为超时被操作系统抢占时间片。如果临界区执行时间较长，比如是文件读写，这种忙等是毫无必要的。</p>
<h1 id="信号量">信号量</h1>
<p>之前我在 介绍 GCD 底层实现的文章 中简单描述了信号量 <code>dispatch_semaphore_t</code> 的实现原理，它最终会调用到 <code>sem_wait</code> 方法，这个方法在 glibc 中被实现如下:</p>
<pre><code>int sem_wait (sem_t *sem) {
int *futex = (int *) sem;
if (atomic_decrement_if_positive (futex) > 0)
return 0;
int err = lll_futex_wait (futex, 0);
return -1;
)
</code></pre>
<p>首先会把信号量的值减一，并判断是否大于零。如果大于零，说明不用等待，所以立刻返回。具体的等待操作在 <code>lll_futex_wait</code> 函数中实现，<strong>lll</strong> 是 low level lock 的简称。这个函数通过汇编代码实现，调用到 <code>SYS_futex</code> 这个系统调用，使线程进入睡眠状态，主动让出时间片，这个函数在互斥锁的实现中，也有可能被用到。</p>
<p>主动让出时间片并不总是代表效率高。让出时间片会导致操作系统切换到另一个线程，这种上下文切换通常需要 10 微秒左右，而且至少需要两次切换。如果等待时间很短，比如只有几个微秒，忙等就比线程睡眠更高效。</p>
<p>可以看到，自旋锁和信号量的实现都非常简单，这也是两者的加解锁耗时分别排在第一和第二的原因。再次强调，加解锁耗时不能准确反应出锁的效率(比如时间片切换就无法发生)，它只能从一定程度上衡量锁的实现复杂程度。</p>
<h1 id="pthread_mutex">pthread_mutex</h1>
<p>pthread 表示 POSIX thread，定义了一组跨平台的线程相关的 API，pthread_mutex 表示互斥锁。互斥锁的实现原理与信号量非常相似，不是使用忙等，而是阻塞线程并睡眠，需要进行上下文切换。</p>
<p>互斥锁的常见用法如下:</p>
<pre><code>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); // 释放锁
</code></pre>
<p>对于 pthread_mutex 来说，它的用法和之前没有太大的改变，比较重要的是锁的类型，可以有 <code>PTHREAD_MUTEX_NORMAL</code>、<code>PTHREAD_MUTEX_ERRORCHECK</code>、<code>PTHREAD_MUTEX_RECURSIVE</code> 等等，具体的特性就不做解释了，网上有很多相关资料。</p>
<p>一般情况下，一个线程只能申请一次锁，也只能在获得锁的情况下才能释放锁，多次申请锁或释放未获得的锁都会导致崩溃。假设在已经获得锁的情况下再次申请锁，线程会因为等待锁的释放而进入睡眠状态，因此就不可能再释放锁，从而导致死锁。</p>
<p>然而这种情况经常会发生，比如某个函数申请了锁，在临界区内又递归调用了自己。辛运的是 <code>pthread_mutex</code> 支持递归锁，也就是允许一个线程递归的申请锁，只要把 attr 的类型改成 <code>PTHREAD_MUTEX_RECURSIVE</code> 即可。</p>
<h2 id="互斥锁的实现">互斥锁的实现</h2>
<p>互斥锁在申请锁时，调用了 <code>pthread_mutex_lock</code> 方法，它在不同的系统上实现各有不同，有时候它的内部是使用信号量来实现，即使不用信号量，也会调用到 <code>lll_futex_wait</code> 函数，从而导致线程休眠。</p>
<p>上文说到如果临界区很短，忙等的效率也许更高，所以在有些版本的实现中，会首先尝试一定次数(比如 1000 次)的 test<em>and</em>test，这样可以在错误使用互斥锁时提高性能。</p>
<p>另外，由于 <code>pthread_mutex</code> 有多种类型，可以支持递归锁等，因此在申请加锁时，需要对锁的类型加以判断，这也就是为什么它和信号量的实现类似，但效率略低的原因。</p>
<h1 id="nslock">NSLock</h1>
<p>NSLock 是 Objective-C 以对象的形式暴露给开发者的一种锁，它的实现非常简单，通过宏，定义了 <code>lock</code>方法:</p>
<pre><code>#define MLOCK \n- (void) lock\n{\nint err = pthread_mutex_lock(&_mutex);\n// 错误处理 ……
}
</code></pre>
<p><code>NSLock</code> 只是在内部封装了一个 <code>pthread_mutex</code>，属性为 <code>PTHREAD_MUTEX_ERRORCHECK</code>，它会损失一定性能换来错误提示。</p>
<p>这里使用宏定义的原因是，OC 内部还有其他几种锁，他们的 lock 方法都是一模一样，仅仅是内部 <code>pthread_mutex</code> 互斥锁的类型不同。通过宏定义，可以简化方法的定义。</p>
<p><code>NSLock</code> 比 <code>pthread_mutex</code> 略慢的原因在于它需要经过方法调用，同时由于缓存的存在，多次方法调用不会对性能产生太大的影响。</p>
<h1 id="nscondition">NSCondition</h1>
<p><code>NSCondition</code> 的底层是通过条件变量(condition variable) <code>pthread_cond_t</code> 来实现的。条件变量有点像信号量，提供了线程阻塞与信号机制，因此可以用来阻塞某个线程，并等待某个数据就绪，随后唤醒线程，比如常见的生产者-消费者模式。</p>
<h2 id="如何使用条件变量">如何使用条件变量</h2>
<p>很多介绍 <code>pthread_cond_t</code> 的文章都会提到，它需要与互斥锁配合使用:</p>
<pre><code>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);
}
</code></pre>
<p>自然我们会有疑问:“如果不用互斥锁，只用条件变量会有什么问题呢？”。问题在于，<code>temp = data;</code> 这段代码不是线程安全的，也许在你把 data 读出来以前，已经有别的线程修改了数据。因此我们需要保证消费者拿到的数据是线程安全的。</p>
<p>wait 方法除了会被 signal 方法唤醒，有时还会被虚假唤醒，所以需要这里 while 循环中的判断来做二次确认。</p>
<h2 id="为什么要使用条件变量">为什么要使用条件变量</h2>
<p>介绍条件变量的文章非常多，但大多都对一个一个基本问题避而不谈:“为什么要用条件变量？它仅仅是控制了线程的执行顺序，用信号量或者互斥锁能不能模拟出类似效果？”</p>
<p>网上的相关资料比较少，我简单说一下个人看法。信号量可以一定程度上替代 condition，但是互斥锁不行。在以上给出的生产者-消费者模式的代码中， <code>pthread_cond_wait</code> 方法的本质是锁的转移，消费者放弃锁，然后生产者获得锁，同理，<code>pthread_cond_signal</code> 则是一个锁从生产者到消费者转移的过程。</p>
<p>如果使用互斥锁，我们需要把代码改成这样:</p>
<pre><code>void consumer () { // 消费者
pthread_mutex_lock(&mutex);
while (data == NULL) {
pthread_mutex_unlock(&mutex);
pthread_mutex_lock(&another_lock)// 相当于 wait 另一个互斥锁
pthread_mutex_lock(&mutex);
}
pthread_mutex_unlock(&mutex);
}
</code></pre>
<p>这样做存在的问题在于，在等待 another<em>lock 之前， 生产者有可能先执行代码， 从而释放了 another</em>lock。也就是说，我们无法保证释放锁和等待另一个锁这两个操作是原子性的，也就无法保证“先等待、后释放 another_lock” 这个顺序。</p>
<p>用信号量则不存在这个问题，因为信号量的等待和唤醒并不需要满足先后顺序，信号量只表示有多少个资源可用，因此不存在上述问题。然而与 <code>pthread_cond_wait</code> 保证的原子性锁转移相比，使用信号量似乎存在一定风险(暂时没有查到非原子性操作有何不妥)。</p>
<p>不过，使用 condition 有一个好处，我们可以调用 <code>pthread_cond_broadcast</code> 方法通知所有等待中的消费者，这是使用信号量无法实现的。</p>
<h2 id="nscondition-的做法">NSCondition 的做法</h2>
<p><code>NSCondition</code> 其实是封装了一个互斥锁和条件变量， 它把前者的 <code>lock</code> 方法和后者的 <code>wait/signal</code> 统一在 <code>NSCondition</code> 对象中，暴露给使用者:</p>
<pre><code>- (void) signal {
pthread_cond_signal(&_condition);
}
// 其实这个函数是通过宏来定义的，展开后就是这样
- (void) lock {
int err = pthread_mutex_lock(&_mutex);
}
</code></pre>
<p>它的加解锁过程与 <code>NSLock</code> 几乎一致，理论上来说耗时也应该一样(实际测试也是如此)。在图中显示它耗时略长，我猜测有可能是测试者在每次加解锁的前后还附带了变量的初始化和销毁操作。</p>
<h1 id="nsrecursivelock">NSRecursiveLock</h1>
<p>上文已经说过，递归锁也是通过 <code>pthread_mutex_lock</code> 函数来实现，在函数内部会判断锁的类型，如果显示是递归锁，就允许递归调用，仅仅将一个计数器加一，锁的释放过程也是同理。</p>
<p><code>NSRecursiveLock</code> 与 <code>NSLock</code> 的区别在于内部封装的 <code>pthread_mutex_t</code> 对象的类型不同，前者的类型为 <code>PTHREAD_MUTEX_RECURSIVE</code>。</p>
<h1 id="nsconditionlock">NSConditionLock</h1>
<p><code>NSConditionLock</code> 借助 <code>NSCondition</code> 来实现，它的本质就是一个生产者-消费者模型。“条件被满足”可以理解为生产者提供了新的内容。<code>NSConditionLock</code> 的内部持有一个 <code>NSCondition</code> 对象，以及 <code>_condition_value</code> 属性，在初始化时就会对这个属性进行赋值:</p>
<pre><code>// 简化版代码
- (id) initWithCondition: (NSInteger)value {
if (nil != (self = )) {
_condition =
_condition_value = value;
}
return self;
}
</code></pre>
<p>它的 <code>lockWhenCondition</code> 方法其实就是消费者方法:</p>
<pre><code>- (void) lockWhenCondition: (NSInteger)value {
;
while (value != _condition_value) {
;
}
}
</code></pre>
<p>对应的 <code>unlockWhenCondition</code> 方法则是生产者，使用了 <code>broadcast</code> 方法通知了所有的消费者:</p>
<pre><code>- (void) unlockWithCondition: (NSInteger)value {
_condition_value = value;
;
;
}
</code></pre>
<h1 id="synchronized">@synchronized</h1>
<p>这其实是一个 OC 层面的锁， 主要是通过牺牲性能换来语法上的简洁与可读。</p>
<p>我们知道 @synchronized 后面需要紧跟一个 OC 对象，它实际上是把这个对象当做锁来使用。这是通过一个哈希表来实现的，OC 在底层使用了一个互斥锁的数组(你可以理解为锁池)，通过对对象去哈希值来得到对应的互斥锁。</p>
<p>具体的实现原理可以参考这篇文章: 关于 @synchronized，这儿比你想知道的还要多</p>
<h1 id="参考资料">参考资料</h1>
<ol>
<li>pthread<em>mutex</em>lock</li>
<li>ThreadSafety</li>
<li>Difference between binary semaphore and mutex</li>
<li>关于 @synchronized，这儿比你想知道的还要多</li>
<li>pthread<em>mutex</em>lock.c 源码</li>
<li> Linux中的线程同步机制(二)--In Glibc</li>
<li>pthread的各种同步机制</li>
<li>pthread<em>cond</em>wait</li>
<li>Conditional Variable vs Semaphore</li>
</ol>
<p>点击此处，立即与iOS大牛交流学习</p><br><br>
来源：https://www.cnblogs.com/chengxyyh/p/13162834.html
頁:
[1]