正点原子imx6ull-mini-Linux驱动之并发与竞争（7）

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

1：并发与竞争

1.1：并发与竞争简介

并发就是多个“用户”同时访问同一个共享资源，比如你们公司有一台打印机，你们公司 的所有人都可以使用。现在小李和小王要同时使用这一台打印机，都要打印一份文件。小李要 打印的文件内容如下：

我叫小李
电话：123456
工号：16

小王要打印的内容如下：

我叫小王
电话：678910
工号：20

这两份文档肯定是各自打印出来的，不能相互影响。当两个人同时打印的话如果打印机不做处 理的话可能会出现小李的文档打印了一行，然后开始打印小王的文档，这样打印出来的文档就错乱 了，可能会出现如下的错误文档内容：

我叫小王
电话：123456
工号：20

可以看出，小王打印出来的文档中电话号码错误了，变成小李的了，这是绝对不允许的。如 果有多人同时向打印机发送了多份文档，打印机必须保证一次只能打印一份文档，只有打印完成以 后才能打印其他的文档。

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

①、多线程并发访问，Linux 是多任务(线程)的系统，所以多线程访问是最基本的原因。

②、抢占式并发访问，从 2.6 版本内核开始，Linux 内核支持抢占，也就是说调度程序可以 在任意时刻抢占正在运行的线程，从而运行其他的线程。

③、中断程序并发访问，这个无需多说，学过 STM32 的同学应该知道，硬件中断的权利可 是很大的。

④、SMP(多核)核间并发访问，现在 ARM 架构的多核 SOC 很常见，多核 CPU 存在核间并 发访问。

并发访问带来的问题就是竞争，学过FreeRTOS和UCOS的同学应该知道临界区这个概念， 所谓的临界区就是共享数据段，对于临界区必须保证一次只有一个线程访问，也就是要保证临 界区是原子访问的，注意这里的“原子”不是正点原子的“原子”。我们都知道，原子是化学反 应不可再分的基本微粒，这里的原子访问就表示这一个访问是一个步骤，不能再进行拆分。如 果多个线程同时操作临界区就表示存在竞争，我们在编写驱动的时候一定要注意避免并发和防 止竞争访问。很多 Linux 驱动初学者往往不注意这一点，在驱动程序中埋下了隐患，这类问题往往又很不容易查找，导致驱动调试难度加大、费时费力。所以我们一般在编写驱动的时候就 要考虑到并发与竞争，而不是驱动都编写完了然后再处理并发与竞争。

1.2：保护内容是什么

前面一直说要防止并发访问共享资源，换句话说就是要保护共享资源，防止进行并发访问。 那么问题来了，什么是共享资源？现实生活中的公共电话、共享单车这些是共享资源，我们都 很容易理解，那么在程序中什么是共享资源？也就是保护的内容是什么？我们保护的不是代码， 而是数据！某个线程的局部变量不需要保护，我们要保护的是多个线程都会访问的共享数据。 一个整形的全局变量 a 是数据，一份要打印的文档也是数据，虽然我们知道了要对共享数据进 行保护，那么怎么判断哪些共享数据要保护呢？找到要保护的数据才是重点，而这个也是难点， 因为驱动程序各不相同，那么数据也千变万化，一般像全局变量，设备结构体这些肯定是要保 护的，至于其他的数据就要根据实际的驱动程序而定了。 当我们发现驱动程序中存在并发和竞争的时候一定要处理掉，接下来我们依次来学习一下 Linux 内核提供的几种并发和竞争的处理方法。

2：原子操作

2.1：原子操作简介

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

a = 3

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

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

示例代码 47.2.1.1 只是一个简单的举例说明，实际的结果要比示例代码复杂的多。从上述 代码可以看出，C 语言里面简简单单的一句“a=3”，编译成汇编文件以后变成了 3 句，那么程 序在执行的时候肯定是按照示例代码 47.2.1.1 中的汇编语句一条一条的执行。假设现在线程 A 要向 a 变量写入 10 这个值，而线程 B 也要向 a 变量写入 20 这个值，我们理想中的执行顺序如 图 47.2.1.1 所示

 按照图 47.2.1.1 所示的流程，确实可以实现线程 A 将 a 变量设置为 10，线程 B 将 a 变量设 置为 20。但是实际上的执行流程可能如图 47.2.1.2 所示：

 按照图 47.2.1.2 所示的流程，线程 A 最终将变量 a 设置为了 20，而并不是要求的 10！线程 B 没有问题。这就是一个最简单的设置变量值的并发与竞争的例子（想起了通信里的非正交），要解决这个问题就要保证 示例代码 47.2.1.2 中的三行汇编指令作为一个整体运行，也就是作为一个原子存在。Linux 内核 提供了一组原子操作 API 函数来完成此功能，Linux 内核提供了两组原子操作 API 函数，一组 是对整形变量进行操作的，一组是对位进行操作的，我们接下来看一下这些 API 函数。

2.2：原子整形操作 API 函数

Linux 内核定义了叫做 atomic_t（i am atomic！！！我是暗影） 的结构体来完成整形数据的原子操作，在使用中用原子变 量来代替整形变量，此结构体定义在 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 函数，如表 47.2.2.1 所示：（真是万物离不开增删改查）

 如果使用 64 位的 SOC 的话，就要用到 64 位的原子变量，Linux 内核也定义了 64 位原子 结构体，如下所示：

typedef struct {
 long long counter;
} atomic64_t;

相应的也提供了 64 位原子变量的操作 API 函数，这里我们就不详细讲解了，和表 47.2.1.1 中的 API 函数有用法一样，只是将“atomic_”前缀换为“atomic64_”，将 int 换为 long long。如 果使用的是 64 位的 SOC，那么就要使用 64 位的原子操作函数。Cortex-A7 是 32 位的架构，所 以本书中只使用表 47.2.2.1 中的 32 位原子操作函数。原子变量和相应的 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 */

2.3：原子位操作 API 函数

位操作也是很常用的操作，Linux 内核也提供了一系列的原子位操作 API 函数，只不过原 子位操作不像原子整形变量那样有个 atomic_t 的数据结构，原子位操作是直接对内存进行操作， API 函数如表 47.2.3.1 所示：

3:自旋锁 

3.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;

您提供的代码是一个使用 `typedef` 创建的 `spinlock` 结构体定义，它是 Linux 内核中用于同步的自旋锁（spinlock）的一种实现。自旋锁是一种用于多处理器系统中的锁机制，当一个 CPU 试图获得一个已被其他 CPU 持有的锁时，它不会睡眠，而是在当前位置“自旋”（即忙等待），直到锁被释放。

下面是对这段代码的逐行解释：

1. `typedef struct spinlock {`：使用 `typedef` 创建一个新的类型名称 `spinlock_t`，基于定义的 `struct spinlock` 结构体。

2. `union {`：定义一个联合体，它允许不同的数据类型共享相同的内存位置。这里用于在 `raw_spinlock` 和调试相关的成员之间共享内存。

3. `struct raw_spinlock rlock;`：`raw_spinlock` 是一个结构体，通常包含一个用于自旋锁的简单整型字段（如 `raw_spinlock_t` 类型，可能是 `volatile unsigned int`）。这是自旋锁的核心实现。

4. `#ifdef CONFIG_DEBUG_LOCK_ALLOC`：这是一个条件编译指令，只有在定义了 `CONFIG_DEBUG_LOCK_ALLOC` 配置选项时，以下代码才会被编译。这个配置用于在锁分配时提供调试支持。

5. `#define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))`：定义一个宏 `LOCK_PADSIZE`，计算 `raw_spinlock` 结构体中 `dep_map` 字段的偏移量。`offsetof` 是一个预处理器宏，用于获取结构体成员的偏移量。

6. 结构体匿名结构体：
    - `u8 __padding[LOCK_PADSIZE];`：定义一个字节数组，用于填充内存，确保 `dep_map` 在与 `rlock` 相同的内存对齐位置。
    - `struct lockdep_map dep_map;`：定义一个 `lockdep_map` 结构体，用于锁的依赖性映射，是锁调试器的一部分。

7. `};`：结束联合体定义。

8. `} spinlock_t;`：结束 `spinlock` 结构体定义，并使用 `spinlock_t` 作为这个结构体的别名。

9. `}`：结束 `typedef` 定义。

这种自旋锁的实现允许在启用调试选项时提供额外的调试信息，而在正常编译时则只包含核心的锁机制，以减少内存占用和提高性能。在多核系统中，自旋锁是确保代码段或数据结构在同一时刻只被一个 CPU 访问的重要机制。

在使用自旋锁之前，肯定要先定义一个自旋锁变量，定义方法如下所示：

spinlock_t lock; //定义自旋锁

定义好自旋锁变量以后就可以使用相应的 API 函数来操作自旋锁。

3.2:自旋锁 API 函数

最基本的自旋锁 API 函数如表 47.3.2.1 所示：

 表47.3.2.1中的自旋锁API函数适用于SMP或支持抢占的单CPU下线程之间的并发访问， 也就是用于线程与线程之间，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的 API 函数，否则的话会可能会导致死锁现象的发生。自旋锁会自动禁止抢占，也就说当线程 A 得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态，那么线程 A 会自 动放弃 CPU 使用权。线程 B 开始运行，线程 B 也想要获取锁，但是此时锁被 A 线程持有，而 且内核抢占还被禁止了！线程 B 无法被调度出去，那么线程 A 就无法运行，锁也就无法释放， 好了，死锁发生了！ 表 47.3.2.1 中的 API 函数用于线程之间的并发访问，如果此时中断也要插一脚，中断也想 访问共享资源，那该怎么办呢？首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里 面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断，对于多核 SOC 来说会有多个 CPU 核)，否则可能导致锁死现象的发生，如图 47.3.2.1 所示：

在图 47.3.2.1 中，线程 A 先运行，并且获取到了 lock 这个锁，当线程 A 运行 functionA 函 数的时候中断发生了，中断抢走了 CPU 使用权。右边的中断服务函数也要获取 lock 这个锁， 但是这个锁被线程 A 占有着，中断就会一直自旋，等待锁有效。但是在中断服务函数执行完之 前，线程 A 是不可能执行的，线程 A 说“你先放手”，中断说“你先放手”，场面就这么僵持着， 死锁发生！ 最好的解决方法就是获取锁之前关闭本地中断，Linux 内核提供了相应的 API 函数，如表 47.3.2.2 所示：

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

下半部(BH)也会竞争共享资源，有些资料也会将下半部叫做底半部。关于下半部后面的 章节会讲解，如果要在下半部里面使用自旋锁，可以使用表 47.3.2.3 中的 API 函数：

 3.3：其他类型的锁

在自旋锁的基础上还衍生出了其他特定场合使用的锁，这些锁在驱动中其实用的不多，更 多的是在 Linux 内核中使用，本节我们简单来了解一下这些衍生出来的锁。

3.3.1:读写自旋锁

现在有个学生信息表，此表存放着学生的年龄、家庭住址、班级等信息，此表可以随时被 修改和读取。此表肯定是数据，那么必须要对其进行保护，如果我们现在使用自旋锁对其进行 保护。每次只能一个读操作或者写操作，但是，实际上此表是可以并发读取的。只需要保证在 修改此表的时候没人读取，或者在其他人读取此表的时候没有人修改此表就行了。也就是此表 的读和写不能同时进行，但是可以多人并发的读取此表。像这样，当某个数据结构符合读/写或 生产者/消费者模型的时候就可以使用读写自旋锁。 读写自旋锁为读和写操作提供了不同的锁，一次只能允许一个写操作，也就是只能一个线 程持有写锁，而且不能进行读操作。但是当没有写操作的时候允许一个或多个线程持有读锁， 可以进行并发的读操作。Linux 内核使用 rwlock_t 结构体表示读写锁，结构体定义如下(删除了 条件编译)：

typedef struct {
 arch_rwlock_t raw_lock;
} rwlock_t;

读写锁操作 API 函数分为两部分，一个是给读使用的，一个是给写使用的，这些 API 函数 如表 47.3.3.1 所示：

 3.3.2:顺序锁

顺序锁在读写锁的基础上衍生而来的，使用读写锁的时候读操作和写操作不能同时进行。 使用顺序锁的话可以允许在写的时候进行读操作，也就是实现同时读写，但是不允许同时进行 并发的写操作。虽然顺序锁的读和写操作可以同时进行，但是如果在读的过程中发生了写操作， 最好重新进行读取，保证数据完整性。顺序锁保护的资源不能是指针，因为如果在写操作的时 候可能会导致指针无效，而这个时候恰巧有读操作访问指针的话就可能导致意外发生，比如读 取野指针导致系统崩溃。Linux 内核使用 seqlock_t 结构体表示顺序锁，结构体定义如下：

typedef struct {
 struct seqcount seqcount;
 spinlock_t lock;
} seqlock_t;

关于顺序锁的 API 函数如表 47.3.3.2 所示：

 3.4:自旋锁使用注意事项

综合前面关于自旋锁的信息，我们需要在使用自旋锁的时候要注意一下几点：

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

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

③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就 必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己 把自己锁死了！ ④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还 是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。

4:信号量（想到了之前学的freertos里的信号量了）

4.1：信号量简介

大家如果有学习过 FreeRTOS 或者 UCOS 的话就应该对信号量很熟悉，因为信号量是同步 的一种方式。Linux 内核也提供了信号量机制，信号量常常用于控制对共享资源的访问。举一个 很常见的例子，某个停车场有 100 个停车位，这 100 个停车位大家都可以用，对于大家来说这 100 个停车位就是共享资源。假设现在这个停车场正常运行，你要把车停到这个这个停车场肯 定要先看一下现在停了多少车了？还有没有停车位？当前停车数量就是一个信号量，具体的停 车数量就是这个信号量值，当这个值到 100 的时候说明停车场满了。停车场满的时你可以等一 会看看有没有其他的车开出停车场，当有车开出停车场的时候停车数量就会减一，也就是说信 号量减一，此时你就可以把车停进去了，你把车停进去以后停车数量就会加一，也就是信号量 加一。这就是一个典型的使用信号量进行共享资源管理的案例，在这个案例中使用的就是计数 型信号量。 相比于自旋锁，信号量可以使线程进入休眠状态，比如 A 与 B、C 合租了一套房子，这个 房子只有一个厕所，一次只能一个人使用。某一天早上 A 去上厕所了，过了一会 B 也想用厕 所，因为 A 在厕所里面，所以 B 只能等到 A 用来了才能进去。B 要么就一直在厕所门口等着， 等 A 出来，这个时候就相当于自旋锁。B 也可以告诉 A，让 A 出来以后通知他一下，然后 B 继 续回房间睡觉，这个时候相当于信号量。（B从就绪态变为阻塞态，如果信号量的值已满（即信号量的值为0），那么尝试获取信号量的进程或线程将从就绪状态变为阻塞状态，直到信号量的值增加，它才能被唤醒并继续执行。这是信号量用来防止多个进程或线程同时访问某个资源的重要机制。）可以看出，使用信号量会提高处理器的使用效率，毕 竟不用一直傻乎乎的在那里“自旋”等待。但是，信号量的开销要比自旋锁大，因为信号量使 线程进入休眠状态以后会切换线程，切换线程就会有开销。总结一下信号量的特点：

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

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

信号量有一个信号量值，相当于一个房子有 10 把钥匙，这 10 把钥匙就相当于信号量值为 10。因此，可以通过信号量来控制访问共享资源的访问数量，如果要想进房间，那就要先获取 一把钥匙，信号量值减 1，直到 10 把钥匙都被拿走，信号量值为 0，这个时候就不允许任何人 进入房间了，因为没钥匙了。如果有人从房间出来，那他要归还他所持有的那把钥匙，信号量 值加 1，此时有 1 把钥匙了，那么可以允许进去一个人。相当于通过信号量控制访问资源的线 程数，在初始化的时候将信号量值设置的大于 1，那么这个信号量就是计数型信号量，计数型 信号量不能用于互斥访问，因为它允许多个线程同时访问共享资源。如果要互斥的访问共享资源那么信号量的值就不能大于 1，此时的信号量就是一个二值信号量。

4.2：信号量 API 函数

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

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

要想使用信号量就得先定义，然后初始化信号量。有关信号量的 API 函数如表 47.4.2.1 所 示：

 信号量的使用如下所示：

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

5：互斥体

5.1：互斥体简介

在 FreeRTOS 和 UCOS 中也有互斥体，将信号量的值设置为 1 就可以使用信号量进行互斥 访问了，虽然可以通过信号量实现互斥，但是 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 不能递归上锁和解锁。（要末有要末无，无了就得再创建，根释放获得有一些不一样）

5.2：互斥体 API 函数

有关互斥体的 API 函数如表 47.5.2.1 所示：

 互斥体的使用如下所示：

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

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

关于 Linux 中的并发和竞争就讲解到这里，Linux 内核还有很多其他的处理并发和竞争的 机制，本章我们主要讲解了常用的原子操作、自旋锁、信号量和互斥体。以后我们在编写 Linux 驱动的时候就会频繁的使用到这几种机制，希望大家能够深入理解这几个常用的机制。

本文绝大部分内容复制与正点原子开发手册，仅作自己学习使用

总结：这一节讲的都是理论知识，关于自旋锁及变体锁，信号量，互斥体。跟我刚学freertos时一样，一时看个眼熟，长时间不用就忘了。所以打算学完驱动就去把前面的freertos项目做了。