一、内核同步基础概念
共享数据：能够被多个代码段访问的数据，一般指全局变量和静态变量
临界区：访问和操作共享数据的代码段
竞争条件：如果两个执行线程可能处于同一个临界区中同时执行，就被称为竞争条件发生了
同步：避免并发和防止竞争条件成为同步
内核中可能造成并发执行的原因：
- 中断 —— 中断几乎可以在任何时刻异步发生，也就可能随时打断当前正在执行的代码。
- 内核抢占 —— 因为内核具有抢占性，所以内核中的任务可能会被另一任务抢占。
- 对称多处理 （SMP）—— 两个或多个处理器可以同时执行代码。
- 软中断和tasklet —— 内核能在任何时刻唤醒或调度软中断和tasklet，打断当前正在执行的代码。
- 睡眠及与用户空间的同步 —— 在内核执行的进程可能会睡眠。这就会唤醒调度程序，从而导致调度一个新的用户进程执行。
同步是要给数据加锁，而不是给代码加锁。两个处理器绝对不能同时访问同一共享数据，如果有其他执行线程可以访问这些数据，那么就要给这些数据加上某种形式的锁。
死锁条件：要有一个或多个执行线程和一个或多个资源，每个线程都在等待其中的一个资源，但所有的资源都已经被占用了。所有线程都在相互等待，但他们永远不会释放已经占有的资源。于是任何线程都无法继续，这边意味着死锁的发生。
二、内核同步方法
1.原子操作
原子操作可以保证指令以原子的方式执行 —— 执行过程不被打断。
原子操作是其他同步方法的基石。
内核提供了两组原子操作接口 —— 一组针对整数进行操作，另一组针对单独的位进行操作。
原子整数操作：
针对整数的原子操作只能对atomic_t类型的整数进行处理。这里没有直接使用int类型原因：
- 只接受atomic_t类型的操作数，确保原子操作至于这种特殊类型数据一起使用。
- 使用atomic_t类型确保编译器不对相应的值进行访问优化，这点是的原子操作最终接收到正确的内存地址，而不是一个别名。
- 在不同体系结构上实现原子操作的时候，使用atomic_t可以屏蔽期间的差异。
atomic_t类型定义在文件<linux/types.h>中：
typedef struct {
volatile int counter;
}
定义并操作一个atomic_t类型的数据：
atomic_t v; //定义 v
atomic_t u = ATOMIC_INIT(0); //定义 u 并把它初始化为0
atomic_set(&v, 4); // v = 4
atomic_add(2, &v); // v = v + 2 = 6
atomic_inc(&v); //v = v + 1 = 7
如果需要把atomic_t转换成int型，可以使用atomic_read()来完成：
printk("%d\n", atomic_read(&v)); // 会打印 7
原子整数操作列表 原子整数操作 描述 ATOMIC_INIT（int i） 在声明一个atomic_t变量时，将它初始化为 i int atomic_read(atomic_t *v) 原子地读取整数变量 v void atomic_set（atomic_t *v，int i） 原子地设置v 值为 i void atomic_add（int i，atomic_t *v） 原子地给v加 i void atomic_sub（int i，atomic_t *v） 原子地从v减 i void atomic_inc(atomic_t *v) 原子地给v加 1 void atomic_dec(atomic_t *v) 原子地从v减 1 void atomic_sub_and_test（int i，atomic_t *v） 原子地从v减 i，如果结果等于0，返回真；否则返回假 void atomic_add_negative（int i，atomic_t *v） 原子地给v加 i，如果结果是负数，返回真；否则返回假 void atomic_add_return（int i，atomic_t *v） 原子地给v加 i，且返回结果 void atomic_sub_return（int i，atomic_t *v） 原子地给v减 i，且返回结果 void atomic_inc_return（int i，atomic_t *v） 原子地给v加 1，且返回结果 void atomic_dec_return（int i，atomic_t *v） 原子地给v减 1，且返回结果 void atomic_dec_and_test（atomic_t *v） 原子地给v减 1，如果结果等于0，返回真；否则返回假 void atomic_add_and_test（atomic_t *v） 原子地给v加 1，如果结果等于0，返回真；否则返回假 64位原子整数操作与32位基本相同，只是在函数名中atomic后加上了64，如：long atomic64_read(atomic64_t *v)
原子位操作：
除了原子整数操作，内核也提供了一组针对位这一级数据进行的操作函数。
由于原子位操作是对普通的指针进行的操作，所以不像原子整型对应atomic_t，这里没有特殊的数据类型。
e.g.
unsigned long word = 0;
set_bit(0, &word); //第0位被设置为1（原子地）
set_bit(1, &word); //第1位被设置为1（原子地）
printk("%ul\n", word); //打印 3
clear_bit(1, &word); //清空第1位
change_bit(2, &word); //翻转第2位的值，这里它被置1，因为之前为0
原子位操作列表 原子位操作 描述 void set_bit(int nr, void *addr) 原子地设置addr所指对象的第nr位 void clear_bit(int nr, void *addr) 原子地清空addr所指对象的第nr位 void change_bit(int nr, void *addr) 原子地翻转addr所指对象的第nr位 int test_and_set_bit(int nr, void *addr) 原子地设置addr所指对象的第nr位,
并返回之前的值int test_and_clear_bit(int nr, void *addr) 原子地清空addr所指对象的第nr位,
并返回之前的值int test_and_change_bit(int nr, void *addr) 原子地翻转addr所指对象的第nr位,
并返回之前的值int test_bit(int nr, void *addr) 原子地返回addr所指对象的第nr位 内核还提供了一组与上述操作对应的非原子位操作函数，但不保证原子性，且其名字多个前缀（两个下划线），如：__test_bit()。
如果数据已经加锁保护了，使用非原子位操作函数可能会执行更快一点。
2.自旋锁
linux内核中最常见的锁是自旋锁。自旋锁最多只能被一个可执行线程持有。一个被争用的自旋锁使得请求它的线程在等待所重新可用时自旋（忙等待，特别浪费处理器时间）。所以自旋锁不应该被长时间持有，这也是使用自旋锁的初衷：在短时间内进行轻量级加锁。
加锁原则：对数据加锁二不是代码加锁
加锁和解锁要成对使用，否则只加锁不解锁会造成阻塞，从而妨碍程序运行。
自旋锁实现和体系结构密切相关。这些与体系结构相关的代码定义在<asm/spinlock.h>中，实际要用到的接口定义在<linux/spinlock.h>中。
定义自旋锁：
spinlock_t lock;
初始化自旋锁：
spin_lock_init（&lock）;
在内核中，将定义和初始化自旋锁合并成一个宏：
DEFINE_SPINLOCK（lock）;
自旋锁的基本使用形式：
DEFINE_SPINLOCK(mr_lock);
spin_lock(&mr_lock);
/* 临界区...*/
spin_unlock(&mr_lock);
自旋锁方法列表 方法 描述 spin_lock() 获得指定的自旋锁 spin_lock_irq() 禁止本地中断并获取指定的锁 spin_lock_irqsave() 先保存本地中断的当前状态，禁止本地中断并获取指定的锁 spin_unlock() 释放指定的锁 spin_unlock_irq() 释放指定的锁，并激活本地中断 spin_unlock_irqrestore() 释放指定的锁，并让本地中断恢复到以前状态 spin_lock_init() 动态初始化指定的spinlock_t spin_trylock() 试图获取指定的锁，如果为获取，则返回非0 spin_is_locked() 如果指定的锁当前正在被获取，则返回非0，否则返回0 有时，锁的用途可以明确地分为读取和写入两个场景，例如：生产者和消费者问题。为此，linux内核提供了专门的读—写自旋锁。
一个或多个读任务可以并发第持有读者锁；用于写的锁只能被一个写任务持有，且此时不能有并发的读操作。
读写锁初始化：
DEFINE_RWLOCK(mr_rwlock);
在读者的代码分支中使用如下函数：
read_lock(&mr_rwlock);
/* 临界区（只读）...... */
read_unlock(&mr_rwlock);
在写者的代码分支中使用如下函数：
write_lock(&mr_rwlock);
/* 临界区（读写）...... */
write_unlock(&mr_rwlock);注意：读锁和写锁不能混用，否则会造成死锁，如下：
read_lock(&mr_rwlock);
write_lock(&mr_rwlock);
3.信号量
linux中的信号量是一种睡眠锁。如果一个任务试图获得一个不可用（已经被占用）的信号量时，信号量会把它推进到一个等待队列，然后将其睡眠
当持有的信号量可用（被释放）后，处于等待队列中的任务将被唤醒，并获得该信号量。
信号量比自旋锁提供了更好的处理器利用率，因为没有把时间花在忙等待上，但是信号量比自旋锁有更大的开销（任务睡眠和唤醒涉及两次进程调度）。
创建和初始化信号量：
信号量具体定义在<asm/semaphore.h>（前面说过，与体系结构相关的实现都定义在asm下）中。
静态声明信号量：
struct semaphore name;
sema_init(&name, count); //name是信号量变量名，count是信号量的可使用数量
未指定count的信号量默认为1，即互斥信号量。
信号量使用down() 和 up()操作来请求获得和释放一个信号量。
down（）操作通过对信号量计数减一来请求获得一个信号量。如果结果是0或者大于0，获得信号量锁，任务就可以进入临界区。如果是负数，任务会被放入等待队列，处理器执行其他任务。
up（）操作用来释放信号量，它会增加信号量的计数值。如果在该信号量上的等待队列不为空，则处于队列中的等待任务在被唤醒的同时会获得该信号量。
信号量使用举例：
static DECLARE_MUTEX(mr_sem); //定义并声明一个互斥信号量，名字为mr_sem，用于信号量计数
if (down_interruptible(&mr_sem)) //试图获取信号量，如果此时没有获得信号量，则进入等待队列，直到获得信号量
{
/* 临界区...... */
}
up(&mr_sem); //释放给定的信号量
信号量方法列表 方法 描述 sema_init(struct semaphore *sem, int count) 以指定的计数值初始化动态创建信号量 init_MUTEX(struct semaphore *) 以计数值 1 初始化动态创建信号量 init_MUTEX_LOCKED(struct semaphore *) 以计数值 0 初始化动态创建信号量
(初始化为加锁状态)down(struct semaphore *) 试图获得指定的信号量，如果信号量
已被争用，则进入不可中断睡眠状态down_interruptible(struct semaphore *) 试图获得指定的信号量，如果信号量
已被争用，则进入可中断睡眠状态down_trylock(struct semaphore *) 试图获得指定的信号量，如果信号量
已被争用，则立刻返回非0值up(struct semaphore *) 释放指定的信号量，如果睡眠队列不空，
则唤醒其中一个任务
读写信号量：
static DECLARE_RESEM(mr_rwsem);
down_read(&mr_rwsem);
/* 临界区 （只读）*/
up_read(&mr_rwsem);
down_write(&mr_rwsem);
/* 临界区 （读写）*/
up_write(&mr_rwsem);
互斥体：
互斥体是一个更简单的睡眠锁，其行为和计数为1的信号量类似，单接口更简单，实现也更高效，使用限制更强。
静态定义mutex：
DEFINE_MUTEX(mutex); //mutex为互斥体的名字
动态初始化mutex：
mutex_init(&mutex);
对互斥锁锁定和解锁：
mutex_lock(&mutex);
/* 临界区 */
mutex_unlock(&mutex);
Mutex方法 方法 描述 mutex_lock(struct mutex*) 为指定的mutex上锁，如果所不可用则睡眠 mutex_unlock(struct mutex*) 为指定的mutex解锁 mutex_trylock(struct mutex*) 试图获取指定的mutex，如果成功返回1；否则返回0 mutex_is_locked(struct mutex*) 如果锁已被争用，则返回1；否则返回0
完成量：
定义在头文件linux/completion.h中：
完成量(completion)是Linux系统提供的一种比信号量更好的同步机制，是对信号量的一种补充。
它用于一个执行单元等待另一个执行单元完成某事。使用完成量等待时,调用进程是以独占睡眠方式进行等待的，不是忙等待。
请参考：
http://bdxnote.blog.163.com/blog/static/84442352012427113929430/