自旋锁死锁

自旋锁死锁

自旋锁内调用kmalloc或者copy_to_user之类的接口可能造成死锁。

这类函数的实现内有睡眠操作，睡眠时产生了进程调度,新的进程内如果也使用了该自旋锁，就会导致死锁。

 

这类问题非常普通，但很容易忽略；

屏蔽的方式：

1，使用get_free_page申请内存

2，对资源使用引用计数保护

3，使用互斥锁

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

阅读目录

• 自旋锁(Spin lock)
•  两种锁的加锁原理
• 两种锁的区别
• 两种锁的应用
• C#中的互斥锁与自旋锁

 

自旋锁(Spin lock)

自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是 否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。其作用是为了解决某项资源的互斥使用。因为自旋锁不会引起调用者睡眠，所以自旋锁的效率远 高于互斥锁。虽然它的效率比互斥锁高，但是它也有些不足之处：
    1、自旋锁一直占用CPU，他在未获得锁的情况下，一直运行－－自旋，所以占用着CPU，如果不能在很短的时 间内获得锁，这无疑会使CPU效率降低。
    2、在用自旋锁时有可能造成死锁，当递归调用时有可能造成死锁，调用有些其他函数也可能造成死锁，如 copy_to_user()、copy_from_user()、kmalloc()等。

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

 

 两种锁的加锁原理

互斥锁：线程会从sleep（加锁）——>running（解锁），过程中有上下文的切换，cpu的抢占，信号的发送等开销。

自旋锁：线程一直是running(加锁——>解锁)，死循环检测锁的标志位，机制不复杂。

 

互斥锁属于sleep-waiting类型的锁。例如在一个双核的机器上有两个线程(线程A和线程B)，它们分别运行在Core0和 Core1上。假设线程A想要通过pthread_mutex_lock操作去得到一个临界区的锁，而此时这个锁正被线程B所持有，那么线程A就会被阻塞 (blocking)，Core0 会在此时进行上下文切换(Context Switch)将线程A置于等待队列中，此时Core0就可以运行其他的任务(例如另一个线程C)而不必进行忙等待。而自旋锁则不然，它属于busy-waiting类型的锁，如果线程A是使用pthread_spin_lock操作去请求锁，那么线程A就会一直在 Core0上进行忙等待并不停的进行锁请求，直到得到这个锁为止。

 

两种锁的区别

互斥锁的起始原始开销要高于自旋锁，但是基本是一劳永逸，临界区持锁时间的大小并不会对互斥锁的开销造成影响，而自旋锁是死循环检测，加锁全程消耗cpu，起始开销虽然低于互斥锁，但是随着持锁时间，加锁的开销是线性增长。

 

两种锁的应用

互斥锁用于临界区持锁时间比较长的操作，比如下面这些情况都可以考虑

1 临界区有IO操作

2 临界区代码复杂或者循环量大

3 临界区竞争非常激烈

4 单核处理器

至于自旋锁就主要用在临界区持锁时间非常短且CPU资源不紧张的情况下，自旋锁一般用于多核的服务器。

以上 本文来源：http://blog.csdn.net/susidian/article/details/51068858

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

   spin_lock

   pthread_spin_lock

    自旋锁(spinlock)是一种常用的互斥同步原语，当试图进入临界区的线程使用忙等待的方式检测锁的状态，若锁未被持有则尝试获取。这种忙等待的做法无谓的消耗了处理器资源，故只适合用于临界区非常小的代码片段，如linux下的中断处理函数。

    posix 已经实现了自旋锁相关的API,其主要包括 pthread_spin_lock,pthread_spin_trylock,pthread_spin_unlock。从实现的原理上来说，它属于busy-waiting类型的锁。假设一双核的机器上有两个线程（线程a,b），他们分别运行在core0,core1上，当线程a使用pthread_spin_lock去请求锁，那么线程a就会在core0上进行忙等待并不停的进行锁请求，直到得到这个锁为止。与mutex锁不同的是，线程a通过pthread_mutex_lock操作区得到一个临界区的时候，如果此时临界区被线程b所持有，那么线程a就会阻塞，core0 会进行上下文切换将线程a置于等待队列中，此时core0就可以运行其他的任务。可见spin_lock的好处是省去用户态切换与内核态的切换。

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

最近在内核频繁使用了自旋锁，自旋锁如果使用不当，极易引起死锁，在此总结一下。

自旋锁是一个互斥设备，它只有两个值：“锁定”和“解锁”。它通常实现为某个整数值中的某个位。希望获得某个特定锁的代码测试相关的位。如果锁可用，则“锁定”被设置，而代码继续进入临界区；相反，如果锁被其他人获得，则代码进入忙循环（而不是休眠，这也是自旋锁和一般锁的区别）并重复检查这个锁，直到该锁可用为止，这就是自旋的过程。“测试并设置位”的操作必须是原子的，这样，即使多个线程在给定时间自旋，也只有一个线程可获得该锁。

自旋锁最初是为了在多处理器系统（SMP）使用而设计的，但是只要考虑到并发问题，单处理器在运行可抢占内核时其行为就类似于SMP。因此，自旋锁对于SMP和单处理器可抢占内核都适用。可以想象，当一个处理器处于自旋状态时，它做不了任何有用的工作，因此自旋锁对于单处理器不可抢占内核没有意义，实际上，非抢占式的单处理器系统上自旋锁被实现为空操作，不做任何事情。

自旋锁有几个重要的特性：（HY：不能休眠、中断、抢占，还要短，可以把自旋锁之间的代码想象成一个大的原子操作）

1、被自旋锁保护的临界区代码执行时不能进入休眠。

2、被自旋锁保护的临界区代码执行时是不能被被其他中断中断。

3、被自旋锁保护的临界区代码执行时，内核不能被抢占。

从这几个特性可以归纳出一个共性：被自旋锁保护的临界区代码执行时，它不能因为任何原因放弃处理器。

考虑上面第一种情况，想象你的内核代码请求到一个自旋锁并且在它的临界区里做它的事情，在中间某处，你的代码失去了处理器。或许它已调用了一个函数（copy_from_user，假设）使进程进入睡眠。也或许，内核抢占发威（HY：抢占时机是？），一个更高优先级的进程将你的代码推到了一边。此时，正好某个别的线程想获取同一个锁，如果这个线程运行在和你的内核代码不同的处理器上（幸运的情况），那么它可能要自旋等待一段时间（可能很长），当你的代码从休眠中唤醒或者重新得到处理器并释放锁，它就能得到锁。而最坏的情况是，那个想获取锁得线程刚好和你的代码运行在同一个处理器上，这时它将一直持有CPU进行自旋操作，而你的代码是永远不可能有任何机会来获得CPU释放这个锁了，这就是悲催的死锁。

考虑上面第二种情况，和上面第一种情况类似。假设我们的驱动程序正在运行，并且已经获取了一个自旋锁，这个锁控制着对设备的访问。在拥有这个锁得时候，设备产生了一个中断，它导致中断处理例程被调用，而中断处理例程在访问设备之前，也要获得这个锁。当中断处理例程和我们的驱动程序代码在同一个处理器上运行时，由于中断处理例程持有CPU不断自旋，我们的代码将得不到机会释放锁，这也将导致死锁。

因此，如果我们有一个自旋锁，它可以被运行在（硬件或软件）中断上下文中的代码获得，则必须使用某个禁用中断的spin_lock形式的锁来禁用本地中断（注意，只是禁用本地CPU的中断，不能禁用别的处理器的中断），使用其他的锁定函数迟早会导致系统死锁（导致死锁的时间可能不定，但是发生上述死锁情况的概率肯定是有的，看处理器怎么调度了）。如果我们不会在硬中断处理例程中访问自旋锁，但可能在软中断（例如，以tasklet的形式运行的代码）中访问，则应该使用spin_lock_bh，以便在安全避免死锁的同时还能服务硬件中断。

补充：

锁定一个自旋锁的函数有四个：

void spin_lock(spinlock_t *lock);      

最基本得自旋锁函数，它不失效本地中断。

void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);

在获得自旋锁之前禁用硬中断（只在本地处理器上），而先前的中断状态保存在flags中

void spin_lockirq(spinlock_t *lock);

在获得自旋锁之前禁用硬中断（只在本地处理器上），不保存中断状态

void spin_lock_bh(spinlock_t *lock);

在获得锁前禁用软中断，保持硬中断打开状态

原文链接：https://blog.csdn.net/vividonly/article/details/6594195

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

单处理器环境的自旋锁

单处理器环境不需要自旋锁，调用了自旋锁的函数，里面也不是自旋锁的实现，只不过是用了层壳而已

原因是：

如果是非抢占的系统：（高优先级的进程不能中止正在内核中运行的低优先级的进程而抢占CPU运行。进程一旦处于核心态(例如用户进程执行系统调用)，则除非进程自愿放弃CPU，否则该进程将一直运行下去，直至完成或退出内核。）

一个进程（进入到了内核态），或者线程用了自旋锁，没有执行完毕之前，没有别的进程或者内核线程跟他抢，即使是时间片到了之 后，接着还是分给本进程或者线程。

如果是软中断或者是中断打断了怎么办？ 没关系，关中断即可。也就是说，这时自旋锁退化成关开中断

 

如果是抢占的系统：（即当进程位于内核空间时，有一个更高优先级的任务出现时，如果当前内核允许抢占，则可以将当前任务挂起，执行优先级更高的进程。）

自旋锁的定义变成非抢占即可，这时高优先级进程就没法跟他抢了。中断是一样的处理。

 

总之，单处理器来说，非抢占的话，自旋锁退化为 关开中断；

对于抢占来说，自旋锁变成  禁止/打开抢占+关开中断