内核中防止竞争状态的手段

1、什么是竞争状态，之前在应用编程的学习中已经提到过。

竞争状态就是在多进程环境下，多个进程同时抢占系统资源（内存、CPU、文件IO），竞争状态对OS来说是很危险的，此时OS如果没处理好就会造成意想不到的结果。

写程序当然不希望程序运行的结果不确定，所以我们写程序时要尽量消灭竞争状态。操作系统给我们提供了一系列的消灭竟态的机制，我们需要做的是在合适的地方使

用合适的方法来消灭竟态。这是之前在应用编程中说的，但是在内核态中同样存在竞争状态，所以今天来说说Linux内核中提供的用来消灭竞争状态的方法。

内核中消灭竞争状态的方法：互斥锁、信号量、原子访问、自旋锁

首先说明本次使用的内核版本是： Linux 2.6.35.7

一些概念：临界段、互斥锁、死锁

同步：多CPU、多任务、中断

2、互斥锁

互斥也就是相互排斥的意思，排他性，在编程中引入互斥是为了保证公共访问对象在同一时间（这个同一时间指的是宏观上的同一时间）内只能被一个线程

进行访问操作。当有一个线程在访问这个对象的时候，其他的线程是无法对他进行访问的。他的实现原理就是通过互斥锁来实现的，当线程访问公共对象时，在访问之前

他需要先去获取访问这个对象的锁，如果此时无法获取锁，则表示此时已经有其他的线程正在访问这个对象，那么他就如进入等待队列当中，进入阻塞状态。

其实这个过程就好比是上厕所（只有一个厕所），当厕所没人的时候你就直接进去把门关上，其他人想要上厕所就得先把门打开，发现门打不开，说明里面就有人，只能等待。

下面相关的函数定义和声明分别在： kernel\mutex.c  和  include\linux\mutex.h

(1)定义互斥锁： DEFINE_MUTEX(mutex);          定义 + 初始化

                      struct mutex mutexname;  mutex_init(mutexname);    先定义，之后再初始化    

(2)给互斥锁上锁： mutex_lock(struct mutex *lock);       这种方式进入休眠状态不会被打断，一直等待条件满足

                        int __must_check mutex_lock_interruptible(struct mutex *lock);   这种方式可以被中断返回，退出等待队列

                        int __must_check mutex_lock_killable(struct mutex *lock);     这种方式可以被杀掉

                        int mutex_trylock(struct mutex *lock);        这种方式会尝试上锁，不管成功与否都不会阻塞等待    

(3)解锁：   mutex_unlock(struct mutex *lock);           

整个互斥锁的使用形式如下：

先定义一个互斥锁： DEFINE_MUTEX(mutex);

在需要被保护的地方加上锁：  mutex_lock(struct mutex *lock);    或者其他的函数

当访问完成之后需要解锁，这个一定不要忘了：  mutex_unlock(struct mutex *lock);

3、信号量

互斥锁其实是一种特殊的信号量，互斥锁表示只有一个线程能够同时访问某个对象，而信号量则可以定义同时访问对象的线程数。也就是说互斥锁是只能同时访问一个对象

的信号量。下面函数定义和申明所在文件：  include\linux\semaphore.h

需要注意的是：互斥锁的出现先对于信号量来说比较晚，所以他的实现上更加的优秀，所以使用时如果可以请尽量使用互斥锁，而不要用信号量。

(1)信号量的定义：  

             宏：     DECLARE_MUTEX(name);       直接定义一个信号量name，初始化为1，表示空闲状态。一般这个用的比较多

                       struct semaphore sem;   init_MUTEX(sem);                  需要自己先定义一个变量，在调用宏初始化

                       struct semaphore sem;    init_MUTEX_LOCKED(sem);    跟上面的区别在于定义之后初始化为0，表示忙状态，所以在访问之前必须先释放锁

             函数：  void sema_init(struct semaphore *sem, int val);    val表示能够同时访问被保护对象的线程数量，上面2个宏内部就是调用了这个函数实现的

(2)信号量上锁：  

                      down(struct semaphore *sem);        将信号量计数值count减1，如果在执行down函数前，计数值已经为0，则表示不能在进行访问了，只能进入阻塞休眠，等待

                      int __must_check down_interruptible(struct semaphore *sem);  和上面的区别在于，阻塞可以被打断，例如信号，直接退出等待队列

                      int __must_check down_killable(struct semaphore *sem);    在阻塞等待的时可以被杀掉

                      int __must_check down_trylock(struct semaphore *sem);     尝试上锁，不管成功与否都直接返回，而不进入阻塞等待队列

                      int __must_check down_timeout(struct semaphore *sem, long jiffies);     可以设置等待超时时间，如果等待时间超过规定的时间，则直接退出等待队列

(3)信号量解锁： 

                      up(struct semaphore *sem);            解锁信号量，将信号量计数值count加1

使用方法跟互斥锁差不多。

4、自旋锁

自旋锁最初是为了在SMP系统中实现保护临界区而设计的，自旋锁的实现是为了保护一段短小的临界区操作代码，保证这个临界区的操作是原子的，从而避免并发的竞争冒险。

因为在SMP多核心处理器中可以在微观上同时执行多个进程，当这几个进程同时对临界保护区的代码进行访问的时候，这就发生了竞争状态。为了避免这种情况的出现，可以

通过内核实现的自旋锁来避免，他的原理就是：当进程访问临界保护区代码时，跟上面的信号量和互斥锁一样需要先去获取锁，只有成功获取到锁的进程才能够对代码进行访问

，并且访问是原子性的，必须当这个临界区代码执行完毕解锁之后才能恢复。没有获取到锁的进程并不会进入休眠阻塞的状态，而是会一直循环查询锁状态，这就是自旋的意思

这点与信号量（互斥锁）是不同的。

上面说的是SMP处理器的情况，在单核心非抢占内核系统（抢占的意思就是高优先级的线程可以优先抢占CPU）中，自旋锁所做的操作时空操作。在单核心抢占内核系统下，自旋

锁仅仅是当作一个设置内核抢占的开关，当获取到的线程进入临界区代码中时，此时就把内核抢占系统关闭了，同时也会禁止中断，所以此时除了正在执行他自己的代码外没有其

他的线程在动作了。

自旋锁是循环检测“忙等”，即等待时内核无事可做（除了浪费时间），进程在CPU上保持运行，所以它保护的临界区必须小，

且操作过程必须短。不过，自旋锁通常非常方便，因为很多内核资源只锁1毫秒的时间片段，所以等待自旋锁的释放不会消耗太多CPU的时间。

(1)自旋锁和信号量的使用要点

  1): 自旋锁不能递归

  2): 自旋锁可以用在中断上下文（信号量不可以，因为可能睡眠），但是在中断上下文中获取自旋锁之前要先禁用本地中断（本CPU自己的中断），因为中断是不参与进程调度的，

       如果我们的CPU运行在中断中时丢失了CPU，那么将再也不能会在这个中断的断点处了。

  3): 自旋锁的核心要求是：拥有自旋锁的代码必须不能睡眠，要一直持有CPU直到释放自旋锁。

  4): 信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下文使用，而自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用

       。如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适，如果对共享资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在

       中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的。自

       旋锁只有在内核可抢占或SMP（多处理器）的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作。

(1)初始化自旋锁：

              宏：     struct spinlock_t lock;       spin_lock_init(&lock);      初始化一个自旋锁，将自旋锁设置为1，表示资源可用

(2)自旋锁上锁：

             函数：  spin_lock(spinlock_t *lock);         循环等待直到自旋锁解锁（置为1），之后将自旋锁锁上（置为0）

                        spin_lock_bh(spinlock_t *lock);    循环等待直到自旋锁解锁（置为1），然后，将自旋锁锁上（置为0）。阻止软中断的底半部的执行。

                        int spin_trylock(spinlock_t *lock);  尝试锁上自旋锁（把它置为0），不管成功与否，都直接返回，而不循环等待

                       spin_lock_irq(spinlock_t *lock);     循环等待直到自旋锁解锁（置为1），然后，将自旋锁锁上（置为0）。关闭中断

             宏：    spin_lock_irqsave(lock, flags);       循环等待直到自旋锁解锁（置为1），然后，将自旋锁锁上（置为0）。关中断，将状态寄存器值存入flags。

(3)自旋锁解锁：

             函数： spin_unlock(spinlock_t *lock);               将自旋锁解锁（置为1）

                       spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);      将自旋锁解锁（置为1）。开中断，将状态寄存器值从flags存入状态寄存器。

                       spin_unlock_irq(spinlock_t *lock);      将自旋锁解锁（置为1）。开中断。

                       spin_unlock_bh(spinlock_t *lock);     将自旋锁解锁（置为1）。开启底半部的执行。

(4)其他的一些辅助函数：

                      int spin_is_locked(spinlock_t *lock);          如果自旋锁被锁上了，返回0，否则返回1

                     spin_unlock_wait(spinlock_t *lock);       等待直到自旋锁解锁（为1），返回0；否则返回1。 

(5)自旋锁与信号量或者互斥锁的使用

需求                                 建议的加锁方式

低开销加锁                        优先使用自旋锁

短期锁定                           优先使用自旋锁

长期锁定                           优先使用信号量或者是互斥锁

中断上下文加锁                  优先使用自旋锁

如果需要进入休眠、调度     优先使用信号量或者是互斥锁

5、原子操作

这部分我之后再补充

 

参考：http://blog.csdn.net/tommy_wxie/article/details/7283307

         http://blog.chinaunix.net/uid-26990992-id-3264808.html