Linux并发和竞争

一.原因

①、多线程并发访问， Linux 是多任务(线程)的系统，所以多线程访问是最基本的原因。
②、抢占式并发访问，从 2.6 版本内核开始， Linux 内核支持抢占，也就是说调度程序可
        以在任意时刻抢占正在运行的线程，从而运行其他的线程。
③、中断程序并发访问，这个无需多说，学过 STM32 的同学应该知道，硬件中断的权利可
        是很大的。
④、 SMP(多核)核间并发访问，现在 ARM 架构的多核 SOC 很常见，多核 CPU 存在核间并发
        访问。

二.手段

2.1 原子操作

        原子操作就是指不能在进一步分割的操作，一般原子操作用于变量或者位操作。

        原子操作只能对整形变量或者位进行保护

1.结构体定义

（include/linux/types.h）（32位和64位定义）

      

2.原子整形API

atomic_t a; //定义 a
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

void set_bit(int nr, void*p) 将 p 地址的第 nr 位置 1。
void clear_bit(intnr,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(intnr, 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 位原来的值。

4.示例

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 */

2.2 自旋锁

        自旋锁的“自旋”也就是“原地打转”的意思，“原地打转”的目的是为了等待自旋锁可以用，可以访问共享资源。

        自旋锁的一个缺点：
        那就等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。所以自旋锁适用于短时期的轻量级加锁，如果遇到需要长时间持有
锁的场景那就需要换其他的方法了.

1.结构体 spinlock_t 

2.API

DEFINE_SPINLOCK(spinlock_t lock) 定义并初始化一个自选变量。

基本API：
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) 将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁。


线程中使用 spin_lock_irqsave/ spin_unlock_irqrestore
中断中使用 spin_lock/spin_unlock

中断下半部
void spin_lock_bh(spinlock_t*lock) 关闭下半部，并获取自旋锁。
void spin_unlock_bh(spinlock_t *lock) 打开下半部，并释放自旋锁

3.示例

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); /* 释放锁 */
}

2.3 信号量

        信号量是同步的一种方式，信号量可以使线程进入休眠状态。
总结一下信号量的特点：
①、因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场
        合。
②、因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
③、如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换
        线程引起的开销要远大于信号量带来的那点优势。

1.结构体 semaphore

Linux 内核使用 semaphore 结构体表示信号量

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) 释放信号量

3.示例

struct semaphore sem; /* 定义信号量 */

sema_init(&sem, 1); /* 初始化信号量 */

down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */

2.4 互斥体

互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。

        在使用 mutex 之前要先定义一个 mutex 变量。在使用 mutex 的时候要注意如下几点：

①、 mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁（因为中
        断不参与进程调度，如果一旦在中断服务函数执行过程中休眠了，休眠了则意味着交出了
        CPU 的使用权， CPU 使用权则跑到了其它线程了，那么就不能再回到中断断点处了） 。
②、和信号量一样， mutex 保护的临界区可以调用引起阻塞的 API 函数。
③、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。
        并且 mutex 不能递归上锁和解锁。

1.结构体mutex

Linux 内核使用 mutex 结构体表示互斥体

2.API

DEFINE_MUTEX(name) 定义并初始化一个 mutex 变量。

void mutex_init(mutex *lock) 初始化 mutex。

void mutex_lock(struct mutex*lock) 获取 mutex，也就是给 mutex 上锁。如果获取不到就进休眠。
int mutex_trylock(struct mutex *lock) 尝试获取 mutex，如果成功就返回1，如果失败就返回 0。
int mutex_lock_interruptible(struct mutex *lock) 使用此函数获取信号量失败进入休眠以后可以被信号打断。

void mutex_unlock(struct mutex *lock) 释放 mutex，也就给 mutex 解锁。

int mutex_is_locked(struct mutex *lock) 判断 mutex 是否被获取，如果是的话就返回 1，否则返回 0。

3.示例

struct mutex lock; /* 定义一个互斥体 */

mutex_init(&lock); /* 初始化互斥体 */

mutex_lock(&lock); /* 上锁 */
/* 临界区 */
mutex_unlock(&lock); /* 解锁 */