单处理器上，因为Linux运行内核代码的进程是非抢占式的（普通的PC版），一般不会有什么太大的问题，但是再SMP系统上，则会出现相互干扰。但是新的版本可能会使内核成为可抢占式的，则要进行竞争的处理。关于竞争，操作系统中还有一个词，就是同步。竞争描述了一种不好的状态，而同步则是为解决这个问题，而出现的机制。
一. 事情发生的处理当竞争状态会出现时，我们可以使用下面的对象进行处理。
u 信号量Semaphore
信号量是用于资源访问控制的一般机制，其可以用于互斥操作。定义在<asm/semaphore.h>中，类型struct semaphore。
1. 初始化
使用信号量之前，要初始化，并指定初始值，对于互斥功能，则指定1。初始化函数：
sema_init(semaphore &, int nInit);
2. 使用
对信号量的使用，分2种，请求占用，释放。
请求：down, down_interruptible: 检查信号量的值，大于0则递减信号量的值，并返回，否则，函数进入休眠，直到其他进程释放该信号并将其唤醒之后，再进行尝试。其中，down_interruptible可以由一个信号中断，而down则不允许有信号传送到进程。在大多数情况下，都是希望信号起作用，否则可能进程无法杀掉。但是，允许信号中断使得信号量的处理复杂化了。
int down_interruptible(struct semaphore& ) 返回0 表示成功，否则出错。
释放：函数 up(struct semaphore & ) 会递增信号量的值，并唤醒所有正在等待信号量转为可用的进程。
u 内核中所有的同步处理对象都可以使用。像 Mutex等。
u 自旋锁spin_lock （303）
通常情况下，使用信号量的代价太大，因为他们会使进程休眠。而自旋锁永远不会使进程休眠。在锁不可用时，它只是简单地不停重试，直到锁被释放。在进程不会锁很长时间的情况下，使用spin_lock的开销很小。
自旋锁申明为 stuct spinlock_t类型，头文件<linux/spinlock.h>，使用前，先初始化：
spin_lock_init(spin_lock_t *lock);
在进入临界区时，使用：
spin_lick( spinlock_t *lock)
来获得锁。
释放锁时使用：
spin_unlock(spinlock_t *lock);
这是最基本的，实际上，自旋锁还有很多的操作，可以很复杂。
u 读者写者自旋锁（305）
这是一种比较特殊的的自旋锁。多个线程可以在同一时间拥有该锁进行读操作，但是当写进程或线程出现时，它会一直等待直到它获得互斥的访问。
类型是rwlock_t，可以被初始化为RW_LOCK_UNLOCKED：
rwlock_t rwl = RW_LOCK_UNLOCKED;
其使用的函数：
read_lock(rwlock_t *)
read_lock_irqsave(rwlock_t *, unsigned long flags);
read_lock_irq( rwlock_t );
read_lock_bh( rwlock_t *)
read_unlock(rwlock_t *)
read_unlock_irqrestore( relock_t*, unsigned long flags)
read_unlock_irq(rwlock_t *)
read_unlock_bh(rwlock_t *)
write_lock(rwlock_t *)
write_lock_irqsave(rwlock_t *, unsigned long flags)
write_lock_irq( rwlock_t *)
write_lock_bh( rwlock_t *)
write_unlock( rwlock_t *)
write_unlock_irqstore(rwlock_t *, unsigned long flags)
write_unlock_irq( rwlock_t *)
write_unlock_bh(rwlock_t *)
u 锁变量
内核中提供了一组对变量提供原子访问，使用他们可以减少使用更复杂的锁方案的需求。
Linux内核导出2组函数来处理锁：位操作，对“原子”数据类型的访问。
1. 位操作（307）
位操作使用单个位的锁变量或者在中断期间更新设备的状态标志（而这时可能某个进程正在访问它们）。他们定义在<asm/bitops.h>中。
void set_bit(nr, void *addr);
void clear_bit(nr, void *addr)
void change_bit(nr, void *addr)
…………
int test_and_set_bit(nr, void *addr)
int test_and_clear_bit(nr, void *addr)
int test_and_change_bit(nr, void *addr)
要说明的是，这些函数用于访问和修改一个共享的标志时，不需要其他的额外工作。而当使用它们来管理锁变量（其控制对共享标志的访问）时，则复杂一些。通常是测试并设置test_and_set_bit失败时，就循环等待测试，直到成功。而后完成工作，最后再循环进行test_and_clear_bit直到成功。
2. 整数的原子操作
在中断处理程序中，经常要和其他的函数共享整型变量。内核提供了一组独立的函数来进行原子操作，以实现共享。（308）它们在<asm/atomic.h>中定义。
现在要使用的是新的类型：atomic_t，只能通过原子操作来访问它。
void atomic_set( atomic_t *v, int i)
int atomic_read(atomic_t );
void atomic_add(int i, atomic_t *v);
void atomic_sub(int i, atomic_t *v);
void atomic_inc(atomic_t *v);
void atomic_dec(atomic_t *v);
int atomic_inc_and_test(atomic_t *v);
int atomic_dec_and_test(atomic *v);
int atomic_add_and_test(int i, atomic_t *v);
int atomic_sub_and_test(int i, atomic_t *v);
u 操作kiovec的锁（452）
int lock_kiovec( int nr, struct kiobuf *iovec[], int wait)
int unlock_kiovec(int nr, struct kiobuf *iovec[] );
u DMA自旋锁(454)
unsigned long claim_dma_lock()
void release_dma_lock()
二. 事前处理前面介绍的是解决竞争问题，是在有竞争的情况下使用的。除此之外，我们当然可以从源头上开始，避免竞争的出现。―― 处理并发访问的最好办法就是不允许并发访问。就是找出一个行之有效的办法，避免出现并发访问――避免实际上是不可能的，那么就想些办法来避免。
使用循环缓冲区就是一种有效处理并发访问的方法。做过过多线程开发，或研究过操作系统的都知道一个模型：生产者－消费者模型。生产者生成数据，放到缓冲区中，消费者从缓冲区中消费，取走数据。缓冲区数据满时，生产者等待。缓冲区空时，消费者等待。
使用2个指针来寻址循环缓冲区：head和tail。Head指向数据写入位置，只能被生产者更新。而tail指向数据读出位置，只能被消费者更新。
但是如果数据在中断期间被写入，当多次访问head时，要小心，可以使用某种锁，或者申明为volatile。
另外，当缓冲区满后，你也要选择一种解决方法，要么丢弃新到的数据，要么覆盖掉最老的数据，又或者分配新的数据区。
