某次在知乎上看到了一个很有意思的提问，怎么可以拥有多个女朋友并且还能不被其中的任何一个女朋友察觉，见到这个问题我的眼睛顿时亮了。并且还点进去了回答瞅了瞅，大多数回答都是在想peach！然后从我最近学习操作系统还有Linux的角度来看，这不就是得用到并发相关的知识嘛！只要手速足够快、移动速度非常快轮着和多个女朋友回消息谈恋爱好像也没有什么问题！
那么在Linux操作系统中也一样的，需要同时执行多个任务或者多个任务同时访问一个资源。那么这个时候应该怎么办呢？这里就要用到Linux并发与竞争。通俗一点的例子就是，我们学校只有一个妹子小花。学校的男生都可以和这个妹子谈恋爱，但是现在张三和李四都非常的寂寞都想谈恋爱，那么他们两个人谈恋爱肯定不能相互影响啊！如果相互影响的话那张三和李四不得干架？那么小花只能选择和张三还是李四先谈，谈完以后分手再和另一个谈。因此在Linux中如果多个任务访问同一个资源就会造成系统崩溃。
往期推荐：
从单片机到ARM Linux驱动——Linux驱动入门
Linux字符驱动设备开发——让开发板的led灯闪烁
写在前面：由于作者能力有限，文中部分内容摘抄自正点原子I.MX6U嵌入式Linux开发指南,并非抄袭某些直接将正点原子驱动开发指南给搬砖到CSDN的博主的文章！请友善对待嵌入式驱动入门新手，本文章纯属作为个人学习笔记记录于CSDN平台，请勿恶意举报！
写在前面：由于作者能力有限，文中部分内容摘抄自正点原子I.MX6U嵌入式Linux开发指南,并非抄袭某些直接将正点原子驱动开发指南给搬砖到CSDN的博主的文章！请友善对待嵌入式驱动入门新手，本文章纯属作为个人学习笔记记录于CSDN平台，请勿恶意举报！
写在前面：由于作者能力有限，文中部分内容摘抄自正点原子I.MX6U嵌入式Linux开发指南,并非抄袭某些直接将正点原子驱动开发指南给搬砖到CSDN的博主的文章！请友善对待嵌入式驱动入门新手，本文章纯属作为个人学习笔记记录于CSDN平台，请勿恶意举报！
Linux并发产生的原因
- 多线程并发访问，由于Linux是多任务（线程）的系统，所以多线程访问是最基本的原因。
- 抢占式并发访问，自Linux 2.6版本内核开始，linux支持抢占，也就是说调度程序可以在任意时刻抢占正运行的线程，从而运行其他的线程。
- 中断程序并访问，硬件可以通过外部中断、定时器中断…等来
- SMP（多核）核间并发访问，现在ARM架构的多核SOC很常见，多核CPU存在核间并发访问
并发访问带来的问题就是竞争，在UCOS中有个临界区这个概念，所谓的临界区就是共享数据段，对于临界区必须保证一次只有一个线程访问，保证灵界去的访问是原子的。因此在编写驱动程序中就要考虑到并发与竞争，而不是在编写完驱动程序时再考虑并发与竞争。考虑并发与竞争的主要原因是保护共享资源，而我们保护的并不是线程的局部变量，而是多个线程的共享数据。
原子操作
原子操作就是指不能进一步分割的指令，一般原子操作用于变量或者位操作。
C语言中给变量a赋值为10直接就是一个短短的语句a=10，但是在程序执行的时候需要将程序先编译成汇编文件，ARM架构不支持直接对寄存器进行读写操作，比如需要借助寄存器R0、R1来完成赋值操作。假设变量a的地址为0X5000000,a=10这一行C语言程序就可能被编译成如下的汇编代码：
ldr r0, =0X50000000 /* 变量a地址 */
ldr r1, = 10 /* 要写入的值 */
str r1, [r0] /* 将5写入到a变量中 */
可以看出C语言中的简单的赋值语句到了汇编中就会变成3句，而程序在执行指令时就是按照汇编的代码一条一条的执行。假设现在线程A要向a变量写入10这个值，而线程B要也要向变量写入20这个值，理想的执行顺序应该如下：
如图所示的流程，确实可以实现线程A将a变量设置为10,线程B将a变量设置为20。但是实际上执行的流程可能就是下图这样：
按照如图所示的流程，线程A最终将变量a设置成了20，并不是要求的10，而线程B没有问题。这就是一个最简单的设置变量值的并发与竞争的例子，要解决这个问题那么我们就需要图中的3条汇编语句作为一个整体而运行，Linux内核提供了一组原子操作API函数来完成此功能，同时提供了两组原子操作API函数，一组是对整形变量进行操作，一组是对位进行操作。
原子整形操作API函数
Linux内核定义了叫做atomic_t的结构体来完成整形数据的原子操作，在使用时用原子变量代替整形变量，结构体定义如下：
typedef struct{
int counter;
}atomic_t;
如果要使用原子操作API函数，首先要定义一个atomic_t的变量。
atomic_t a;//定义a
也可以在定义的时候通过宏定义ATOMIC_INIT向原子变量赋初值。原子变量有了，接下来就是对原子变量进行操作，比如读、写、增加、减少等等，Linux内核提供了大量的原子操作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，如果结果为负就返回真，否则返回假 |
原子位操作API函数
位操作也是很常用的操作，Linux提供了一系列的原子位操作API函数，只不过原子位操作不像原子整形变量那样有个 atomic_t的数据结构，原子位操作是直接对内存进行操作，API函数如下图所示：
| 函数 | 描述 |
|---|---|
| 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位原来的值。 |
自旋锁
原子操作只能对整形变量或者位进行保护，但是，在实际的使用环境中怎么可能只有整形变量或位这么简单的临界区。举个最简单的例子，设备结构体变量就不是整型变量，我们对于结构体中成员变量的操作也要保证原子性，在线程 A对结构体变量使用期间，应该禁止其他的线程来访问此结构体变量，这些工作原子操作都不能胜任，那么Linux内核就通过自旋锁来胜任这个工作。
当一个线程要访问某个 共享资源 的时候首先要先获取相应的锁， 锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程A持有，线程 B想要获取自旋锁，那么线程 B就会处于忙循环->旋转 ->等待状态，线程 B不会进入休眠状态或者说去做其他的处理，而是会一直傻傻的在那里“转圈圈”的等待锁可用。比如现在有个公用电话亭，一次肯定只能进去一个人打电话，现在电话亭里面有人正在打电话，相当于获得了自旋锁。此时你到了电话亭门口，因为里面有人，所以你不能进去打电话，相当于没有获取自旋锁，这个时候你肯定是站在原地等待，你可能因为无聊的等待而转圈圈消遣时光，反正就是那里也不能去，要一直等到里面的人打完电话出来。终于，里面的人打完电话出来了，相当于 释放了自旋锁，这个时候你就可以使用电话亭打电话了，相当于获取到了自旋锁。
自旋锁的“自旋”也就是原地转圈圈的意思，转圈圈是为了等待自旋锁可用，可以访问共享资源。把自旋锁比作一个变量 a，变量 a=1的时候表示共享资源可用，当 a=0的时候表示共享资源不可用。现在线程 A要访问共享资源，发现 a=0(自旋锁被其他线程持有那么线程 A就会不断的查询 a的值，直到 a=1。从这里我们可以看到自旋锁的一个缺点：那就是等待自旋锁的线程会一直处于自选状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。适用于轻量级的加锁，如果遇到需要长时间持有的场景那就需要换其他的方法了。
Linux内核通过spinlock_t表示自旋锁，结构体定义如下：
typedef struct spinlock {
union {
struct raw_spinlock rlock;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
struct {
u8 __padding[LOCK_PADSIZE];
struct lockdep_map dep_map;
};
#endif
};
}spinlock_t;
在使用自旋锁之前，肯定需要先定义一个自旋锁变量，定义方法如下：
spinlock_t lock;//定义自旋锁
定义好自旋锁变量以后就可以使用相应的API函数来操作自旋锁。基本的自旋锁的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。 |
表中的自旋锁API函数适用于SMP或支持抢占的单CPU下线程之间的并发访问，也就是用于线程与线程之间。被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。自旋锁会自动禁止抢占，也就说当线程A得到锁以后会暂时禁止内核抢占。如果线程A 在持有锁期间进入了休眠状态，那么线程A 会自动放弃CPU 使用权。线程B 开始运行，线程B 也想要获取锁，但是此时锁被A 线程持有，而且内核抢占还被禁止了！线程B 无法被调度出去，那么线程A 就无法运行，锁也就无法释放，然后，死锁发生了！
如果在使用这些函数时，中断非要来插手使用公共资源的话应该怎么办呢？可以肯定的是，中断里面是可以使用自旋锁，但是中断里面使用自旋锁的时候，在获取锁之前一定要禁止本地中断（也就是本CPU 中断，对于多核SOC 来说会有多个CPU 核)，否则可能导致锁死现象的发生。
线程A先运行，并且获得lock这个锁，当线程A运行到functionA函数的时候中断发生了，中断抢走了CPU的使用权。右边的中断服务函数也要获取lock这个锁，但是这个锁被线程A占有着，中断就会一直自选，等待锁有效。但是中断服务函数没有完成之前，线程A是不可能执行的，线程A说你放手，中断说你先放手，场面就这样僵持着，死锁就发生了！最好的解决办法就是获取锁之前关闭本地中断，Linux内核提供了相应的API函数，如下表所示：
| 函数 | 描述 |
|---|---|
| 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) | 将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁。 |
使用 spin_lock_irq/spin_unlock_irq的时候需要用户能够确定加锁之前的中断状态，但实际上内核很庞大，运行也是“千变万化”，我们是很难确定某个时刻的中断状态，因此不推荐使用spin_lock_irq/spin_unlock_irq。建议使用 spin_lock_irqsave/ spin_unlock_irqrestore，因为这一组函数会保存中断状态，在释放锁的时候会恢复中断状态。一般在线程中使用 spin_lock_irqsave/ spin_unlock_irqrestore，在中断中使用 spin_lock/spin_unlock，示例代码如下所示：
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) /* 释放锁 */
}
linux中断分为上半部（顶半步）和下半部（底半部）
| Linux中断分类 | 作用 | 特点 |
|---|---|---|
| 顶半部（上半部） | 完成尽可能少的比较紧急的任务，它往往只是简单的读取寄存器中的中断状态并清除中断标志后就进行”登记中断“（也就是将底半部处理程序挂到设备的底半部执行队列中）的工作 | 响应速度快 |
| 底半部（下半部） | 中断处理的大部分工作都在底半部，它几乎做了中断处理程序的所有事情 | 处理相对不是非常紧急的事情 |
下半部（BH）也会竞争共享资源，如果下半部里面使用自旋锁，可以使用以下表中的API函数：
| 函数 | 描述 |
|---|---|
| void spin_lock_bh(spinlock_t *lock) | 关闭下半部，并获取自旋锁。 |
| void spin_unlock_bh(spinlock_t *lock) | 打开下半部，并释放自旋锁。 |
其他的锁
在Linux并发在自旋锁的基础上还衍生出来了其他特定场合使用的锁，这些锁在驱动中其实用的不太多，更多的是在Linux内核中使用！
读写自旋锁
现在有个学生信息表，此表存放着学生的年龄、家庭住址、班级等信息，这个表可以随时被修改和读取。此表肯定是数据，那么必须要对其进行保护。如果我们需要使用自旋锁对其进行保护。每次只能一个读操作或者写操作，但是实际上此表是可以并发读取的。只需要保证在修改此表的时候没人读取，或者在其他人读取此表的时候没有人修改此表就行了。也就是此表的读和写不能同时进行操作，但是可以多人并发的读取表的内容。
读写自旋锁为读和写操作提供了不同的锁，一次只能允许一个 写操作，也就是只能一个线程持有写锁，而且不能进行读操作。但是当没有写操作的时候允许一个或多个线程持有读锁，可以进行并发的读操作。 Linux内核使用 rwlock_t结构体表示读写锁，结构体定义如下 (删除了条件编译)。
typedef struct{
arch_rwlock_t raw_lock;
}rwlock_t;
顺序锁
顺序锁在读写锁的基础上衍生而来的，使用读写锁的时候读操作和写操作不能同时进行。使用顺序锁的话可以允许在写的时候进行读操作，也就是实现同时读写，但是不允许同时进行并发的写操作。虽然顺序锁的读和写操作可以同时进行，但是如果在读的过程中发生了写操作，最好重新进行读取，保证数据完整性。顺序锁保护的资源不能是指针，因为如果在写操作的时候可能会导致指针无效，而这个时候恰巧有读操作访问指针的话就可能导致意外发生，比如读取野指针导致系统崩溃。 Linux内核使用 seqlock_t结构体表示顺序锁，结构体定义如下：
typedef struct {
struct seqcount seqcount;
spinlock_t lock;
} seqlock_t;
自旋锁使用注意事项
①、因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长可以通过信号量和互斥体。
②、自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API函数，否则的话可能导致死锁。
③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己把自己锁死了！
④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不论你用的是单核的还是多核的 SOC，都将其当做多核 SOC来编写驱动程序。
信号量
Linux内核内核也提供了信号量机制，信号量常常用于控制对共享资源的访问。相比于自旋锁，信号量可以使线程进入休眠状态，比如 A与 B、 C合租了一套房子，这个房子只有一个厕所，一次只能一个人使用。某 一天早上 A去上厕所了，过了一会 B也想用厕所，因为 A在厕所里面，所以 B只能等到 A用来了才能进去。 B要么就一直在厕所门口等着，等 A出来，这个时候就相当于自旋锁。 B也可以告诉 A，让 A出来以后通知他一下，然后 B继续回房间睡觉，这个时候相当于信号量。可以看出，使用信号量会提高处理器的使用效率，毕竟不用一直傻乎乎的在那里“自选”等待。但是，信号量的开销要比自旋锁大，因为信号量使线程进入休眠状态以后会切换线程，切换线程就会有开销。总结一下信号量的特点：
①、因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资 源比较久的场合。
②、因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
③、如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。
Linux内核使用 semaphore结构体表示信号量，结构体内容如下所示：
struct semaphore {
raw_spinlock_t lock;
unsigned int count;
struct list_head wait_list;
};
要想使用信号量就得先定义，然后初始化信号量。
| 函数 | 描述 |
|---|---|
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) | 释放信号量 |
互斥体
Linux提供了一个比信号量更专业的机制来进行互斥，它就是互斥体——mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。在我们编写 Linux驱动的时候遇到需要互斥访问的地方建议使用 mutex。 Linux内核使用 mutex结构体表示互斥体，定义如下(省略条件编译):
struct mutex {
atomic_t count;
spinlock_t wait_lock;
}
在使用mutex之前要先定义一个mutex变量。在使用mutex的时候需要注意如下几点：
①、 mutex可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
②、和信号量一样，mutex保护的临界区可以调用引起阻塞的 API函数。
③、因为一次只有一个线程可以持有 mutex，因此必须由 mutex的持有者释放 mutex。并且 mutex不能递归上锁和解锁。
| 函数 | 描述 |
|---|---|
| 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) | 使用此函数获取信号量失败进入休眠以后可 |
互斥体的使用流程如下：
struct mutex lock;//定义一个互斥体
mutex_init(&lock);//初始化互斥体
mutex_lock(&lock);//上锁
/*临界区*/
mutex_unlock(&lock);//解锁
不积小流无以成江河，不积跬步无以至千里。而我想要成为万里羊，就必须坚持学习来获取更多知识，用知识来改变命运，用博客见证成长，用行动证明我在努力。
如果我的博客对你有帮助、如果你喜欢我的博客内容，记得“点赞” “评论” “收藏”一键三连哦！听说点赞的人运气不会太差，每一天都会元气满满呦！如果实在要白嫖的话，那祝你开心每一天，欢迎常来我博客看看。
扫一扫
221
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
