linux的并发与竞争

并发与竞争简介

并发就是多个“用户”同时访问一个资源（所以解决的方法就是让这一个资源每个时刻只能有一个用户访问，hhh）

Linux系统并发产生的原因，主要有以下几种

• 多线程并发访问，linux是多任务（线程）的系统
• 抢占式并发访问，从2.6版本内核开始，linux内核支持抢占，也就是说调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程
• 中断程序并发访问
• SMP（多核）核间并发访问，现在 ARM 架构的多核 SOC 很常见，多核 CPU 存在核间并发访问。

上面指的资源就是临界区临界区就是共享数据段，对于临界区必须保证一次只有一个线程访问

原子操作

原子操作就是不能再进一步分割的操作，一般原子操作用于变量或者位操作，或许你会以为a=3;这个赋值操作是原子操作，但是C语言要先编译为汇编指令，ARM架构不支持直接对寄存器进行读写操作，比如要借助寄存器 R0、 R1 等来完成赋值操作。假设变量 a 的地址为 0X3000000，“a=3”这一行 C语言可能会被编译为如下所示的汇编代码：

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

有线程A和线程B，设现在线程 A要向 a 变量写入 10 这个值，而线程 B 也要向 a 变量写入 20 这个值，我们理想中的执行顺序如图所示

但是实际的流程可能是这个样子

从而到最后线程A的值变成了20，但是线程A的取值应该是10的。
要解决这个问题的最简单的方法就是让上面的三行语句作为一个整体运行，也就是作为一个原子操作存在。
linux内核提供了一组原子操作API函数来完成此功能，Linux 内核提供了两组原子操作 API 函数，一组是对整形变量进行操作的，一组是对位进行操作的，我们接下来看一下这些 API 函数。

原子整型操作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 向原子变量赋初值。

上面是针对32位原子操作，64位原子操作函数只是将atomic_前缀变成atomic64_
原子变量和API函数使用：

atomic_t v = ATOMIC_INIT(0);		//定义并初始化原子变量v=0

atomic_set(10);			//设置v=10
atomic_read(&v);		//读取v的值，肯定是10
atomic_inc(&v);			//V的值加1，v=11

原子位操作API函数

原子位操作是直接对内存进行操作，相关的API函数如表所示

自旋锁

自旋锁简介

原子操作只能对整型变量或者位进行保护。但是在实际中不仅仅只有只有整型变量和位这样简单的临界区。举个简单的例子，设备结构体变量就不是整型变量，我们对于结构体中的成员变量操作也要保证原子性，在线程A对结构体变量使用期间，应该禁止其他的线程来访问此结构体变量，在这里可以用到自旋锁。

自旋锁是一种用于保护多线程共享资源的锁，与一般互斥锁不同之处在于自旋锁尝试获取锁时以忙等待的形式不断的循环检查锁是否可用。

在多cpu的环境下，对持有锁较短的程序来说，使用自旋锁代替一般的互斥锁往往能够提高程序的性能
linux内核使用结构体spinlock_t表示自旋锁:

 64 typedef struct spinlock {
     
 65     union {
     
 66         struct raw_spinlock rlock;
 67 
 68 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 69 # define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
 70         struct {
     
 71             u8 __padding[LOCK_PADSIZE];
 72             struct lockdep_map dep_map;
 73         };
 74 #endif
 75		};
 76 }spinlock_t;

在使用自旋锁之前，肯定要先定义一个自旋锁变量，定义方法如下:
spinlock_t lock;//定义自旋锁

自旋锁API函数

上述自旋锁的API函数适用于SMP(多核)或支持抢占的单CPU下线程之间的并发访问，也就是用于线程与线程之间，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API函数，否则会导致死锁现象的发生。

表中的 API 函数用于线程之间的并发访问，如果此时中断也要插一脚，中断也想访问共享资源，那该怎么办呢？首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断，对于多核 SOC来说会有多个 CPU 核)，否则可能导致死锁现象的发生

线程A先运行，并且获得了lock这个锁，当线程A运行到函数functionA的时候，发生了中断，中断服务函数也要获得lock这个锁，但是此时线程A一直占有lock这个锁，中断一直自旋，从而产生了死锁。
最好的解决办法是在获取锁之前关闭本地中断

使用 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)		//释放锁
}

信号量

相比于自旋锁，信号量可以使线程进入休眠状态，比如 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;
};

有关信号量的 API 函数如表

互斥体

Linux 提供了一个比信号量更专业的机制来进行互斥，它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。在我们编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex。 Linux 内核使用 mutex 结构体表示互斥体

struct mutex {
     
/* 1: unlocked, 0: locked, negative: locked, possible waiters */
	atomic_t count;
	spinlock_t wait_lock;
};

在使用 mutex 之前要先定义一个 mutex 变量。在使用 mutex 的时候要注意如下几点：
①、 mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
②、和信号量一样， mutex 保护的临界区可以调用引起阻塞的 API 函数。
③、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。并且 mutex 不能递归上锁和解锁。

有关互斥体的 API 函数如表