linux 驱动并发控制终极总结

1、并发与竞争简介

并发就是多个“用户”同时访问同一个共享资源，比如你们公司有一台打印机，你们公司

的所有人都可以使用。现在小李和小王要同时使用这一台打印机，都要打印一份文件。

Linux 系统是个多任务操作系统，会存在多个任务同时访问同一片内存区域，这些任务可

能会相互覆盖这段内存中的数据，造成内存数据混乱。针对这个问题必须要做处理，严重的话

可能会导致系统崩溃。现在的 Linux 系统并发产生的原因很复杂，总结一下有下面几个主要原

因：

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

②、抢占式并发访问，从 2.6 版本内核开始，Linux 内核支持抢占，也就是说调度程序可以

在任意时刻抢占正在运行的线程，从而运行其他的线程。

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

是很大的。

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

发访问

对于临界区必须保证一次只有一个线程访问，也就是要保证临 界区是 原子访问 的。

我们一般在编写驱动的时候就 要考虑到并发与竞争，而不是驱动都编写完了然后再处理并发与竞争。找到要保护的数据才是重点，而这个也是难点， 因为驱动程序各不相同，那么数据也千变万化，一般像全局变量，设备结构体这些肯定是要保 护的，至于其他的数据就要根据实际的驱动程序而定了。

当我们发现驱动程序中存在并发和竞争的时候一定要处理掉。

自旋锁

自旋锁的“自旋”也就是“原地打转”的意思，“原地打转”的目的是为了等待自旋锁可以

用，可以访问共享资源。把自旋锁比作一个变量 a，变量 a=1 的时候表示共享资源可用，当 a=0

的时候表示共享资源不可用。现在线程 A 要访问共享资源，发现 a=0( 自旋锁被其他线程持有 ) ，

那么线程 A 就会不断的查询 a 的值，直到 a=1 。

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

场景那就需要换其他的方法了。

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 ];

原子哥在线教学 :www.yuanzige.com

论坛 :www.openedv.com

1180

I.MX6U

嵌入式 Linux 驱动开发指南

72

struct lockdep_map dep_map ;

73

};

74 #endif

75

};

76 } spinlock_t ;

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

spinlock_t lock; // 定义自旋锁。

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 函数，否则的话可能

导致死锁。

③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就

必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己

把自己锁死了！

④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还

是多核的 SOC ，都将其当做多核 SOC 来编写驱动程序

Linux 内核也提供了信号量机制，信号量常常用于控制对共享资源的访问。

信号量 API 函数

struct semaphore {

raw_spinlock_t lock ;

unsigned int count ;

struct list_head wait_list ;

};

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 ) ;

/* 初始化信号量 */

down (& sem );

/* 申请信号量

*/

/* 临界区 */

up (& sem );

/* 释放信号量

*/

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 不能递归上锁和解锁。

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)

使用此函数获取信号量失败进入休眠以后可

以被信号打断。

我们主要讲解了常用的原子操作、自旋锁、信号量和互斥体。以后我们在编写 Linux 驱动的时候就会频繁的使用到这几种机制，希望大家能够深入理解这几个常用的机制。