自旋锁和互斥锁的区别

喜欢ヅ旅行 2022-06-05 11:14 241阅读 0赞

# 自旋锁和互斥锁的区别 #

POSIX threads(简称Pthreads)是在多核平台上进行并行编程的一套API。线程同步是并行编程中非常重要的通讯手段，其中最典型的应用就是用

Pthreads提供的锁机制(lock)来对多个线程之间的共享临界区(Critical Section)进行保护(另一种常用的同步机制是barrier)。

Pthreads提供了多种锁机制：

*  Mutex(互斥量)：pthread\_mutex\_t
 *  Spin lock(自旋锁): pthread\_spin\_t
 *  Condition Variable(条件变量): pthread\_cond\_t
 *  Read/Write lock(读写锁)：pthread\_rwlock\_t

Pthreads提供的Mutex锁操作相关的API主要有：

*  pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);
 *  pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex);
 *  pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);

Pthreads提供的Spin Lock锁操作相关的API主要有：

*  pthread\_spin\_lock(pthread\_spinlock\_t \*lock);
 *  pthread\_spin\_trylock(pthread\_spinlock\_t \*lock);
 *  pthread\_spin\_unlock(pthread\_spinlock\_t \*lock);

从实现原理上来讲，**Mutex（互斥锁）属于sleep-waiting类型的锁**。例如在一个双核的机器上有两个线程（线程A和线程B）,它们分别运行在Core0和Core1上。假设线程A想要通过pthread\_mutex\_lock操作去得到一个临界区的锁，而此时这个锁正被线程B所持有，那么线程A就会被阻塞，

Core0会在此时进行上下文切换(Context Switch)将线程A置于等待队列中，此时Core0就可以运行其它的任务而不必进行忙等待。而**Spin lock（自旋锁）**则不然，它属于**busy-waiting类型的锁**，如果线程A是使用pthread\_spin\_lock操作去请求锁，那么线程A就会一直在Core0上进行忙等待并不停的进行锁请求，直到得到这个锁为止。

**自旋锁（Spin lock）**

自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，**“自旋锁”的作用是为了解决某项资源的互斥使用。因为自旋锁不会引起调用者睡眠，所以自旋锁的效率远高于互斥锁。**

自旋锁的不足之处：

**自旋锁一直占用着CPU，他在未获得锁的情况下，一直运行（自旋），所以占用着CPU，如果不能在很短的时间内获得锁，这无疑会使CPU效率降低。**

在用自旋锁时有可能造成死锁，当递归调用时有可能造成死锁，调用有些其他函数也可能造成死锁，如 copy\_to\_user()、copy\_from\_user()、kmalloc()等。

因此我们要慎重使用自旋锁，自旋锁只有在内核可抢占式或SMP的情况下才真正需要，在单CPU且不可抢占式的内核下，自旋锁的操作为空操作。自旋锁适用于锁使用者保持锁时间比较短的情况下。

##  ##

#  #

## 自旋锁-原理 ##

跟[互斥锁][Link 1]一样，一个执行单元要想访问被自旋锁保护的共享资源，必须**先得到锁，在访问完共享资源后，必须释放锁**。如果在获取自旋锁时，没有任何执行单元保持该锁，那么将立即得到锁;如果在获取自旋锁时锁已经有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁。由此我们可以看出，自旋锁是一种比较低级的保护数据结构或代码片段的原始方式，这种锁可能存在两个问题:

1、[死锁][Link 2]。**试图递归地获得自旋锁必然会引起死锁**:递归程序的持有实例在第二个实例循环，以试图获得相同自旋锁时，不会释放此自旋锁。

在递归程序中使用自旋锁应遵守下列策略:

递归程序决不能在持有自旋锁时调用它自己，也决不能在[递归调用][Link 3]时试图获得相同的自旋锁。此外如果一个进程已经将资源锁定，那么，即使其它申请这个资源的进程不停地疯狂"自旋",也无法获得资源，从而进入死循环。

2、过多占用cpu资源。如果不加限制，由于申请者一直在循环等待，因此自旋锁在锁定的时候,如果不成功,不会睡眠,会持续的尝试,单cpu的时候自旋锁会让其它process动不了. 因此，一般自旋锁实现会有一个参数限定最多持续尝试次数. 超出后, 自旋锁放弃当前time slice. 等下一次机会

由此可见，**自旋锁**比较**适用于**锁使用者**保持锁时间比较短**的情况。正是由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于[互斥锁][Link 1]。[信号量][Link 4]和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在[进程上下文][Link 5]使用，而自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用。如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适，如果对共享资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问(包括底半部即[中断处理][Link 6]句柄和顶半部即[软中断][Link 7])，就必须使用自旋锁。**自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的**。自旋锁只有在[内核][Link 8]可抢占或[SMP][](多处理器)的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作，

转自：https://www.cnblogs.com/guagua2016/p/6068925.html

https://baike.so.com/doc/9186718-9519957.html

\------------------------------------------------------------

# 自旋锁 互斥锁 读写锁 递归锁 #

#### 互斥锁(mutexlock)： ####

最常使用于线程同步的锁；标记用来保证在任一时刻，只能有一个线程访问该对象，**同一线程多次加锁操作会造成死锁**；临界区和互斥量都可用来实现此锁，通常情况下锁操作失败会将该线程睡眠等待锁释放时被唤醒

自旋锁(spinlock)：

同样用来标记只能有一个线程访问该对象，在同一线程多次加锁操作会造成死锁；使用硬件提供的swap指令或test\_and\_set指令实现；同互斥锁不同的是在锁操作需要等待的时候并不是睡眠等待唤醒，而是循环检测保持者已经释放了锁，这样做的好处是节省了线程从睡眠状态到唤醒之间内核会产生的消耗，在加锁时间短暂的环境下这点会提高很大效率

读写锁(rwlock)：

高级别锁，区分读和写，符合条件时允许多个线程访问对象。处于读锁操作时可以允许其他线程和本线程的读锁， 但不允许写锁， 处于写锁时则任何锁操作都会睡眠等待；常见的操作系统会在写锁等待时屏蔽后续的读锁操作以防写锁被无限孤立而等待，在操作系统不支持情况下可以用引用计数加写优先等待来用互斥锁实现。 读写锁适用于大量读少量写的环境，但由于其特殊的逻辑使得其效率相对普通的互斥锁和自旋锁要慢一个数量级；值得注意的一点是按POSIX标准 在线程申请读锁并未释放前本线程申请写锁是成功的，但运行后的逻辑结果是无法预测

递归锁(recursivelock)：

严格上讲递归锁只是互斥锁的一个特例，同样只能有一个线程访问该对象，但允许同一个线程在未释放其拥有的锁时反复对该锁进行加锁操作； windows下的临界区默认是支持递归锁的，而linux下的互斥量则需要设置参数PTHREAD\_MUTEX\_RECURSIVE\_NP，默认则是不支持

大读者锁（brlock-Big Reader Lock）

大读者锁是读写锁的高性能版，读者可以非常快地获得锁，但写者获得锁的开销比较大。大读者锁只存在于2.4内核中，在2.6中已经没有这种锁（提醒读者特别注意）。它们的使用与读写锁的使用类似，只是所有的大读者锁都是事先已经定义好的。这种锁适合于读多写少的情况，它在这种情况下远好于读写锁。

大读者锁的实现机制是：每一个大读者锁在所有CPU上都有一个本地读者写者锁，一个读者仅需要获得本地CPU的读者锁，而写者必须获得所有CPU上的锁。

大读者锁的API非常类似于读写锁，只是锁变量为预定义的锁ID。

大内核锁（BKL--Big Kernel Lock）

大内核锁本质上也是自旋锁，但是它又不同于自旋锁，自旋锁是不可以递归获得锁的，因为那样会导致死锁。但大内核锁可以递归获得锁。大内核锁用于保护整个内核，而自旋锁用于保护非常特定的某一共享资源。进程保持大内核锁时可以发生调度，具体实现是：在执行schedule时，schedule将检查进程是否拥有大内核锁，如果有，它将被释放，以致于其它的进程能够获得该锁，而当轮到该进程运行时，再让它重新获得大内核锁。注意在保持自旋锁期间是不运行发生调度的。

需要特别指出，整个内核只有一个大内核锁，其实不难理解，内核只有一个，而大内核锁是保护整个内核的，当然有且只有一个就足够了。

还需要特别指出的是，大内核锁是历史遗留，内核中用的非常少，一般保持该锁的时间较长，因此不提倡使用它。从2.6.11内核起，大内核锁可以通过配置内核使其变得可抢占（自旋锁是不可抢占的），这时它实质上是一个互斥锁，使用信号量实现。

RCU(Read-Copy Update)

RCU(Read-Copy Update)，顾名思义就是读-拷贝修改，它是基于其原理命名的。对于被RCU保护的共享数据结构，读者不需要获得任何锁就可以访问它，但写者在访问它时首先拷贝一个副本，然后对副本进行修改，最后使用一个回调（callback）机制在适当的时机把指向原来数据的指针重新指向新的被修改的数据。这个时机就是所有引用该数据的CPU都退出对共享数据的操作。

RCU也是读写锁的高性能版本，但是它比大读者锁具有更好的扩展性和性能。 RCU既允许多个读者同时访问被保护的数据，又允许多个读者和多个写者同时访问被保护的数据（注意：是否可以有多个写者并行访问取决于写者之间使用的同步机制），读者没有任何同步开销，而写者的同步开销则取决于使用的写者间同步机制。但RCU不能替代读写锁，因为如果写比较多时，对读者的性能提高不能弥补写者导致的损失。

顺序锁（seqlock）

顺序锁也是对读写锁的一种优化，对于顺序锁，读者绝不会被写者阻塞，也就说，读者可以在写者对被顺序锁保护的共享资源进行写操作时仍然可以继续读，而不必等待写者完成写操作，写者也不需要等待所有读者完成读操作才去进行写操作。但是，写者与写者之间仍然是互斥的，即如果有写者在进行写操作，其他写者必须自旋在那里，直到写者释放了顺序锁。

这种锁有一个限制，它必须要求被保护的共享资源不含有指针，因为写者可能使得指针失效，但读者如果正要访问该指针，将导致OOPs。

如果读者在读操作期间，写者已经发生了写操作，那么，读者必须重新读取数据，以便确保得到的数据是完整的。

这种锁对于读写同时进行的概率比较小的情况，性能是非常好的，而且它允许读写同时进行，因而更大地提高了并发性。

转自：http://blog.csdn.net/qq100440110/article/details/51076609

[Link 1]: https://baike.so.com/doc/6150631-6363825.html
[Link 2]: https://baike.so.com/doc/414521-439063.html
[Link 3]: https://baike.so.com/doc/6115126-6328268.html
[Link 4]: https://baike.so.com/doc/6799211-7016022.html
[Link 5]: https://baike.so.com/doc/2315046-2448796.html
[Link 6]: https://baike.so.com/doc/4973549-5196235.html
[Link 7]: https://baike.so.com/doc/7715429-7989524.html
[Link 8]: https://baike.so.com/doc/665564-704577.html
[SMP]: https://baike.so.com/doc/4522250-4732301.html