Linux并发与竞争

Linux是一个多任务操作系统，肯定会存在多个任务共同操作同一段内存或者设备的情况，多个任务甚至中断都能访问的资源叫做共享资源，就和共享单车一样。在驱动开发中要注意对共享资源的保护，也就是要处理对共享资源的并发访问。比如共享单车，大家按照谁扫谁骑走的原则来共用这个单车，如果没有这个并发访问共享单车的原则存在，只怕到时候为了一辆单车要打起来了。在Linux驱动编写过程中对于并发控制的管理非常重要。

一、并发与竞争

1、并发与竞争简介
Linux系统是个多任务操作系统，会存在多个任务同时访问同一片内存区域，这些任务可能会相互覆盖这段内存中的数据，造成内存数据混乱。针对这个问题必须要做处理，严重的话可能会导致系统崩溃。现在的Linux系统并发产生的原因很复杂，总结一下有下面几个主要原因：

• ①、多线程并发访问，Linux是多任务（线程）的系统，所以多线程访问是最基本的原因。
• ②、抢占式并发访问，从2.6版本内核开始，Linux内核支持抢占，也就是说调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程。
• ③、中断程序并发访问。
• ④、SMP(多核）核间并发访问，现在ARM架构的多核SOC很常见，多核CPU存在核间并发访问。
  2、保护内容
  前面一直说要防止并发访问共享资源，换句话说就是要保护共享资源，防止进行并发访问。那么问题来了，什么是共享资源？现实生活中的公共电话、共享单车这些是共享资源，我们都很容易理解，那么在程序中什么是共享资源？也就是保护的内容是什么？我们保护的不是代码，而是数据！某个线程的局部变量不需要保护，我们要保护的是多个线程都会访问的共享数据。一个整形的全局变量a是数据，一份要打印的文档也是数据，虽然知道了要对共享数据进行保护，那么怎么判断哪些共享数据要保护呢？找到要保护的数据才是重点，而这个也是难点，因为驱动程序各不相同，那么数据也千变万化，一般像全局变量，设备结构体这些肯定是要保护的，至于其他的数据就要根据实际的驱动程序而定了。当发现驱动程序中存在并发和竞争的时候一定要处理掉，接下来依次来学习一下Linux内核提供的几种并发和竞争的处理方法。

二、原子操作

1、原子操作简介

原子操作就是指不能再进一步分割的操作，一般原子操作用于变量
或者位操作。假如现在要对无符号整形变量a赋值，值为3，对于C语言来讲很简单，直接就是：

a=3

但是C语言要先编译为成汇编指令，ARM架构不支持直接对寄存器进行读写操作，比如要借助寄存器RO、R1等来完成赋值操作。假设变量a的地址为0X3000000，“a=3”这一行C语言可能会被编译为如下所示的汇编代码：

ldr r0,=0X30000000/*变量a地址*/
ldr r1 , = 3/*要写入的值*/
str r1, [r0]/*将3写入到a变量中*/

示例代码只是一个简单的举例说明，实际的结果要比示例代码复杂的多。从上述代码可以看出，C语言里面简简单单的一句“a=3”，编译成汇编文件以后变成了3句，那么程序在执行的时候肯定是按照示例代码中的汇编语句一条一条的执行。假设现在线程A要向a变量写入10这个值，而线程B也要向a变量写入20这个值，我们理想中的执行顺序如下图所示：
按照上图所示的流程，确实可以实现线程A将a变量设置为10，线程B将a变量设置为20。但实际上的执行流程可能如下所示：
按照上图所示的流程，线程A最终将变量a设置为了20，而并不是要求的10！线程B没有问题。这就是一个最简单的设置变量值的并发与竞争的例子，要解决这个问题就要保证示例代码中的三行汇编指令作为一个整体运行，也就是作为一个原子操作。Linux内核提供了一组原子操作API函数来完成此功能，Linux内核提供了两组原子操作API函数，一组是对整形变量进行操作的，一组是对位进行操作的，我们接下来看一下这些API函数。

2、原子整型操作API函数
Linux内核定义了叫做atomic_t的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量，此结构体定义include/linux/types.h文件中，定义如下：

typedef struct {
int counter;
} atomic_t;

如果要使用原子操作API函数，首先要先定义一个atomic_t的变量，如下所示：

atomic_t a;//定义a

也可以在定义原子变量的时候给原子变量赋初值，如下所示：

atomic_t b=ATOMIC_INIT(0);/定义原子变量b并赋初值为0

可以通过宏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,如果结果为负就返回真，否则返回假。

3、原子位操作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位原来的值。

三、自旋锁

1、自旋锁简介
原子操作只能对整形变量或者位进行保护，但是，在实际的使用环境中怎么可能只有整形变量或位这么简单的临界区。举个最简单的例子，设备结构体变量就不是整型变量，对于结构体中成员变量的操作也要保证原子性，在线程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函数来操作自旋锁。
2、自旋锁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就无法运行，锁也就无法释放，好了，死锁发生了！API函数用于线程之间的并发访问，如果此时中断也要插一脚，中断也想访问共享资源，那该怎么办呢？首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断（也就是本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并发与竞争就讲解到这里啦！！！