本篇文章为linux在处理多线程并发访问共享内存（又叫做临界区）时，linux内核提供的几种处理方法：原子操作、自旋锁、信号量、互斥体。
文章目录
一、linux并发与竞争概述
linux中的并发是指多个线程使用到同一个共享内存，常见的并发情形如下：
- 多线程并发访问， Linux 是多任务(线程)的系统，所以多线程访问是最基本的原因。
- 抢占式并发访问，从 2.6 版本内核开始， Linux 内核支持抢占，也就是说调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程
- 中断程序并发访问，这个无需多说，学过 STM32 的同学应该知道，硬件中断的权利可是很大的。
- SMP(多核)核间并发访问，现在 ARM 架构的多核 SOC 很常见，多核 CPU 存在核间并发访问。
解决并发的方法：
- 原子操作
- 自旋锁
- 信号量
- 互斥体
二、原子操作
2.1 简介
Linux 内核提供了一组原子操作API函数来完成整型数据的原子操作，Linux 内核提供了两组原子操作API函数，一组对整形变量进行操作，一组对位进行操作。这种方式比直接操作变量更加安全。
2.2 原子操作api
//操作整型数据
ATOMIC_INIT(int 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，也就是自减
int atomic_dec_return(atomic_t *v) // 从 v 减 1，并且返回 v 的值。
int atomic_inc_return(atomic_t *v) //给 v 加 1，并且返回 v 的值。
int atomic_sub_and_test(int i, atomic_t *v) //从 v 减 i，如果结果为 0 就返回真，否则返回假
int atomic_dec_and_test(atomic_t *v) //从 v 减 1，如果结果为 0 就返回真，否则返回假
int atomic_inc_and_test(atomic_t *v) //给 v 加 1，如果结果为 0 就返回真，否则返回假
int atomic_add_negative(int i, atomic_t *v) //给 v 加 i，如果结果为负就返回真，否则返回假
//操作位数据
void set_bit(int nr, void *p) //将 p 地址的第 nr 位置 1
void clear_bit(int nr,void *p) //将 p 地址的第 nr 位清零。
void change_bit(int nr, void *p) //将 p 地址的第 nr 位进行翻转。
int test_bit(int nr, void *p) //获取 p 地址的第 nr 位的值。
int test_and_set_bit(int nr, void *p) //将 p 地址的第 nr 位置 1，并且返回 nr 位原来的值。
int test_and_clear_bit(int nr, void *p) //将 p 地址的第 nr 位清零，并且返回 nr 位原来的值。
int test_and_change_bit(int nr, void *p) //将 p 地址的第 nr 位翻转，并且返回 nr 位原来的值。
2.3 原子操作示例
atomic_t v = ATOMIC_INIT(0); /* 定义并初始化原子变零 v=0 */
atomic_set(&v, 10); /* 设置 v=10 */
atomic_read(&v); /* 读取 v 的值，肯定是 10 */
atomic_inc(&v); /* v 的值加 1， v=11 */
三、自旋锁
3.1 概念
自旋锁用于保护临界区，只有获得自旋锁的线程能操作临界区，其它需要操作临界区的线程会在原地等待，因为原地等待消耗CPU资源，所以自旋锁适用于在短期内多个线程共享资源的情况下。
3.2 自旋锁API
//普通自旋锁
DEFINE_SPINLOCK(spinlock_t lock) 定义并初始化一个自选变量。
int spin_lock_init(spinlock_t *lock) 初始化自旋锁。
void spin_lock(spinlock_t *lock) 获取指定的自旋锁，也叫做加锁。
void spin_unlock(spinlock_t *lock) 释放指定的自旋锁。
int spin_trylock(spinlock_t *lock) 尝试获取指定的自旋锁，如果没有获取到就返回 0
int spin_is_locked(spinlock_t *lock) 检查指定的自旋锁是否被获取，如果没有被获取就返回非 0，否则返回 0。
//关闭本地中断的自旋锁
void spin_lock_irq(spinlock_t *lock) 禁止本地中断，并获取自旋锁。
void spin_unlock_irq(spinlock_t *lock) 激活本地中断，并释放自旋锁。
//关闭本地中断并保存中断状态的自旋锁（推荐使用）
void spin_lock_irqsave(spinlock_t *lock,
unsigned long flags)保存中断状态，禁止本地中断，并获取自旋锁。
void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags) 将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁。
//下半部自旋锁
void spin_lock_bh(spinlock_t *lock) 关闭下半部，并获取自旋锁。
void spin_unlock_bh(spinlock_t *lock) 打开下半部，并释放自旋锁。
3.3 自旋锁示例
线程A和中断函数都需要访问临界区，当线程A获取锁的时候关闭本地中断并保存中断状态。
DEFINE_SPINLOCK(lock) /* 定义并初始化一个锁 */
/* 线程 A */
void functionA (){
unsigned long flags; /* 中断状态 */
spin_lock_irqsave(&lock, flags) /* 获取锁 */
/* 临界区 */
spin_unlock_irqrestore(&lock, flags) /* 释放锁 */
}
/* 中断服务函数 */
void irq() {
spin_lock(&lock) /* 获取锁 */
/* 临界区 */
spin_unlock(&lock) /* 释放锁 */
}
3.4 衍生的自旋锁
- 读写自旋锁：对临界区进行写操作时禁止读操作，可以多个线程并发读取临界区，分为读锁和写锁，读写锁抽象成rwlock。
DEFINE_RWLOCK(rwlock_t lock) 定义并初始化读写锁
void rwlock_init(rwlock_t *lock) 初始化读写锁。
void read_lock(rwlock_t *lock) 获取读锁。
//读锁
void read_unlock(rwlock_t *lock) 释放读锁。
void read_lock_irq(rwlock_t *lock) 禁止本地中断，并且获取读锁。
void read_unlock_irq(rwlock_t *lock) 打开本地中断，并且释放读锁。
void read_lock_irqsave(rwlock_t *lock,
unsigned long flags)
保存中断状态，禁止本地中断，并获取读锁。
void read_unlock_irqrestore(rwlock_t *lock,
unsigned long flags)
将中断状态恢复到以前的状态，并且激活本地
中断，释放读锁。
void read_lock_bh(rwlock_t *lock) 关闭下半部，并获取读锁。
void read_unlock_bh(rwlock_t *lock) 打开下半部，并释放读锁。
//写锁
void write_lock(rwlock_t *lock) 获取写锁。
void write_unlock(rwlock_t *lock) 释放写锁。
void write_lock_irq(rwlock_t *lock) 禁止本地中断，并且获取写锁。
void write_unlock_irq(rwlock_t *lock) 打开本地中断，并且释放写锁。
void write_lock_irqsave(rwlock_t *lock, unsigned long flags)保存中断状态，禁止本地中断，并获取写锁。
void write_unlock_irqrestore(rwlock_t *lock,unsigned long flags)
将中断状态恢复到以前的状态，并且激活本地中断，释放读锁。
void write_lock_bh(rwlock_t *lock) 关闭下半部，并获取读锁。
void write_unlock_bh(rwlock_t *lock) 打开下半部，并释放读锁
- 顺序锁：顺序锁的读写能同时进行
DEFINE_SEQLOCK(seqlock_t sl) 定义并初始化顺序锁
void seqlock_ini seqlock_t *sl) 初始化顺序锁
//写锁
void write_seqlock(seqlock_t *sl) 获取写顺序锁。
void write_sequnlock(seqlock_t *sl) 释放写顺序锁。
void write_seqlock_irq(seqlock_t *sl) 禁止本地中断，并且获取写顺序锁
void write_sequnlock_irq(seqlock_t *sl) 打开本地中断，并且释放写顺序锁。
void write_seqlock_irqsave(seqlock_t *sl,unsigned long flags)保存中断状态，禁止本地中断，并获取写顺序锁。
void write_sequnlock_irqrestore(seqlock_t *sl,unsigned long flags)
将中断状态恢复到以前的状态，并且激活本地中断，释放写顺序锁。
void write_seqlock_bh(seqlock_t *sl) 关闭下半部，并获取写读锁。
void write_sequnlock_bh(seqlock_t *sl) 打开下半部，并释放写读锁
//读锁
unsigned read_seqbegin(const seqlock_t *sl)读单元访问共享资源的时候调用此函数，此函数会返回顺序锁的顺序号。
unsigned read_seqretry(const seqlock_t *sl,unsigned start)读结束以后调用此函数检查在读的过程中有没有对资源进行写操作，如果有的话就要重读
3.5 自旋锁注意事项
①、因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长的话要选择其他的并发处理方式，比如稍后要讲的信号量和互斥体。
②、自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API 函数，否则的话可能导致死锁。
③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己把自己锁死了！
④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。
3.6 【补充】下半部概念
下半部和上半部是中断处理服务函数中的概念，有的中断处理比较快，有的中断处理比较耗时，为了使中断快进快出，linux提出了上半部和下半部的概念，操作快的放在上半部，操作慢的放在下半部。
四、信号量
4.1 概念
信号量允许多个线程访问临界区，信号量的数量在初始化的时候确定，线程获取到信号量则信号量减1，当信号量为0时有其它线程需要访问临界区，则该线程会进入休眠等待。
4.2 信号量API
DEFINE_SEAMPHORE(name) 定义一个信号量，并且设置信号量的值为 1。
void sema_init(struct semaphore *sem, int val) 初始化信号量 sem，设置信号量值为 val。
void down(struct semaphore *sem)获取信号量，因为会导致休眠，因此不能在中断中使用。
int down_trylock(struct semaphore *sem);尝试获取信号量，如果能获取到信号量就获取，并且返回 0。如果不能就返回非 0，并且不会进入休眠。
int down_interruptible(struct semaphore *sem)获取信号量，和 down 类似，只是使用 down 进入休眠状态的线程不能被信号打断。而使用此函数进入休眠以后是可以被信号打断的。
void up(struct semaphore *sem) 释放信号量
4.3 信号量示例
struct semaphore sem; /* 定义信号量 */
sema_init(&sem, 1); /* 初始化信号量 */
down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */
五、互斥体
5.1 概念
互斥体用于线程互斥访问临界区的场合，一次只有一个线程可以访问临界区。
5.2 互斥体API
DEFINE_MUTEX(name) 定义并初始化一个 mutex 变量。
void mutex_init(mutex *lock) 初始化 mutex。
void mutex_lock(struct mutex *lock)获取 mutex，也就是给 mutex 上锁。如果获取不到就进休眠。
void mutex_unlock(struct mutex *lock) 释放 mutex，也就给 mutex 解锁。
int mutex_trylock(struct mutex *lock)尝试获取 mutex，如果成功就返回 1，如果失败就返回 0。
int mutex_is_locked(struct mutex *lock)判断 mutex 是否被获取，如果是的话就返回1，否则返回 0。
int mutex_lock_interruptible(struct mutex *lock)使用此函数获取互斥体失败进入休眠以后可以被信号打断
5.3 互斥体示例
struct mutex lock; /* 定义一个互斥体 */
mutex_init(&lock); /* 初始化互斥体 */
mutex_lock(&lock); /* 上锁 */
/* 临界区 */
mutex_unlock(&lock); /* 解锁 */