14.1 Linux 并发与竞争

合集 - 驱动开发(33)

1.1.1 Ubuntu 系统安装2023-06-292.1.2 Ubauntu使用2023-07-133.1.3 Linux文件系统2023-07-134.2.1 Linux C 编程2023-07-175.3.1 开发环境搭建2023-07-246.4 STM32MP1 Linux系统启动过程2023-07-257.5 TF-A2023-07-308.6.1 U-boot的使用2023-07-319.6.2 U-boot 顶层 Makefile2023-08-0110.6.3 U-boot 启动流程详解2023-08-0211.6.4 U-boot 移植2023-08-0312.7 Linux 内核移植2023-08-0413.8 Buildroot 根文件系统构建2023-08-0814.9.1 字符设备驱动开发2023-08-1115.9.2 Linux LED 驱动开发2023-08-1416.10 新字符设备驱动文件2023-08-1517.11.1 Linux 设备树2023-08-1618.11.2 设备树下的 LED 驱动2023-08-1719.12 pinctrl 和 gpio 子系统2023-08-1820.13 Linux 蜂鸣器2023-08-22

21.14.1 Linux 并发与竞争2023-08-23

22.14.2 并发与竞争实验2023-08-2423.15 Linux 按键2023-08-2524.16 Linux 内核定时器2023-08-2825.17 Linux 中断2023-08-3026.18 Linux 阻塞和非阻塞 IO 2023-08-3127.19 异步通知2023-09-0428.20.1 platform 设备驱动2023-09-0529.20.2 设备树中的 platform 驱动编写2023-09-0630.21 Linux 自带的LED驱动2023-09-0731.22 Linux MISC 驱动2023-09-0932.23 Linux INPUT 子系统2023-09-1233.24 Linux PWM 驱动2023-09-14

收起

一、并发与竞争

  并发：多个执行单元同时、并行执行。

  竞争：并发的执行单元同时访问共享资源(硬件资源和软件上的全局变量等)易导致竞态。

 

二、原子操作

1. 原子操作简介

  原子操作：不能再进一步分割的操作，一般用于变量或位操作。

  例如在 C 语言中对 无符号整型变量 a 赋值：

a = 3;

  但 C 语言要先编译成汇编语言，ARM 架构不支持直接对寄存器(内存)进行读写操作，要借助寄存器 R0、 R1 等来完成赋值操作。假设变量 a 的地址为 0X3000000 ，汇编代码如下：

ldr r0, =0X30000000 // 将变量a的地址加载到寄存器r0中
ldr r1, = 3         // 写入变量a的值加载到寄存器r1中
str r1, [r0]        // 将寄存器r1中的值3写入到变量a的地址所指向的内存中

  现在假设线程 A要向 a 变量写入 10 这个值，而线程 B 也要向 a 变量写入 20 这个值，理想情况是这样：

  实际执行流程可能情况是这样：

  这算一个简单的并发与竞争的例子。要解决这个问题就需要把这三行汇编指令作为一个整体运行，也就是一个原子。

 

2. 原子整形操作 API 函数 

  Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量，如果要使用原子操作 API 函数，首先要先定义一个 atomic_t 的变量：

atomic_t a;

// 也可以在定义原子变量的时候给原子变量赋初值
atomic_t b = ATOMIC_INIT(0);    // 定义原子变量，b赋初值为0。ATOMIC_INIT就是给原子赋初值用的

  以下是操作 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，如果结果为负就返回真，否则返回假

  如果使用 64 位的 SOC 的话，就要使用 64 位的原子变量，atomic64_t ，并且以上 API 函数都要换成 64 位的。

  原子变量和相应的 API 函数举例：

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. 原子位操作 API 函数 

  原子位操作是直接对内存进行操作，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 对结构体使用期间，应禁止其他线程来访问此结构体变量，这就是自旋锁。

  当一个线程要访问某个共享资源的时候首先要先获取相应的锁，锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。如果自旋锁正在被线程 A 持有，线程 B 想要获取自旋锁，那么线程 B 就会处于忙循环-旋转-等待状态， 线程 B 回一直等待锁可用。

  自旋锁的“自旋”也就是“原地打转”的意思，“原地打转”的目的是为了等待自旋锁可以用，可以访问共享资源。 这也看出自旋锁有一个缺点：等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。自旋锁适用于短时期的轻量级加锁，如果遇到需要长时间持有锁的场景那就需要换其他的方法了。

  Linux 内核使用结构体 spinlock_t 表示自旋锁，使用自旋锁得先定义一个自旋锁变量。

spinlock_t lock;

 

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。

  自旋锁 API 适用于线程与线程之间， 自旋锁保护的临界区（临界区就是共享数据段 ）一定不能调用任何能够引起睡眠和阻塞的API 函数，否则回导致死锁现象出现。自旋锁会自动禁止抢占，也就说当线程 A 得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态，那么线程 A 会自动放弃 CPU 使用权。线程 B 开始运行，线程 B 也想要获取锁，但是此时锁被 A 线程持有，而且内核抢占还被禁止了！线程 B 无法被调度出去，那么线程 A 就无法运行，锁也就无法释放， 这就是死锁。

  在线程之间并发访问的时候，中断也想访问共享资源。中断里也能使用自旋锁，但在中断里面使用自旋锁的时候，获取锁之前需要禁止本地中断（本CPU中断），否则可能发生死锁。

 

  上图中，线程 A 抢先一步抢走 lock 锁，当线程 A 运行到 functionA 的时候，中断发生，中断抢走了 CPU 使用权，右边的中断也要这个 lock 这个锁，但这个线程会一直被线程 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_irqsave/ spin_unlock_irqrestore 函数，因为这两个函数会保存中断状态，在释放锁的时候恢复中断状态。一般在线程中使用 spin_lock_irqsave/spin_unlock_irqrestore，在中断中使用 spin_lock/spin_unlock ，示例代码如下：

spinlock_t lock;     // 定义一个自旋锁
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. 自旋锁使用注意事项

  1、因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长的话要选择其他的并发处理方式，比如信号量和互斥体。

  2、自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API 函数，否则的话可能导致死锁。

  3、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。 

  4、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。 

 

四、信号量

1. 信号量简介

  信号量是同步的一种方式，信号量也常常用于控制对共享资源的访问。 比如有一个能停 100 辆车的停车场，停车数量就是信号量，如果信号满了，需要有车开出来，信号量-1，你再开进去，信号量+1，这就是计数型信号量。

  相比于自旋锁，信号量可以使线程进入休眠状态。比如 A 和 B合租房子，A先去了厕所，过一会B也想上，B一直等着就是自旋锁，B说你完了喊我，B之后回去睡觉，这是信号量。信号量特点：

  ① 因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合。 

  ② 因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。 

  ③ 如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。 

  通过信号量控制访问资源的线程数，在初始化的时候将信号量值设置的大于 1，那么这个信号量就是计数型信号量，计数型信号量不能用于互斥访问，因为它允许多个线程同时访问共享资源。如果要互斥的访问共享资那么信号量的值就不能大于 1，此时的信号量就是一个二值信号量（只能取0和1）。 

 

2. 信号量 API 函数

  Linux 内核使用 semaphore 结构体表示信号量，结构体内容如下所示： 

struct semaphore {
    raw_spinlock_t lock;
    unsigned int count;
    struct list_head wait_list;
};

  使用信号量之前先定义，然后再初始化信号量。信号量相关 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)	释放信号量

  使用方式如下：

struct semaphore sem; /* 定义信号量 */
sema_init(&sem, 1)； /* 初始化信号量，并把sem设为1 */
down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */

 

五、互斥体

1. 互斥体简介

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

  使用 mutex 之前需要定义 mutex 变量，使用 mutex 注意以下几点：

  ① mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。 

  ② 和信号量一样， mutex 保护的临界区可以调用引起阻塞（一个线程由于某种原因无法继续执行，并进入等待状态的情况）的 API 函数。

  ③ 因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。并且 mutex 不能递归上锁和解锁。 

 

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)	使用此函数获取信号量失败进入休眠以后可 以被信号打断。

  互斥体的使用：

struct mutex lock; /* 定义一个互斥体 */
mutex_init(&lock); /* 初始化互斥体 */

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

 

六、总结

  这一章讲了并发和竞争，还有常用的原子操作（整形原子操作和位原子操作）、自旋锁、信号量和互斥体。知道这些名词的概念和常用的用法就即可。

并发：有多个线程同时执行。

竞争：多个线程同时访问共享资源。

原子操作：不能进一步分割，适用于变量或位操作。使用方式：

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

自旋锁：线程 A 对结构体使用期间，禁止其他进程对结构体使用（针对于短时期的加锁）。使用方式：

DEFINE_SPINLOCK(lock) /* 定义并初始化一个锁 */
/*
另一种方式定义和初始化:
spinlock_t lock;    // 定义一个锁
spin_lock_init(&lock);    // 初始化 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) /* 释放锁 */
}

信号量：类似与自旋锁，但是信号量可以让线程进入休眠，并且信号量针对于长时间的加锁。但是信号量值小于1的时候变为互斥体。使用方式：

struct semaphore sem; /* 定义信号量 */
sema_init(&sem, 1)； /* 初始化信号量，并把sem设为1 */
down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */

互斥体：互斥访问表示一次只有一个线程可以访问共享资源，不能递归（有了一个互斥体后再申请互斥体）申请互斥体。使用方式：

struct mutex lock; /* 定义一个互斥体 */
mutex_init(&lock); /* 初始化互斥体 */

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