自旋锁及其衍生锁

最新推荐文章于 2024-08-06 07:00:00 发布
最新推荐文章于 2024-08-06 07:00:00 发布
阅读量541 收藏
点赞数
分类专栏： 初学linux内核 文章标签： 自旋锁 linux内核
本文深入解析自旋锁的概念、工作原理、API函数及其在多处理器系统中的应用，同时介绍读写锁的特性、实现方式以及如何在并发编程中优化性能。详细讨论顺序锁的改进，以及在不同场景下的使用策略。此外，文章还对比了自旋锁与互斥锁的区别，并给出在不同情况下的推荐锁类型选择。
摘要由CSDN通过智能技术生成

自旋锁

自旋锁（spinlock）是用在多个CPU系统中的锁机制，当一个CPU正访问自旋锁保护的临界区时，临界区将被锁上，其他需要访问此临界区的CPU只能忙等待，直到前面的CPU已访问完临界区，将临界区开锁。自旋锁上锁后让等待线程进行忙等待而不是睡眠阻塞，而信号量是让等待线程睡眠阻塞。自旋锁的忙等待浪费了处理器的时间，但时间通常很短，在1毫秒以下。

   

自旋锁用于多个CPU系统中，在单处理器系统中，自旋锁不起锁的作用，只是禁止或启用内核抢占。在自旋锁忙等待期间，内核抢占机制还是有效的，等待自旋锁释放的线程可能被更高优先级的线程抢占CPU。

   

自旋锁基于共享变量。一个线程通过给共享变量设置一个值来获取锁，其他等待线程查询共享变量是否为0来确定锁现是否可用，然后在忙等待的循环中"自旋"直到锁可用为止。

   

通用自旋锁

自旋锁的状态值为1表示解锁状态，说明有1个资源可用；0或负值表示加锁状态，0说明可用资源数为0。Linux内核为通用自旋锁提供了API函数初始化、测试和设置自旋锁。API函数功能说明如下。

宏定义功能说明
spin_lock_init(lock)初始化自旋锁，将自旋锁设置为1，表示有一个资源可用。
spin_is_locked(lock)如果自旋锁被置为1（未锁），返回0，否则返回1。
spin_unlock_wait(lock)等待直到自旋锁解锁（为1），返回0；否则返回1。
spin_trylock(lock)尝试锁上自旋锁（置0），如果原来锁的值为1，返回1，否则返回0。
spin_lock(lock)循环等待直到自旋锁解锁（置为1），然后，将自旋锁锁上（置为0）。
spin_unlock(lock)将自旋锁解锁（置为1）。
spin_lock_irqsave(lock, flags)循环等待直到自旋锁解锁（置为1），然后，将自旋锁锁上（置为0）。关中断，将状态寄存器值存入flags。
spin_unlock_irqrestore(lock, flags)将自旋锁解锁（置为1）。开中断，将状态寄存器值从flags存入状态寄存器。
spin_lock_irq(lock)循环等待直到自旋锁解锁（置为1），然后，将自旋锁锁上（置为0）。关中断。
spin_unlock_irq(lock)将自旋锁解锁（置为1）。开中断。
spin_unlock_bh(lock)将自旋锁解锁（置为1）。开启底半部的执行。
spin_lock_bh(lock)循环等待直到自旋锁解锁（置为1），然后，将自旋锁锁上（置为0）。阻止软中断的底半部的执行。

自旋锁用结构spinlock_t描述，在include/linux/spinlock.h中有类型 spinlock_t定义，列出如下：

[cpp]  view plain copy
  1. typedef struct {  
  2.     raw_spinlock_t raw_lock;  
  3. #ifdef CONFIG_GENERIC_LOCKBREAK /*引入另一个自旋锁*/  
  4.     unsigned int break_lock;  
  5. #endif  
  6. #ifdef CONFIG_DEBUG_SPINLOCK /*用于调试自旋锁*/  
  7.     unsigned int magic, owner_cpu;  
  8.     void *owner;  
  9. #endif  
  10. #ifdef CONFIG_DEBUG_LOCK_ALLOC  
  11.     struct lockdep_map dep_map; /*映射lock实例到lock-class对象  
  12. #endif  
  13. } spinlock_t;  

由于自旋锁的性能严重地影响着操作系统的性能，Linux内核提供了Lock-class和Lockdep跟踪自旋锁的使用对象和锁的状态，并可从/proc文件系统查询自旋锁的状态信息。自旋锁的调试通过配置项CONFIG_DEBUG_*项打开。   

对于对称多处理器系统（SMP），slock为一个int数据类型，对于单个处理器系统，slock定义为空。SMP的slock定义列出如下（在include/linux/spinlock_types.h）：

[cpp]  view plain copy
  1. typedef struct {  
  2.     volatile unsigned int slock;  
  3. } raw_spinlock_t;  

自旋锁的实现机制类型

spin_lock_init

函数spin_lock_init将自旋锁状态值设置为1，表示未锁状态。其列出如下（在include/linux/spinlock.h中）：

[cpp]  view plain copy
  1. # define spin_lock_init(lock)                    /  
  2.     do { *(lock) = SPIN_LOCK_UNLOCKED; } while (0)  
  3.      
  4. 宏__SPIN_LOCK_UNLOCKED列出如下（在include/linux/spinlock_types.h中）：  
  5. # define __SPIN_LOCK_UNLOCKED(lockname) /  
  6.     (spinlock_t)    {    .raw_lock = __RAW_SPIN_LOCK_UNLOCKED,    /  
  7.                 SPIN_DEP_MAP_INIT(lockname) }  
  8.    
  9. #define __RAW_SPIN_LOCK_UNLOCKED    { 1 }  
  

spin_lock_irqsave

函数spin_lock_irqsave等待直到自旋锁解锁，即自旋锁值为1，它还关闭本地处理器上的中断。其列出如下（在include/linux/spinlock.h中）：

[cpp]  view plain copy
  1. #define spin_lock_irqsave(lock, flags)    flags = _spin_lock_irqsave(lock)  

 

函数spin_lock_irqsave分析如下（在kernel/spinlock.c中）：

[cpp]  view plain copy
  1. unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)  
  2. {  
  3.     unsigned long flags;  
  4.    
  5.     local_irq_save(flags); //将状态寄存器的值写入flags保存  
  6.     preempt_disable(); //关闭内核抢占，内核抢占锁加1  
  7.     spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);  
  8.    
  9. #ifdef CONFIG_LOCKDEP  
  10.     LOCK_CONTENDED(lock, _raw_spin_trylock, _raw_spin_lock);  
  11. #else  
  12.     _raw_spin_lock_flags(lock, &flags);  
  13. #endif  
  14.     return flags;  
  15. }  

spin_unlock_irqrestore

宏定义spin_unlock_irqrestore是解锁，开中断，并把flags值存入到状态寄存器中，这个宏定义分析如下：

[cpp]  view plain copy
  1. #define spin_unlock_irqrestore(lock, flags)    _spin_unlock_irqrestore(lock, flags)  

函数_spin_unlock_irqrestore列出如下（在kernel/spinlock.c中）：   

[cpp]  view plain copy
  1. void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)  
  2. {  
  3.     spin_release(&lock->dep_map, 1, _RET_IP_);  
  4.     _raw_spin_unlock(lock); //解锁  
  5.     local_irq_restore(flags); //开中断，将flag的值存入状态寄存器  
  6.     preempt_enable(); //开启内核抢占  
  7. }  
  8.    
  9. # define _raw_spin_unlock(lock)        __raw_spin_unlock(&(lock)->raw_lock)  
   

函数__raw_spin_unlock将自旋锁状态值加1，表示有1个资源可用，从而释放自旋锁，其列出如下（在include/asm-x86/spinlock.h中）：

[cpp]  view plain copy
  1. static __always_inline void __raw_spin_unlock(raw_spinlock_t *lock)  
  2. {  
  3.     asm volatile(UNLOCK_LOCK_PREFIX "incw %0" // lock->slock= lock->slock +1  
  4.          : "+m" (lock->slock)  
  5.          :  
  6.          : "memory", "cc");  
  7. }  

读/写自旋锁

"读/写自旋锁"用来解决读者/写者问题。如果有多个线程（进程、中断处理程序、底半部例程）以只读的方式访问一个临界区数据，读/写自旋锁允许多个线程同时读取数据。如果一个线程需要对临界区数据进行写操作，它必须获取写锁，只有在没有读者或写者进行操作时，写者才独占临界区数据进行写操作。读操作时需要获取读锁，写操作时需要获取写锁。

   

Linux内核为读/写自旋锁提供了操作API函数初始化、测试和设置自旋锁。API函数功能说明如下：

宏定义功能说明
rwlock_init(lock)初始化自旋锁值为0x01000000（未锁）。
read_lock(lock)加读者锁，即将读者计数加1。
read_lock_irqsave(lock, flags)加读者锁，即将读者计数加1。并且关中断，存储状态标识到flags中。
read_lock_irq(lock)加读者锁，即将读者计数加1。并且关中断。
read_unlock(lock)解读者锁，即将读者计数减1。
read_unlock_irqrestore(lock, flags)解读者锁，即将读者计数减1。并且开中断，将状态标识从flags读到状态寄存器中。
read_unlock_irq(lock)解读者锁，即将读者计数减1。并且开中断。
write_lock(lock)加写者锁，即将写者锁置0。
write_lock_irqrestore(lock, flags)加写者锁，即将写者锁置0。并且关中断，存储状态标识到flags中。
write_lock_irq(lock)加写者锁，即将写者锁置0。并且关中断。
write_unlock(lock)解写者锁，即将写者锁置1。
write_unlock_irqrestore(lock, flags)解写者锁，即将写者锁置1。并且开中断，将状态标识从flags读到状态寄存器中。
write_unlock_irq(lock)解写者锁，即将写者锁置1。并且开中断。

用户使用读/写自旋锁，应先自旋锁的状态值初始化为锁初始化为RW_LOCK_BIAS，即0x01000000，表示为未锁状态。

   

读/写自旋锁用结构rwlock_t描述，它的主要成员为锁状态值变量lock，结构rwlock_t列出如下（在include/linux/spinlock_types.h中）：

[cpp]  view plain copy
  1. typedef struct {  
  2.     raw_rwlock_t raw_lock;  
  3. ……  
  4. } rwlock_t;  
  5.    
  6. typedef struct {  
  7.     unsigned int lock;  
  8. } raw_rwlock_t;  

 

在结构raw_rwlock_t中，读/写自旋锁状态变量lock为32位，它分为2个部分，0~23位是一个24位计数器，表示对临界数据区进行并发读操作的线程数，线程数以补码形式存入计数器；第24位为表示"未锁"的状态位，在没有线程读或写临界区时，设置为1，否则，设置为0。

   

如果自旋锁设置了"未锁"状态且无读者，那么lock值为0x01000000；如果写者已获得自旋锁且无读者，则未锁状态位清0，lock值为0x00000000。如果有一个、2个或多个线程获取锁对临界数据区进行读操作，则lock值为0x00ffffff、0x00fffffe等（第24位清0表示未锁，第0~23位为读者个数的补码）。

   

下面说明读/写自旋锁API函数的实现：

rwlock_init

函数rwlock_init将读/写自旋锁状态值设为0x01000000，其列出如下（在include/linux/spinlock.h中）：   

[cpp]  view plain copy
  1. # define rwlock_init(lock)                    /  
  2.     do { *(lock) = RW_LOCK_UNLOCKED; } while (0)  
  3.    
  4. #define RW_LOCK_UNLOCKED    __RW_LOCK_UNLOCKED(old_style_rw_init)  
  5. #define __RW_LOCK_UNLOCKED(lockname) /  
  6.     (rwlock_t)    {    .raw_lock = __RAW_RW_LOCK_UNLOCKED,    /  
  7.                 RW_DEP_MAP_INIT(lockname) }  
  8.    
  9. #define __RAW_RW_LOCK_UNLOCKED        { RW_LOCK_BIAS }  
  10. #define RW_LOCK_BIAS        0x01000000  

 read_lock和read_unlock

函数read_lock用于加读者锁，函数read_unlock用于解读者锁，两函数需要配对使用。下面分别进行说明：

   

函数read_lock

读/写自旋锁lock空闲值为0x01000000，当有一个读者进行读操作时，它加读者锁，执行运算lock=lock-1，lock值为0x00ffffff；当接着有第二个读者进行读操作时，可以进行并发的读，再执行运算lock=lock-1，lock值为0x00fffffe；依此类推，可支持多个读者同时读操作。

   

如果在读操作正进行（如：有2个读者正进行操作，lock值为0x00fffffe）时，有一个写者请求写操作时，写操作必须等待读者全部完成操作，每个读者完成操作时，执行运算lock=lock+1，当2个读者的操作完成后，lock值为0x01000000，表示写锁空闲，可以进行写操作或并发的读操作。

   

如果一个写操作正进行时，执行运算lock=lock-0x01000000，lock值为0x00000000，表示写者锁已加锁，另一个写者无法对临界区数据进行访问。此时，如果有一个读者进行读操作请求时，执行运算lock=lock-1，结果为负数，则状态寄存器符号位置为1，加读者锁失败，将lock还原（lock=lock+1），读者循环等待，直到写操作完成（即lock值为0x01000000）时。

   

写操作完成时，lock值为0x01000000，表示写锁空闲，可以进行写操作或并发的读操作。这时，正等待的读者执行运算lock=lock-1，结果为0x00ffffff，则状态寄存器符号位置为0，跳出加读者锁的等待循环，加锁成功，读者进行读操作。

   

函数read_lock关闭内核抢占，加读者锁，即将读者数增加1，其列出如下（在include/linux/spinlock.h中）：   

[cpp]  view plain copy
  1. #define read_lock(lock)            _read_lock(lock)  

   

函数_read_lock列出如下（在kernel/spinlock.c中）：   

[cpp]  view plain copy
  1. void __lockfunc _read_lock(rwlock_t *lock)  
  2. {  
  3.     preempt_disable(); //关闭内核抢占  
  4.     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); /*用于自旋锁调试*/  
  5. /*下面语句相当于_raw_read_lock（lock）*/  
  6.     LOCK_CONTENDED(lock, _raw_read_trylock, _raw_read_lock);  
  7. }  
  8. # define _raw_read_lock(rwlock)        __raw_read_lock(&(rwlock)->raw_lock)  

函数__raw_read_lock增加读锁，即锁状态值rw减1，由于读者计数以补码形式存放在锁状态值中，因此，减1表示读者计数增加1。其列出如下（在include/asm-x86/spinglock.h中）：   

[cpp]  view plain copy
  1. static inline void __raw_read_lock(raw_rwlock_t *rw)  
  2. {  
  3.     asm volatile(LOCK_PREFIX " subl $1,(%0)/n/t" //*rw=*rw-1  
  4.          "jns 1f/n" //如果符号位为0，跳转到1  
  5.          "call __read_lock_failed/n/t"  
  6.          "1:/n"  
  7.          ::LOCK_PTR_REG (rw) : "memory");  
  8. }  

函数__read_lock_failed进行加读者锁失败后的循环等待操作。加读者锁失败，说明有一个写者正在写操作，因此，锁状态值为*rw=0x00000000，函数__raw_read_lock在执行*rw=*rw-1后，rw值为0xffffffff，即传入函数__read_lock_failed的rw值为0xffffffff。

   

函数__read_lock_failed执行*rw=*rw+1后，锁状态值为*rw=0x00000000，然后，进入循环等待状态，直到，写者完成写操作后将锁状态值*rw置为0x01000000。这时，函数__read_lock_failed才跳出循环等待状态，加读者锁成功。

   

函数__read_lock_failed列出如下（在include/asm-x86/lib/rwlock_64.h中）：

[cpp]  view plain copy
  1. /* rdi指向rwlock_t */  
  2. ENTRY(__read_lock_failed)  
  3.     CFI_STARTPROC //即：#define CFI_STARTPROC .cfi_startproc  
  4.     LOCK_PREFIX  
  5.     incl (%rdi) // *rw=*rw+1，值为0x00000000  
  6. 1:    rep //循环等待*rw值被写者修改为0x01000000  
  7.     nop  
  8.     cmpl $1,(%rdi) // *rw-1  
  9.     js 1b //如果符号位为1，表明*rw值还为0x00000000，跳转到1进行循环等待  
  10.     LOCK_PREFIX  
  11. /* 运行到这里，说明写者操作完成，*rw值为0x01000000 */  
  12.     decl (%rdi) //执行加读者锁操作*rw＝*rw-1  
  13.     js __read_lock_failed//如果符号位为1，表明*rw值为0x00000000，跳转到函数开头进行循环等待  
  14.     ret  
  15.     CFI_ENDPROC //即：#define CFI_ENDPROC .cfi_endproc  
  16. END(__read_lock_failed)  
  

由于汇编语言程序无法产生帧信息，由用户手动添加指示语句。上述代码中，指示语句.cfi_startproc用于调试时的调用帧信息处理，在每个函数的开始处使用，它在.eh_frame中生成一个条目，初始化一些内部数据结构，并发出构架依赖的初始CFI（Call Frame Information）指令。在函数结束处使用.cfi_endproc关闭该功能。


函数read_unlock

函数read_unlock开读者锁，即将锁状态值减1，由于读者计数以补码形式存放在锁状态值中，因此，加1表示读者计数减1。其列出如下

[cpp]  view plain copy
  1. # define read_unlock(lock) /  
  2. do {__raw_read_unlock(&(lock)->raw_lock); __release(lock); } while (0)  
  3. # define __release(x)    __context__(x,-1)  
  4. static inline void __raw_read_unlock(raw_rwlock_t *rw)  
  5. { /* rw->lock= rw->lock +1*/  
  6.     asm volatile(LOCK_PREFIX "incl %0" :"+m" (rw->lock) : : "memory");  
  7. }  

write_lock和write_unlock

函数write_lock和write_unlock分别加写者锁和解写者锁，分别说明如下：

   

函数write_lock

只有在没有读者或写者对临界区数据进行操作时，加写者锁才会成功，即：只有锁状态值lock值为0x01000000时，写者加锁才能成功，执行运行lock=lock-0x01000000运算。

   

当有读者或写者操作临界区数据时，lock值为比0x01000000小的正数，如果值为0x00000000表示有一个写者正在写操作，如果值为0x00ffffff，表示有1个读者在进行读操作，如果值为0x00fffffe，表示有2个读者在进行读操作，依此类推。此时，写者只能循环等待，直到lock值为0x01000000。

   

函数write_lock关闭内核抢占，加写者锁，其列出如下（在include/linux/spinlock.h中）：

[cpp]  view plain copy
  1. #define write_lock(lock)        _write_lock(lock)  


函数_write_lock列出如下（在kernel/spinlock.c中）：

[cpp]  view plain copy
  1. void __lockfunc _write_lock(rwlock_t *lock)  
  2. {  
  3.     preempt_disable(); /*关闭内核抢占*/  
  4.     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); /*用于自旋锁调试*/  
  5. /*下面语句相当于_raw_write_lock(lock)*/  
  6.     LOCK_CONTENDED(lock, _raw_write_trylock, _raw_write_lock);  
  7. }  
  8.    
  9. # define _raw_write_lock(rwlock)    __raw_write_lock(&(rwlock)->raw_lock)  
  10.    
  11. static inline void __raw_write_lock(raw_rwlock_t *rw)  
  12. {  
  13.     asm volatile(LOCK_PREFIX " subl %1,(%0)/n/t" /* RW_LOCK_BIAS-rw*/  
  14. /* 如果没有读者或写者，*rw为0x01000000，RW_LOCK_BIAS-rw为0 */  
  15.          "jz 1f/n" /*值为0，跳转到1*/  
  16.          "call __write_lock_failed/n/t" /*加写者锁失败*/  
  17.          "1:/n"  
  18. /* RW_LOCK_BIAS定义为0x01000000*/  
  19.          ::LOCK_PTR_REG (rw), "i" (RW_LOCK_BIAS) : "memory");  
  20. }  

   

运行函数__write_lock_failed时，说明加写者锁失败。如果加写者锁失败，说明有读者或写者正在访问临界区数据，*rw值为一个小于0x01000000的正数。此时，函数__write_lock_failed循环等待直到，读者或写者完成操作，锁变为空闲，即*rw值为0x01000000。

   

函数__write_lock_failed列出如下（在include/asm-x86/lib/rwlock_64.h中）：   

[cpp]  view plain copy
  1. /* rdi:    pointer to rwlock_t */  
  2. ENTRY(__write_lock_failed)  
  3.     CFI_STARTPROC /*用于调试时将调用帧信息写入 
  4.     LOCK_PREFIX 
  5.     addl $RW_LOCK_BIAS,(%rdi) // *rw=*rw+$RW_LOCK_BIAS，还原为尝试加锁前的状态值 
  6. 1:    rep 
  7.     nop 
  8.     cmpl $RW_LOCK_BIAS,(%rdi) //比较结果 = *rw-$RW_LOCK_BIAS 
  9.     jne 1b //比较结果不为0，说明有写者或读者在访问临界区，跳转到1进行循环等待 
  10.     LOCK_PREFIX //锁内存管理器，确保原子操作 
  11. /*运行到这里，说明锁空闲，*rw值为0x010000，执行加写者锁操作*/  
  12.     subl $RW_LOCK_BIAS,(%rdi) //*rw=*rw-RW_LOCK_BIAS  
  13.     jnz __write_lock_failed /*如果*rw不为0，说明加写者锁失败，跳转到函数头循环等待*/  
  14.     ret  
  15.     CFI_ENDPROC  
  16. END(__write_lock_failed)  


函数write_unlock

函数write_unlock在写者操作完后解写者锁，读/写自旋锁变为空闲，锁状态值lock变为: 0x00000000+0x01000000。以后，读者或写者可以访问临界区数据了。

   

函数write_unlock列出如下：

[cpp]  view plain copy
  1. # define write_unlock(lock) /  
  2. do {__raw_write_unlock(&(lock)->raw_lock); __release(lock); } while (0)  

   

函数_write_unlock列出如下（在kernel/spinlock.c中）：

[cpp]  view plain copy
  1. void __lockfunc _write_unlock(rwlock_t *lock)  
  2. {  
  3.     rwlock_release(&lock->dep_map, 1, _RET_IP_);  
  4.     _raw_write_unlock(lock);  
  5.     preempt_enable(); /*打开内核抢占*/  
  6. }  
  7.    
  8. # define _raw_write_unlock(rwlock)    __raw_write_unlock(&(rwlock)->raw_lock)  

   

函数__raw_write_unlock开写者锁，即将锁状态值加上RW_LOCK_BIAS，其列出如下（在include/asm-x86/spinlock.h中）：

[cpp]  view plain copy
  1. static inline void __raw_write_unlock(raw_rwlock_t *rw)  
  2. {  
  3.     asm volatile(LOCK_PREFIX "addl %1, %0" /* RW_LOCK_BIAS+rw*/  
  4.          : "+m" (rw->lock) : "i" (RW_LOCK_BIAS) : "memory");  
  5. }  

   

顺序锁

当使用读/写锁时，读者必须等待写者完成时才能读，写者必须等待读者完成时才能写，两者的优先权是平等的。顺序锁是对读/写锁的优化，它允许读写同时进行，提高了并发性，读写操作同时进行的概率较小时，其性能很好。顺序锁对读/写锁进行了下面的改进：

   

写者不会阻塞读者，即写操作时，读者仍可以进行读操作。

写者不需要等待所有读者完成读操作后才进行写操作。

写者与写者之间互斥，即如果有写者在写操作时，其他写者必须自旋等待。

如果在读者进行读操作期间，有写者进行写操作，那么读者必须重新读取数据，确保读取正确的数据。

要求临界区的共享资源不含指针，因为如果写者使指针失效，读者访问该指针，将导致崩溃。

顺序锁实际上由一个自旋锁和一个顺序计数器组成，有的应用已包括自旋锁，只需要一个顺序计数器配合就可以实现顺序锁。针对这两种情况，Linux内核给顺序锁提供了两套API函数。一套API函数为*seq*，完整地实现了顺序锁；另一套API函数为*seqcount*，只包含了顺序计数器，需要与用户的自旋锁配套实现顺序锁。顺序锁API函数的功能说明如下：

函数名功能说明
seqlock_init(x)初始化顺序锁，将顺序计数器置0。
write_seqlock(seqlock_t *sl)加顺序锁，将顺序号加1。写者获取顺序锁s1访问临界区，它使用了函数spin_lock。
write_sequnlock(seqlock_t *sl)解顺序锁，使用了函数spin_unlock，顺序号加1。
write_tryseqlock(seqlock_t *sl)功能上等同于spin_trylock，顺序号加1。
read_seqbegin(const seqlock_t *sl)返回顺序锁s1的当前顺序号，读者没有开锁和释放锁的开销。
read_seqretry(const seqlock_t *sl, unsigned start)检查读操作期间是否有写者访问了共享资源，如果是，读者就需要重新进行读操作，否则，读者成功完成了读操作。
seqcount_init(x)初始化顺序号。
read_seqcount_begin(const seqcount_t *s)读者在读操作前用此函数获取当前的顺序号。
read_seqcount_retry(const seqcount_t *s, unsigned start)读者在访问完后调用此函数检查在读期间是否有写者访问临界区。如果有，读者需要重新进行读操作，否则，完成读操作。
write_seqcount_begin(seqcount_t *s)写者在访问临界区前调用此函数将顺序号加1，以便读者检查是否在读期间有写者访问过。
write_seqcount_end(seqcount_t *s)写者写完成后调用此函数将顺序号加1，以便读者能检查出是否在读期间有写者访问过。

用户使用顺序锁时，写操作加锁方法与自旋锁一样，但读操作需要使用循环查询，使用顺序锁的读操作样例列出如下（在kernel/time.c中）：

[cpp]  view plain copy
  1. u64 get_jiffies_64(void)  
  2. {  
  3.     unsigned long seq;  
  4.     u64 ret;  
  5.    
  6.     do {  
  7.         seq = read_seqbegin(&xtime_lock); //获取当前的顺序号  
  8.         ret = jiffies_64; //读取临界区数据  
  9. /*检查seq值与当前顺序号是否相等，若不等，说明有写者开始工作，函数read_seqretry返回1，继续循环*/  
  10.     } while (read_seqretry(&xtime_lock, seq));  
  11.     return ret;  
  12. }  


在非SMP系统上，自旋锁消失，但写者还必须递增顺序变量，因为中断例程可能改变数据的状态。

   

下面分析顺序锁的数据结构及API函数：

   

（1）顺序锁结构seqlock_t

顺序锁用结构seqlock_t描述，它包括顺序计数器sequence和自旋锁lock。结构seqlock_t列出如下（在include/linux/seqlock.h中）：

[cpp]  view plain copy
  1. typedef struct {  
  2.     unsigned sequence;  
  3.     spinlock_t lock;  
  4. } seqlock_t;  

   

在结构seqlock_t中，顺序计数器sequence存放顺序号，每个读者在读数据前后两次读顺序计数器，并检查两次读到的顺序号是否相同。如果不相同，说明新的写者已经开始写并增加了顺序计数器，表明刚读到的数据无效。

   

写者通过调用函数write_seqlock获取顺序锁，将顺序号加1，调用函数write_sequnlock释放顺序锁，再将顺序号加1。这样，写者正在写操作时，顺序号为奇数，写完临界区数据后，顺序号为偶数。

   

读者应以循环查询方法读取临界区数据，读者执行的临界区代码的方法列出如下：

[cpp]  view plain copy
  1. do {  
  2.      seq = read_seqbegin(&foo); //返回当前的顺序号  
  3.     ... //临界区数据操作  
  4. } while (read_seqretry(&foo, seq));  


在上述代码中，读者在读临界区数据之前，先调用函数read_seqbegin获致当前的顺序号，如果顺序号seq为奇数，说明写者正写临界区数据，或者seq值与顺序号当前值不等，表明读者正读时，写者开始写，函数read_seqretry返回1，读者继续循环等待写者完成。

   

（2）顺序锁初始化函数seqlock_init

函数seqlock_init初始化顺序锁，顺序锁实际上由一个自旋锁和一个顺序计数器组成。其列出如下：

[cpp]  view plain copy
  1. #define seqlock_init(x)                    /  
  2.     do {                        /  
  3.         (x)->sequence = 0;            /  
  4.         spin_lock_init(&(x)->lock);        /  
  5.     } while (0)  

   

（3）写者加锁函数write_seqlock

函数write_seqlock加顺序锁。方法是：它先加自旋锁，然后将顺序号加1，此时，顺序号值为奇数。此函数不需要关闭内核抢占，因为自旋锁加锁时已关闭了内核抢占。其列出如下：

[cpp]  view plain copy
  1. static inline void write_seqlock(seqlock_t *sl)  
  2. {  
  3.     spin_lock(&sl->lock);  
  4.     ++sl->sequence;  
  5.     smp_wmb();  
  6. }  

   

（4）写者解锁函数write_sequnlock

函数write_sequnlock表示写者解顺序锁，它将顺序号加1，然后解开自旋锁。此时，顺序号应为偶数。其列出如下（在include/linux/seqlock.h中）：

[cpp]  view plain copy
  1. static inline void write_sequnlock(seqlock_t *sl)  
  2. {  
  3.     smp_wmb(); //加上SMP写内存屏障  
  4.     sl->sequence++; //顺序号加1  
  5.     spin_unlock(&sl->lock); //解开自旋锁  
  6. }  

   

（5）读操作开始时读顺序号函数read_seqbegin

函数read_seqbegin读取顺序号，如果顺序号为奇数，说明写者正在写操作，处理器执行空操作，进行循环等待，否则，函数返回读取的顺序号值。其列出如下：

[cpp]  view plain copy
  1. static __always_inline unsigned read_seqbegin(const seqlock_t *sl)  
  2. {  
  3.     unsigned ret;  
  4.    
  5. repeat:  
  6.     ret = sl->sequence;  
  7.     smp_rmb(); //加上SMP读内存屏障  
  8.     if (unlikely(ret & 1)) { //如果ret & 1为true，表示顺序号为奇数，写者正在写操作  
  9.         cpu_relax(); //空操作  
  10.         goto repeat;  
  11.     }  
  12.    
  13.     return ret;  
  14. }  

   

（6）读操作完成时顺序号检查函数read_seqretry

函数read_seqretry用于读操作完成后检测读的数据是否有效。如果读操作完成后的顺序号与读操作开始前的顺序号不一致，函数返回1，说明有写者更改了临界区数据，因此，调用者必须重新读临界者数据。   

函数read_seqretry列出如下：   

[cpp]  view plain copy
  1. static __always_inline int read_seqretry(const seqlock_t *sl, unsigned start)  
  2. {  
  3.     smp_rmb();//加上SMP读内存屏障  
  4.    
  5.     return (sl->sequence != start); //顺序锁的顺序号值与读操作开始时的顺序号值start不一致  
  6. }  

   

大内核锁

Linux内核因历史原因还保留着大内核锁（Big Kernel Lock，BKL），它在内核中的用途越来越小。大内核锁用于同步整个内核，锁的保持时间较长，严重地影响延迟，不提倡使用。

   

大内核锁本质上是自旋锁，它由一个自旋锁和一个锁深度变量组成。自旋锁不能递归获得锁的，否则导致死锁。大内核锁进行了改进，它可以递归获得锁，还实现了抢占。整个内核只有一个大内核锁，因为内核只有一个，用于保护整个内核。

   

锁深度变量定义列出如下（在include/linux/sched.h）：

[cpp]  view plain copy
  1. struct task_struct {  
  2.     ……  
  3.     int lock_depth;        /* BKL锁深度*/  
  4. ……  
  5. }  

   

自旋锁定义列出如下（在lib/kernel_lock.c中）：   

[cpp]  view plain copy
  1. static __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);  

大内核锁的API函数为lock_kernel(void)和unlock_kernel(void)，函数lock_kernel为获取大内核锁，可以递归调用而不导致死锁；函数unlock_kernel释放大内核锁。它们的用法与一般自旋锁类似。

转自：http://blog.chinaunix.net/uid-26126915-id-3032644.html

自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。

　　由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于互斥锁。
　　信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下文使用（_trylock的变种能够在中断上下文使用），而自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用。
　　如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适，如果对共巷资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。
　　自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的。自旋锁只有在内核可抢占或SMP的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作。
　　跟互斥锁一样，一个执行单元要想访问被自旋锁保护的共享资源，必须先得到锁，在访问完共享资源后，必须释放锁。如果在获取自旋锁时，没有任何执行单元保持该锁，那么将立即得到锁；如果在获取自旋锁时锁已经有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁。
　　无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。
获得自旋锁和释放自旋锁有好几个版本，因此让读者知道在什么样的情况下使用什么版本的获得和释放锁的宏是非常必要的。
　　如果被保护的共享资源只在进程上下文访问和软中断上下文访问，那么当在进程上下文访问共享资源时，可能被软中断打断，从而可能进入软中断上下文来对被保护的共享资源访问，因此对于这种情况，对共享资源的访问必须使用spin_lock_bh和spin_unlock_bh来保护。
　　当然使用spin_lock_irq和spin_unlock_irq以及spin_lock_irqsave和spin_unlock_irqrestore也可以，它们失效了本地硬中断，失效硬中断隐式地也失效了软中断。但是使用spin_lock_bh和spin_unlock_bh是最恰当的，它比其他两个快。
　　如果被保护的共享资源只在进程上下文和tasklet或timer上下文访问，那么应该使用与上面情况相同的获得和释放锁的宏，因为tasklet和timer是用软中断实现的。
　　如果被保护的共享资源只在一个tasklet或timer上下文访问，那么不需要任何自旋锁保护，因为同一个tasklet或timer只能在一个CPU上运行，即使是在SMP环境下也是如此。实际上tasklet在调用tasklet_schedule标记其需要被调度时已经把该tasklet绑定到当前CPU，因此同一个tasklet决不可能同时在其他CPU上运行。
　　timer也是在其被使用add_timer添加到timer队列中时已经被帮定到当前CPU，所以同一个timer绝不可能运行在其他CPU上。当然同一个tasklet有两个实例同时运行在同一个CPU就更不可能了。
　　如果被保护的共享资源只在两个或多个tasklet或timer上下文访问，那么对共享资源的访问仅需要用spin_lock和spin_unlock来保护，不必使用_bh版本，因为当tasklet或timer运行时，不可能有其他tasklet或timer在当前CPU上运行。
　如果被保护的共享资源只在一个软中断（tasklet和timer除外）上下文访问，那么这个共享资源需要用spin_lock和spin_unlock来保护，因为同样的软中断可以同时在不同的CPU上运行。
　　如果被保护的共享资源在两个或多个软中断上下文访问，那么这个共享资源当然更需要用spin_lock和spin_unlock来保护，不同的软中断能够同时在不同的CPU上运行。
　　如果被保护的共享资源在软中断（包括tasklet和timer）或进程上下文和硬中断上下文访问，那么在软中断或进程上下文访问期间，可能被硬中断打断，从而进入硬中断上下文对共享资源进行访问，因此，在进程或软中断上下文需要使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。
　　而在中断处理句柄中使用什么版本，需依情况而定，如果只有一个中断处理句柄访问该共享资源，那么在中断处理句柄中仅需要spin_lock和spin_unlock来保护对共享资源的访问就可以了。
　　因为在执行中断处理句柄期间，不可能被同一CPU上的软中断或进程打断。但是如果有不同的中断处理句柄访问该共享资源，那么需要在中断处理句柄中使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。
　　在使用spin_lock_irq和spin_unlock_irq的情况下，完全可以用spin_lock_irqsave和spin_unlock_irqrestore取代，那具体应该使用哪一个也需要依情况而定，如果可以确信在对共享资源访问前中断是使能的，那么使用spin_lock_irq更好一些。
　　因为它比spin_lock_irqsave要快一些，但是如果你不能确定是否中断使能，那么使用spin_lock_irqsave和spin_unlock_irqrestore更好，因为它将恢复访问共享资源前的中断标志而不是直接使能中断。
　　当然，有些情况下需要在访问共享资源时必须中断失效，而访问完后必须中断使能，这样的情形使用spin_lock_irq和spin_unlock_irq最好。

　　spin_lock用于阻止在不同CPU上的执行单元对共享资源的同时访问以及不同进程上下文互相抢占导致的对共享资源的非同步访问，而中断失效和软中断失效却是为了阻止在同一CPU上软中断或中断对共享资源的非同步访问。
转自： http://blog.csdn.net/unbutun/article/details/5730037
yoveldf
关注
专栏目录
Java 并发编程：ReentrantLock 锁与 AQS
栗筝i的博客
08-10 1382
大家好，我是栗筝i，这篇文章是我的 “栗筝i 的 Java 技术栈” 专栏的第 030 篇文章，在 “栗筝i 的 Java 技术栈” 这个专栏中我会持续为大家更新 Java 技术相关全套技术栈内容。专栏的主要目标是已经有一定 Java 开发经验，并希望进一步完善自己对整个 Java 技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同学学习。
分布式锁与幂等性问题，如何解决？
KHOST的博客
12-28 535
随着互联网信息技术的飞速发展，数据量不断增大，业务逻辑也日趋复杂，对系统的高并发访问、海量数据处理的场景也越来越多。如何用较低成本实现系统的高可用、易伸缩、可扩展等目标就显得越发重要。 为了解决这一系列问题，系统架构也在不断演进。传统的集中式系统已经逐渐无法满足要求，分布式系统被使用在更多的场景中。 分布式系统由独立的服务器通过网络松散耦合组成。在这个系统中每个服务器都是一台独立的主机，服务器...
Linux内核同步机制-自旋锁（spin_lock）
m0_74282605的博客
02-11 916
函数的关键实现在于和架构相关的二个函数：do_raw_spin_trylock, do_raw_spin_lock，其中他们分别会调用与架构相关的二个函数：arch_spin_trylock和arch_spin_lock函数；自旋锁的初始化其实很简单，就是做个spinlock->raw_spinlock->arch_spinlock_t的转换，然后把arch_spinlock_t的val初始化为0；spin_lock_bh该函数会关抢占，关软中断，防止单核抢占或软中断抢占拿锁；
转： Linux spinlock_t
weixin_30877181的博客
08-12 569
我的经验：如果出现死锁的情况，检查：1. lock 和 unlock是否成对出现了，检查所有的程序分支。2.是否有同时需要2个和2个以上的锁的情况，避免掉这种情况。3.如果在timer等软中断中出现死锁，可能是没有使用spin_lock_bh这一类的锁。reference: http://www.chinaitpower.com/2005September/2005-09-13/200...
关于SpinLock的更深入理解
FireBird的专栏
12-06 7858
0 前言          之前转载过一篇阐述spin_lock的博文，但始终理解不深入，记忆不深刻。今天，花了半天阅读完LDD3的相关章节，有种顿悟的感觉，遂简要记下自己的理解。Btw，LDD3真心是字字珠玑，没有半句废话，而且从这边书可以看出外国人写书非常注重前后的呼应，而国内大多数书都是就事论事，没有体系的感觉，也难以启发人深入思考。（一不小心又吐嘈了一遍，罪过罪过……）另外，关于LDD3
Spin_Lock
lando 一生有你
03-12 149
From Intel Volume 3A: Spin_Lock: CMP lockvar, 0 ;Check if lock is free JE Get_Lock PAUSE ;Short delay JMP Spin_Lock Get_Lock: MOV EAX, 1 ...
spinlock
TheGameIsFives的专栏
05-23 1060
spinlock本身是原子操作的。会禁用抢占和避免multi-core竞争.它不能长期持有。 1. spinlock哪些场合需要？ 不能进入睡眠的情况下: 中断处理中，tasklet中。还有有些很短的临界区，如果用信号量，会有进程睡眠和再次唤醒，代价很高，可以用spin_lock. 使用时要先初始化： SPIN_LOCK_UNLOCKED 2. 为什么用户空间不需要spinlock
Linux内核同步方法之自旋锁
lh0616的博客
12-20 220
文章目录前言一、什么是自旋锁1. 自旋锁的含义2. 单处理器的自旋锁3. 多处理器（SMP）的自旋锁二、自旋锁及其衍生型三、自旋锁的使用实例1. spin_lock()/spin_unlock()2. spin_lock_irq()/spin_unlock_irq()3. spin_lock_irqsave()/spin_lock_irqrestore()4. Makefile四、使用自旋锁的注意点1.使用自旋锁时的注意点2. 死锁实例3. 自旋锁适用场景总结参考资料 前言 软硬件环境 硬件： PC 软件
互斥锁在多线程编程中的应用技巧分享
# 1. 多线程编程基础 ## 1.1 什么是多线程编程 在计算机领域，多线程编程是指在同一进程中运行多个线程以实现并发执行的编程技术。...互斥锁就是一种常用的同步机制，可以解决这类问题。 # 2. 理解互斥锁
T-SQL执行内幕（1）——简介
MVP黄钊吉（發糞塗牆）
03-23 2675
本文属于SQL Server T-SQL执行内幕系列前言：    本文主体内容来自于：http://rusanu.com/2013/08/01/understanding-how-sql-server-executes-a-query/但是经常打不开，本人又在：https://www.codeproject.com/Articles/630346/Understanding-how-SQL-Ser...
SpinLock(自旋锁)
xiaokaiv587的博客
08-09 372
SpinLock结构是一个低级别的互斥同步基元，它在等待获取锁时进行旋转。 在多核计算机上，当等待时间预计较短且极少出现争用情况时，SpinLock 的性能将高于其他类型的锁。 不过，仅在通过分析确定 System.Threading.Monitor 方法或 Interlocked 方法显著降低了程序的性能时使用 SpinLock。......
自旋锁（Spin Lock）
kof2019的博客
08-21 2611
转载请您注明出处：    http://www.cnblogs.com/lsh123/p/7400625.html   0x01 自旋锁简介 　　自旋锁也是一种同步机制，它能保证某个资源只能被一个线程所拥有，这种保护被形象地称做“上锁”。它可以用于驱动程序中的同步处理。初始化自旋锁时，处理解锁状态，这时它可以被程序“获取”。“获取”后的自旋锁处理于锁定状态，不能再被“获取”。 　　如果自旋
Spinlock简介
YUYOUFU的专栏
06-11 978
作者 : cjc86在 这篇文章中，我将会介绍 Kernel 提供用来使用 spinlock 的 function。除此之外，我还会告诉各位，为何在 SMP 的环境里，使用 spinlock 会比将所有 CPU 的中断 disable 这个方法来的有效率，我也会告诉各位如何针对不同的使用需求，使 spinlock 的 cost 再降低，进而使系统的效能更好... 前言在 Linux Ker
自旋锁
u013322907的专栏
10-06 388
http://blog.csdn.net/kyokowl/article/details/6294341 POSIX threads(简称Pthreads)是在多核平台上进行并行编程的一套常用的API。线程同步(Thread Synchronization)是并行编程中非常重要的通讯手段，其中最典型的应用就是用Pthreads提供的锁机制(lock)来对多个线程之间共 享的临界区(Cri
自旋锁（spinlock）
青山师
08-10 519
自旋锁（spinlock） 自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，”自旋”一词就是因此而得名。 　　由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于互斥锁。 　　信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下
自旋锁（Spinlock）：轻量级锁机制
最新发布
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
08-06 8107
自旋锁：非阻塞锁，线程尝试获取锁时，不直接阻塞，而是忙等待检查锁状态，直到锁释放后立即获取，减少阻塞和上下文切换开销。
03-自旋锁应用示例
夏夜晚风_的博客
11-04 2021
文章目录1 示例代码1.1 demo.c1.2 test.c1.3 Makefile1.4 测试结果  上个示例 02-原子变量应用示例 使用原子变量实现了一次只能有一个应用程序访问一个设备，本节我们使用自旋锁来实现此功能。在使用自旋锁之前，先回顾一下自旋锁的使用注意事项：  ①、自旋锁保护的临界区要尽可能的短，因此在 open 函数中申请自旋锁，然后在 release 函数中释放自旋锁的方法就不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值