linux中的内核同步机制

古城微笑少年丶 2022-06-08 23:09 337阅读 0赞

Linux设备驱动中必须解决的一个问题是多个进程对共享资源的并发访问，并发访问会导致竞态， linux提供了多种解决竞态问题的方式，这些方式适合不同的应用场景。

[Linux][]内核是多进程、多线程的[操作系统][Link 1]，它提供了相当完整的内核同步方法。内核同步方法列表如下：

=========================

内核中采用的同步技术:

**中断屏蔽**

**原子操作　　（分为整数原子操作和位 原子操作）**

**信号量  （semaphore）**

**RCU  （read-copy-update）**

SMP系统中的同步机制 ：  
**自旋锁 （spin lock）**

**读写自旋锁**

**顺序锁         (seqlock 只包含在2.6内核中)**

**读写信号量  （rw\_semaphore）**

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

**Seq锁（）。**

==========================

**一、概念介绍**

**并发与竞态：**

**         ** 并发（concurrency）指的是多个执行单元同时、并行被执行，而并发的执行单元对共享资源（硬件资源和软件上的全局变量、静态变量等）的访问则很容易导致竞态（race conditions）。

**在[linux][Linux]中，主要的竞态发生在如下几种情况：**

1、对称多处理器（SMP）多个CPU                特点是多个CPU使用共同的系统总线，因此可访问共同的外设和存储器。

2、单CPU内进程与抢占它的进程

3、中断（硬中断、软中断、Tasklet、底半部）与进程之间

只要并发的多个执行单元存在对共享资源的访问，竞态就有可能发生。

如果中断处理程序访问进程正在访问的资源，则竞态也会会发生。

多个中断之间本身也可能引起并发而导致竞态（中断被更高优先级的中断打断）。

解决竞态问题的途径是保证对共享资源的互斥访问，所谓**互斥访问**就是指一个执行单元在访问共享资源的时候，其他的执行单元都被禁止访问。

访问共享资源的代码区域被称为**临界区**，临界区需要以某种互斥机制加以保护，如：中断屏蔽，原子操作，自旋锁，和信号量都是linux设备驱动中可采用的互斥途径。

**临界区和竞争条件：**

所谓临界区（critical regions）就是访问和操作共享数据的代码段，为了避免在临界区中并发访问，编程者必须**保证这些代码原子地执行——也就是说，代码在执行结束前不可被打断**，就如同整个临界区是一个不可分割的指令一样，如果两个执行线程有可能处于同一个临界区中，那么就是程序包含一个bug，如果这种情况发生了，我们就称之为竞争条件（race conditions），避免并发和防止竞争条件被称为**同步**。

**死锁：**

死锁的产生需要一定条件：要有一个或多个执行线程和一个或多个资源，每个线程都在等待其中的一个资源，但所有的资源都已经被占用了，所有线程都在相互等待，但它们永远不会释放已经占有的资源，于是任何线程都无法继续，这便意味着死锁的发生。

=========================================================================================================================

**详细的同步方法如下：**

**一、中断屏蔽**

在单CPU范围内避免竞态的一种简单方法是在进入临界区之前屏蔽系统的中断。由于linux内核的进程调度等操作都依赖中断来实现，内核抢占进程之间的并发也就得以避免了。

**中断屏蔽的使用方法：**

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. local\_irq\_disable()//屏蔽中断  
2. //临界区  
3. local\_irq\_enable()//开中断  
4. 特点：由于<span style="font-family:Times New Roman;">linux系统的异步<span style="font-family:Times New Roman;">IO，进程调度等很多重要操作都依赖于中断，在屏蔽中断期间所有的中断都无法得到处理，因此长时间的屏蔽是很危险的，有可能造成数据丢失甚至系统崩溃，这就要求在屏蔽中断之后，当前的内核执行路径应当尽快地执行完临界区的代码。

中断屏蔽只能禁止本CPU内的中断，因此，并不能解决多CPU引发的竞态，所以单独使用中断屏蔽并不是一个值得推荐的避免竞态的方法，它一般和自旋锁配合使用。

** 二、原子操作**

**定义：**原子操作指的是在执行过程中不会被别的代码路径所中断的操作。（原子原本指的是不可分割的微粒，所以原子操作也就是不能够被分割的指令）

（它保证**指令**以“原子”的方式执行而不能被打断）

原子操作是不可分割的，在执行完毕不会被任何其它任务或事件中断。在单处理器系统(UniProcessor)中，能够在单条指令中完成的操作都可以认为是"原子操作"，因为中断只能发生于指令之间。这也是某些CPU指令系统中引入了test\_and\_set、test\_and\_clear等指令用于临界资源互斥的原因。但是，在对称多处理器(**Symmetric Multi-Processor**)结构中就不同了，由于系统中有多个处理器在独立地运行，即使能在单条指令中完成的操作也有可能受到干扰。我们以decl (递减指令)为例，这是一个典型的"读－改－写"过程，涉及两次内存访问。

**通俗理解：**

原子操作，顾名思义，就是说像原子一样不可再细分。一个操作是原子操作，意思就是说这个操作是以原子的方式被执行，要一口气执行完，执行过程不能够被OS的其他行为打断，是一个整体的过程，在其执行过程中，OS的其它行为是插不进来的。

**分类：**linux内核提供了一系列函数来实现内核中的原子操作，分为**整型原子操作**和**位原子操作**，共同点是：在任何情况下操作都是原子的，内核代码可以安全的调用它们而不被打断。

**原子整数操作：**

针对整数的原子操作只能对**atomic\_t****类型**的数据进行处理，在这里之所以引入了一个特殊的数据类型，而没有直接使用C语言的int型，主要是出于两个原因：

第一、让原子函数只接受atomic\_t类型的操作数，可以确保原子操作只与这种特殊类型数据一起使用，同时，这也确保了该类型的数据不会被传递给其它任何非原子函数；

第二、使用atomic\_t类型确保编译器不对相应的值进行访问优化——这点使得原子操作最终接收到正确的内存地址，而不是一个别名，最后就是在不同体系结构上实现原子操作的时候，使用atomic\_t可以屏蔽其间的差异。

原子整数操作最常见的用途就是实现计数器。

另一点需要说明原子操作只能保证操作是原子的，要么完成，要么不完成，不会有操作一半的可能，但原子操作并不能保证操作的顺序性，即它不能保证两个操作是按某个顺序完成的。如果要保证原子操作的顺序性，请使用内存屏障指令。

atomic\_t和ATOMIC\_INIT(i)定义如下：

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  typedef struct \{ volatile int counter; \} atomic\_t;  
2.  \#define ATOMIC\_INIT(i)  \{ (i) \}

=========================整数相关函数: ===========================================

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  ATOMIC\_INIT(int i)                                         //声明一个atomic\_t变量并且初始化为i  
2.           int atomic\_read(atomic\_t \*v)                      //原子地读取整数变量v  
3.           void atomic\_set(atomic\_t \*v, int i)               //原子地设置v为i  
4.           void atomic\_add(int i, atomic\_t \*v)         //v+i  
5.           void atomic\_sub(int i, atomic\_t \*v)         //v-i  
6.           void atomic\_inc(atomic\_t \*v)                //v+1  
7.           void atomic\_dec(atomic\_t \*v)                //v-1  
8.           int atomic\_sub\_and\_test(int i, atomic\_t \*v)       //v-i, 结果等于0，返回真，否则返回假   
9.             int atomic\_add\_negative(int i, atomic\_t \*v)       //原子地给v+i,结果是负数，返回真，否则返回假  
10.            int atomic\_dec\_and\_test(atomic\_t \*v)              //v-1, 结果是0，返回真，否则返回假  
11.            int atomic\_inc\_and\_test(atomic\_t \*v)              //v+1,如果是0，返回真，否则返回假

在你编写代码的时候，能使用原子操作的时候，就尽量不要使用复杂的加锁机制，对多数体系结构来讲，原子操作与更复杂的同步方法相比较，给系统带来的开销小，对高速缓存行的影响也小，但是，对于那些有高性能要求的代码，对多种同步方法进行[测试][Link 2]比较，不失为一种明智的作法。

**原子位操作：**

针对位这一级数据进行操作的函数，是对普通的内存地址进行操作的。它的参数是一个指针和一个位号。

=================================位操作相关函数:====================================

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  void set\_bit(int nr, void \*addr)                  //原子地设置addr所指对象的第nr位  
2.  void clear\_bit(int nr, void \*addr)                  //清空addr第nr位  
3.  void change\_bit(int nr, void \*addr)                 //反转addr第nr位  
4.  int test\_and \_set\_bit(int nr, void \*addr)           //设置addr第nr位，并返回原先的位的值  
5.  int test\_and\_clear\_bit(int nr, void \*addr)          //清除addr第nr位，并返回原先的值  
6.  int test\_and\_change\_bit(int nr, void \*addr)         //反转addr第nr，并返回原先的值  
7.  int test\_bit(int nr, void \*addr)                            //原子地返回addr的第nr位

为方便其间，内核还提供了一组与上述操作对应的**非原子位函数**，非原子位函数与原子位函数的操作完全相同，但是，非原子位函数不保证原子性，且其名字前缀多两个下划线。例如，与**test\_**bit()对应的非原子形式是**\_test\_**bit()，如果你不需要原子性操作（比如，如果你已经用锁保护了自己的数据），那么这些非原子的位函数相比原子的位函数可能会执行得更快些。

** 使用示例：**

创建和初始化原子变量                     
atomic\_t my\_counter ATOMIC\_INIT(0);    //声明一个atomic\_t类型的变量my\_counter 并且初始化为0  
或者   
atomic\_set( &my\_counter, 0 );

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. <span style="font-size:12px;color:\#000000;">简单的算术原子函数                      
2. val = atomic\_read( &my\_counter );      
3. atomic\_add( 1, &my\_counter );      
4. atomic\_inc( &my\_counter );      
5. atomic\_sub( 1, &my\_counter );      
6. atomic\_dec( &my\_counter );    
7.

**三、自旋锁（spin lock）**

**自旋锁的引入：**

如果每个临界区都能像增加变量这样简单就好了，可惜现实不是这样，而是**临界区可以跨越多个函数**，例如：**先得从一个数据结果中移出数据，对其进行格式转换和解析，最后再把它加入到另一个[数据结构][Link 3]中，整个执行过程必须是原子的，在数据被更新完毕之前，不能有其他代码读取这些数据**，显然，简单的原子操作是无能为力的（在单处理器系统(UniProcessor)中，能够在单条指令中完成的操作都可以认为是"原子操作"，因为中断只能发生于指令之间），这就需要使用更为复杂的同步方法——锁来提供保护。

**自旋锁的介绍：**

Linux内核中最常见的锁是自旋锁（spin lock），自旋锁最多只能被一个可执行线程持有，如果一个执行线程试图获得一个被争用（已经被持有）的自旋锁，那么该线程就会一直进行忙循环—旋转—等待锁重新可用，要是锁未被争用，请求锁的执行线程便能立刻得到它，继续执行，在任意时间，自旋锁都可以防止多于一个的执行线程同时进入理解区，注意同一个锁可以用在多个位置—例如，对于给定数据的所有访问都可以得到保护和同步。

**一个被争用的自旋锁使得请求它的线程在等待锁重新可用时自旋（特别浪费处理器时间），所以自旋锁不应该被长时间持有**，事实上，这点正是使用自旋锁的初衷，在短期间内进行轻量级加锁，还可以采取另外的方式来处理对锁的争用：让请求线程睡眠，直到锁重新可用时再唤醒它，这样处理器就不必循环等待，可以去执行其他代码，这也会带来一定的开销——这里有两次明显的上下文切换，被阻塞的线程要换出和换入。因此，持有自旋锁的时间最好小于完成两次上下文切换的耗时，当然我们大多数人不会无聊到去测量上下文切换的耗时，所以我们让持有自旋锁的时间应尽可能的短就可以了，**信号量可以提供上述第二种机制**，它使得在发生争用时，等待的线程能投入睡眠，而不是旋转。

自旋锁可以使用在中断处理程序中（此处不能使用信号量，因为它们会导致睡眠），在中断处理程序中使用自旋锁时，一定要在获取锁之前，首先禁止本地中断（在当前处理器上的中断请求），否则，中断处理程序就会打断正持有锁的内核代码，有可能会试图去争用这个已经持有的自旋锁，这样以来，中断处理程序就会自旋，等待该锁重新可用，但是锁的持有者在这个中断处理程序执行完毕前不可能运行，这正是我们在前一章节中提到的双重请求死锁，注意，需要关闭的只是当前处理器上的中断，如果中断发生在不同的处理器上，即使中断处理程序在同一锁上自旋，也不会妨碍锁的持有者（在不同处理器上）最终释放锁。

**自旋锁的简单理解：**

理解自旋锁最简单的方法是把它作为一个变量看待，该变量把一个临界区或者标记为“我当前正在运行，请稍等一会”或者标记为“我当前不在运行，可以被使用”。如果A执行单元首先进入例程，它将持有自旋锁，当B执行单元试图进入同一个例程时，将获知自旋锁已被持有，需等到A执行单元释放后才能进入。

**自旋锁的API函数：**

其实介绍的几种信号量和互斥机制，其底层源码都是使用自旋锁,可以理解为自旋锁的再包装。所以从这里就可以理解为什么自旋锁通常可以提供比信号量更高的性能。  
自旋锁是一个互斥设备，他只能会两个值：“锁定”和“解锁”。它通常实现为某个整数之中的单个位。  
“测试并设置”的操作必须以原子方式完成。  
任何时候，只要内核代码拥有自旋锁，在相关CPU上的抢占就会被禁止。

适用于自旋锁的核心规则：  
（1）任何拥有自旋锁的代码都必须使原子的，除服务中断外（某些情况下也不能放弃CPU,如中断服务也要获得自旋锁。为了避免这种锁陷阱，需要在拥有自旋锁时禁止中断），不能放弃CPU（如休眠，休眠可发生在许多无法预期的地方）。否则CPU将有可能永远自旋下去（死机）。  
（2）拥有自旋锁的时间越短越好。

需要强调的是，**自旋锁设计用于多处理器的同步机制**，对于单处理器（对于单处理器并且不可抢占的内核来说，自旋锁什么也不作），内核在编译时不会引入自旋锁机制，对于可抢占的内核，它仅仅被用于设置内核的抢占机制是否开启的一个开关，也就是说加锁和解锁实际变成了禁止或开启内核抢占功能。**如果内核不支持抢占，那么自旋锁根本就不会编译到内核中。** 
内核中使用spinlock\_t类型来表示自旋锁，它定义在<linux/spinlock\_types.h>：

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  typedef struct \{  
2.      raw\_spinlock\_t raw\_lock;  
3.  \#if defined(CONFIG\_PREEMPT) && defined(CONFIG\_SMP)  
4.      unsigned int break\_lock;  
5.  \#endif  
6.  \} spinlock\_t;  
7.

对于不支持SMP的内核来说，struct raw\_spinlock\_t什么也没有，是一个空结构。对于支持多处理器的内核来说，struct raw\_spinlock\_t定义为

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. typedef struct \{  
2.     unsigned int slock;  
3. \} raw\_spinlock\_t;<span style="color:\#2a2a2a;"><span style="font-family:Times New Roman;">

slock表示了自旋锁的状态，“1”表示自旋锁处于解锁状态（UNLOCK），“0”表示自旋锁处于上锁状态（LOCKED）。 
break\_lock表示当前是否由进程在等待自旋锁，显然，它只有在支持抢占的SMP内核上才起作用。 
    自旋锁的实现是一个复杂的过程，说它复杂不是因为需要多少代码或逻辑来实现它，其实它的实现代码很少。自旋锁的实现跟体系结构关系密切，核心代码基本也是由汇编语言写成，与体协结构相关的核心代码都放在相关的<asm/>目录下，比如<asm/spinlock.h>。对于我们驱动程序开发人员来说，我们没有必要了解这么spinlock的内部细节，如果你对它感兴趣，请参考阅读Linux内核源代码。对于我们驱动的spinlock接口，我们只需包括<linux/spinlock.h>头文件。在我们详细的介绍spinlock的API之前，我们先来看看自旋锁的一个**基本使用格式：**

** 使用示例：**

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. \#include <linux/spinlock.h>  
2. spinlock\_t mr\_lock = SPIN\_LOCK\_UNLOCKED;  
3. spin\_lock(&mr\_lock);  
4. /\*  
5. 临界区  
6. \*/  
7. spin\_unlock(&mr\_lock);

从使用上来说，spinlock的API还很简单的，**一般我们会用的的****API**如下表，其实它们都是定义在<linux/spinlock.h>中的宏接口，真正的实现在<asm/spinlock.h>中

**\[cpp\]** [ view plain][view plain 1] [copy][view plain 1]

1. \#include <linux/spinlock.h> 
 SPIN\_LOCK\_UNLOCKED 
 DEFINE\_SPINLOCK 
 spin\_lock\_init( spinlock\_t \*) 
 spin\_lock(spinlock\_t \*) 
 spin\_unlock(spinlock\_t \*) 
 spin\_lock\_irq(spinlock\_t \*) 
 spin\_unlock\_irq(spinlock\_t \*) 
 spin\_lock\_irqsace(spinlock\_t \*，unsigned long flags) 
 spin\_unlock\_irqsace(spinlock\_t \*, unsigned long flags) 
 spin\_trylock(spinlock\_t \*) 
 spin\_is\_locked(spinlock\_t \*)

**初始化**

spinlock有两种初始化形式，一种是静态初始化，一种是动态初始化。对于静态的spinlock对象，我们用 SPIN\_LOCK\_UNLOCKED来初始化，它是一个宏。当然，我们也可以把声明spinlock和初始化它放在一起做，这就是 DEFINE\_SPINLOCK宏的工作，因此，下面的两行代码是等价的。

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  DEFINE\_SPINLOCK (lock);  
2.  spinlock\_t lock = SPIN\_LOCK\_UNLOCKED;

spin\_lock\_init函数一般用来初始化动态创建的spinlock\_t对象，它的参数是一个指向spinlock\_t对象的指针。当然，它也可以初始化一个静态的没有初始化的spinlock\_t对象。

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  spinlock\_t \*lock  
2.  ......  
3.  spin\_lock\_init(lock);

获取锁

内核提供了多个函数用于获取一个自旋锁。

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. spin\_try\_lock()        试图获得某个特定的自旋锁,如果该锁已经被争用,该方法会立刻返回一个非0值,而不会自旋等待锁被释放,如果成果获得了这个锁,那么就返回0.  
2. spin\_is\_locked()          //方法和spin\_try\_lock()是一样的功效,该方法只做判断,并不生效.<span style="color:\#2a2a2a;">如果是则返回非<span style="font-family:Times New Roman;">0，否则，返回<span style="font-family:Times New Roman;">0。  
3. spin\_lock();              //获取指定的自旋锁  
4. spin\_lock\_irq();          //禁止本地中断获取指定的锁  
5. spin\_lock\_irqsave();      //保存本地中断的状态,禁止本地中断,并获取指定的锁

自旋锁是可以使用在中断处理程序中的，这时需**要使用具有关闭本地中断功能的函数，我们推荐使用** **spin\_lock\_irqsave**，因为它会保存加锁前的中断标志，这样就会正确恢复解锁时的中断标志。如果spin\_lock\_irq在加锁时中断是关闭的，那么在解锁时就会错误的开启中断。

**释放锁**

同获取锁相对应，内核提供了三个相对的函数来释放自旋锁。

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. <span style="color:\#000000;">spin\_unlock：释放指定的自旋锁。  
2. spin\_unlock\_irq：释放自旋锁并激活本地中断。  
3. spin\_unlock\_irqsave：释放自旋锁，并恢复保存的本地中断状态。

**四、读写自旋锁**

如果临界区保护的数据是可读可写的，那么只要没有写操作，对于读是可以支持并发操作的。对于这种只要求写操作是互斥的需求，如果还是使用自旋锁显然是无法满足这个要求（对于读操作实在是太浪费了）。为此内核提供了另一种锁－读写自旋锁，读自旋锁也叫共享自旋锁，写自旋锁也叫排他自旋锁。

读写自旋锁是一种比自旋锁粒度更小的锁机制，它保留了“自旋”的概念，但是在写操作方面，只能最多有一个写进程，在读操作方面，同时可以有多个读执行单元，当然，读和写也不能同时进行。  
    读写自旋锁的使用也普通自旋锁的使用很类似，首先要初始化读写自旋锁对象：

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  //静态初始化  
2.  rwlock\_t rwlock = RW\_LOCK\_UNLOCKED;  
3.  //动态初始化  
4.  rwlock\_t \*rwlock;  
5.  ...  
6.  rw\_lock\_init(rwlock);

在读操作代码里对共享数据获取读自旋锁：

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  read\_lock(&rwlock);  
2.  ...  
3.  read\_unlock(&rwlock);

在写操作代码里为共享数据获取写自旋锁：

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  write\_lock(&rwlock);  
2.  ...  
3.  write\_unlock(&rwlock);

需要注意的是，如果有大量的写操作，会使写操作自旋在写自旋锁上而处于写饥饿状态（等待读自旋锁的全部释放），因为读自旋锁会自由的获取读自旋锁。  
  
读写自旋锁的函数类似于普通自旋锁，这里就不一一介绍了，我们把它列在下面的表中。

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  RW\_LOCK\_UNLOCKED  
2.  rw\_lock\_init(rwlock\_t \*)  
3.  read\_lock(rwlock\_t \*)  
4.  read\_unlock(rwlock\_t \*)  
5.  read\_lock\_irq(rwlock\_t \*)  
6.  read\_unlock\_irq(rwlock\_t \*)  
7.  read\_lock\_irqsave(rwlock\_t \*, unsigned long)  
8.  read\_unlock\_irqsave(rwlock\_t \*, unsigned long)  
9.  write\_lock(rwlock\_t \*)  
10. write\_unlock(rwlock\_t \*)  
11. write\_lock\_irq(rwlock\_t \*)  
12. write\_unlock\_irq(rwlock\_t \*)  
13. write\_lock\_irqsave(rwlock\_t \*, unsigned long)  
14. write\_unlock\_irqsave(rwlock\_t \*, unsigned long)  
15. rw\_is\_locked(rwlock\_t \*)

**五、顺序琐**

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

**如果读执行单元在读操作期间，写执行单元已经发生了写操作，那么，读执行单元必须重新读取数据，以便确保得到的数据是完整的，这**种锁在读写同时进行的概率比较小时，性能是非常好的，而且它允许读写同时进行，因而更大的提高了并发性，

注意，顺序琐由一个限制，就是它必须被保护的共享资源不含有指针，因为写执行单元可能使得指针失效，但读执行单元如果正要访问该指针，将导致Oops。

**六、信号量**

**Linux中的信号量是一种睡眠锁，如果有一个任务试图获得一个已经被占用的信号量时，信号量会将其推进一个等待队列，然后让其睡眠，这时处理器能重获自由，从而去执行其它代码，当持有信号量的进程将信号量释放后，处于等待队列中的哪个任务被唤醒，并获得该信号量。**

**信号量，或旗标，就是我们在操作系统里学习的经典的P/V原语操作。  
P：如果信号量值大于0，则递减信号量的值，程序继续执行，否则，睡眠等待信号量大于0。  
V：递增信号量的值，如果递增的信号量的值大于0，则唤醒等待的进程。**  
  
    信号量的值确定了同时可以有多少个进程可以同时进入临界区，如果信号量的初始值始1，这信号量就是互斥信号量（MUTEX）。对于大于1的非0值信号量，也可称为计数信号量（counting semaphore）。对于一般的驱动程序使用的信号量都是互斥信号量。

类似于自旋锁，信号量的实现也与体系结构密切相关，具体的实现定义在<asm/semaphore.h>头文件中，对于x86\_32系统来说，它的定义如下：

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. struct semaphore \{  
2.    <span style="color:\#ff9900;">atomic\_t count;  
3.    int sleepers;  
4.    wait\_queue\_head\_t wait;  
5. \};

信号量的初始值count是atomic\_t类型的，这是一个原子操作类型，它也是一个内核同步技术，可见信号量是基于原子操作的。我们会在后面原子操作部分对原子操作做详细介绍。  
  
信号量的使用类似于自旋锁，包括创建、获取和释放。我们还是来先展示信号量的**基本使用形式：**

**\[html\]** [ view plain][view plain] [ copy][view plain]

1.  static DECLARE\_MUTEX(my\_sem);  
2.  ......  
3.  if (down\_interruptible(&my\_sem))  
4.  \{  
5.      return -ERESTARTSYS;  
6.  \}  
7.  ......  
8.  up(&my\_sem);

Linux内核中的信号量函数接口如下：

<table style="background:#e7e9e9"> 
 <tbody> 
 <tr> 
 <td> static DECLARE_SEMAPHORE_GENERIC(name, count); static DECLARE_MUTEX(name); seam_init(struct semaphore *, int); init_MUTEX(struct semaphore *); init_MUTEX_LOCKED(struct semaphore *) down_interruptible(struct semaphore *); down(struct semaphore *) down_trylock(struct semaphore *) up(struct semaphore *) </td> 
 </tr> 
 </tbody> 
</table>

**初始化信号量**

信号量的初始化包括静态初始化和动态初始化。**静态初始**化用于静态的声明并初始化信号量。

对于**动态声明或创建的信号量**，可以使用如下函数进行初始化：

<table style="background:#e7e9e9"> 
 <tbody> 
 <tr> 
 <td> seam_init(sem, count); init_MUTEX(sem); init_MUTEX_LOCKED(struct semaphore *) </td> 
 </tr> 
 </tbody> 
</table>

显然，带有MUTEX的函数始初始化互斥信号量。LOCKED则初始化信号量为锁状态。

**使用信号量**

**\[html\]** [ view plain][view plain] [ copy][view plain]

1. down\_interruptible(struct semaphore \*);          
2.                                    <span style="color:\#3366ff;">使进程进入可中断的睡眠状态。关于进程状态的详细细节，我们在内核的进程管理里在做详细介绍。  
3. down(struct semaphore \*)           尝试获取指定的信号量，如果信号量已经被使用了，则进程进入不可中断的睡眠状态。  
4. down\_trylock(struct semaphore \*)   尝试获取信号量，如果获取成功则返回0，失败则会立即返回非0。  
5. up(struct semaphore \*)             释放信号量，如果信号量上的睡眠队列不为空，则唤醒其中一个等待进程。

**七、读写信号量**

类似于自旋锁，信号量也有读写信号量。读写信号量API定义在<linux/rwsem.h>头文件中，它的定义其实也是体系结构相关的，因此具体实现定义在<asm/rwsem.h>头文件中，以下是x86的例子：

<table style="background:#e7e9e9"> 
 <tbody> 
 <tr> 
 <td> struct rw_semaphore { &nbsp;&nbsp;&nbsp; signed long&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; count; &nbsp;&nbsp;&nbsp; spinlock_t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; wait_lock; &nbsp;&nbsp;&nbsp; struct list_head&nbsp;&nbsp;&nbsp; wait_list; }; </td> 
 </tr> 
 </tbody> 
</table>

**首先要说明的是所有的读写信号量都是互斥信号量。**读锁是共享锁，就是同时允许多个读进程持有该信号量，但写锁是独占锁，同时只能有一个写锁持有该互斥信号量。显然，写锁是排他的，包括排斥读锁。由于写锁是共享锁，它允许多个读进程持有该锁，只要没有进程持有写锁，它就始终会成功持有该锁，因此这会造成写进程写饥饿状态。  
  
在使用读写信号量前先要初始化，就像你所想到的，它在使用上几乎与读写自旋锁一致。先来看看读写信号量的创建和初始化：

<table style="background:#e7e9e9"> 
 <tbody> 
 <tr> 
 <td> //静态初始化 static DECLARE_RWSEM(rwsem_name); // 动态初始化 static struct rw_semaphore rw_sem； init_rwsem(&amp;rw_sem); </td> 
 </tr> 
 </tbody> 
</table>

读进程获取信号量保护临界区数据：

写进程获取信号量保护临界区数据：

<table style="background:#e7e9e9"> 
 <tbody> 
 <tr> 
 <td> down_write(&amp;rw_sem); ... up_write(&amp;rw_sem); </td> 
 </tr> 
 </tbody> 
</table>

更多的读写信号量API请参考下表：

<table style="background:#e7e9e9"> 
 <tbody> 
 <tr> 
 <td> #include &lt;linux/rwsem.h&gt; DECLARE_RWSET(name); init_rwsem(struct&nbsp; rw_semaphore *); void down_read(struct rw_semaphore *sem); void down_write(struct rw_semaphore *sem); void up_read(struct rw_semaphore *sem); int down_read_trylock(struct rw_semaphore *sem); int down_write_trylock(struct rw_semaphore *sem); void downgrade_write(struct rw_semaphore *sem); void up_write(struct rw_semaphore *sem); </td> 
 </tr> 
 </tbody> 
</table>

同自旋锁一样，down\_read\_trylock和down\_write\_trylock会尝试着获取信号量，如果获取成功则返回1，否则返回0。奇怪为什么返回值与信号量的对应函数相反，使用是一定要小心这点。

**九、自旋锁和信号量区别**

在驱动程序中，当多个线程同时访问相同的资源时（驱动程序中的全局变量是一种典型的共享资源），可能会引发"竞态"，因此我们必须对共享资源进行并发控制。Linux内核中解决并发控制的最常用方法是自旋锁与信号量（绝大多数时候作为互斥锁使用）。  
  
　　自旋锁与信号量"类似而不类"，类似说的是它们功能上的相似性，"不类"指代它们在本质和实现机理上完全不一样，不属于一类。  
  
　　自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环查看是否该自旋锁的保持者已经释放了锁，"自旋"就是"在原地打转"。而信号量则引起调用者睡眠，它把进程从运行队列上拖出去，除非获得锁。这就是它们的"不类"。  
  
　　但是，无论是信号量，还是自旋锁，在任何时刻，最多只能有一个保持者，即在任何时刻最多只能有一个执行单元获得锁。这就是它们的"类似"。  
  
　　鉴于自旋锁与信号量的上述特点，一般而言，自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用；信号量适合于保持时间较长的情况，会只能在进程上下文使用。如果被保护的共享资源只在进程上下文访问，则可以以信号量来保护该共享资源，如果对共享资源的访问时间非常短，自旋锁也是好的选择。但是，如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。

**区别总结如下：**

**1、由于争用信号量的进程在等待锁重新变为可用时会睡眠，所以信号量适用于锁会被长时间持有的情况。**

**2、相反，锁被短时间持有时，使用信号量就不太适宜了，因为睡眠引起的耗时可能比锁被占用的全部时间还要长。**

**3、由于执行线程在锁被争用时会睡眠，所以只能在进程上下文中才能获取信号量锁，因为在中断上下文中（使用自旋锁）是不能进行调度的。**

**4、你可以在持有信号量时去睡眠（当然你也可能并不需要睡眠），因为当其它进程试图获得同一信号量时不会因此而死锁，（因为该进程也只是去睡眠而已，而你最终会继续执行的）。**

**5、在你占用信号量的同时不能占用自旋锁，因为在你等待信号量时可能会睡眠，而在持有自旋锁时是不允许睡眠的。**

**6、信号量锁保护的临界区可包含可能引起阻塞的代码，而自旋锁则绝对要避免用来保护包含这样代码的临界区，因为阻塞意味着要进行进程的切换，如果进程被切换出去后，另一进程企图获取本自旋锁，死锁就会发生。**

**7、信号量不同于自旋锁，它不会禁止内核抢占（自旋锁被持有时，内核不能被抢占），所以持有信号量的代码可以被抢占，这意味着信号量不会对调度的等待时间带来负面影响。**

除了以上介绍的同步机制方法以外，还有BKL（大内核锁），Seq锁等。

BKL是一个全局自旋锁，使用它主要是为了方便实现从Linux最初的SMP过度到细粒度加锁机制。

Seq 锁用于读写共享数据，实现这样锁只要依靠一个序列计数器。

[Linux]: http://lib.csdn.net/base/linux
[Link 1]: http://lib.csdn.net/base/operatingsystem
[view plain]: http://blog.csdn.net/wealoong/article/details/7957385#
[Link 2]: http://lib.csdn.net/base/softwaretest
[Link 3]: http://lib.csdn.net/base/datastructure
[view plain 1]: http://blog.csdn.net/juana1/article/details/6630082#