linux 并发与竞争 原子操作、自旋锁、信号量、互斥体
linux 并发与竞争
并发与竞争的简介
- 并发的原因
①、多线程并发访问
②、抢占式并发访问，调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程
③、中断程序并发访问
④、SMP(多核)核间并发访问
并发访问带来的问题就是竞争。对于临界区必须保证一次只有一个线程访问，也就是要保证临界区是原子访问的。
- 保护内容
我们要保护的是多个线程都会访问的共享数据。一般像全局变量，设备结构体这些肯定是要保护的，至于其他的数据就要根据实际的驱动程序而定。
原子操作
原子操作就是指不能再进一步分割的操作，一般原子操作用于变量或者位操作。
原子整型操作 API
Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量，此结构体定义在 include/linux/types.h 文件中。
typedef struct {
int counter;
} atomic_t;
#define ATOMIC_INIT(i) { (i) }
atomic_t a; //定义 a
atomic_t b = ATOMIC_INIT(0); //定义原子变量 b 并赋初值为 0
ATOMIC_INIT(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，如果结果为负就返回真，否则返回假
// 注意Linux相应的也提供了 64 位原子变量的操作 API 函数
// API 函数有用法一样，只是将“atomic_”前缀换为“atomic64_”，将 int 换为 long long
typedef struct {
long long counter;
} atomic64_t;
原子位操作 API
原子位操作不像原子整形变量那样有个 atomic_t 的数据结构，原子位操作是直接对内存进行操作。
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 位原来的值。
原子操作实验
自旋锁
自旋锁 API
当一个线程要访问某个共享资源的时候首先要先获取相应的锁，锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程 A 持有，线程 B 想要获取自锁，那么线程 B 就会处于忙循环-旋转-等待状态，线程 B 不会进入休眠状态或者说去做其他的处理，而是会一直傻傻的在那里“转圈圈”的等待锁可用。
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;
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函数适用于SMP或支持抢占的单CPU下线程之间的并发访问，也就是用于线程与线程之间，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。自旋锁会自动禁止抢占，也就说当线程 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。
DEFINE_SPINLOCK(my_lock);
// 线程A
void functionA()
{
unsigned long flags; /* 中断状态 */
spin_lock_irqsave(&my_lock,flags); /* 获取锁 */
/* 临界区 */
spin_unlock_irqrestore(&my_lock, flags) /* 释放锁 */
}
// 中断服务函数
void arq()
{
spin_lock(&my_lock); /* 获取锁 */
/* 临界区 */
spin_unlock(&my_lock); /* 释放锁 */
}
- 关于下半部的自旋锁 API
void spin_lock_bh(spinlock_t *lock) // 关闭下半部，并获取自旋锁。
void spin_unlock_bh(spinlock_t *lock) // 打开下半部，并释放自旋锁。
其他类型的锁
- 读写自旋锁
读写自旋锁为读和写操作提供了不同的锁，一次只能允许一个写操作，也就是只能一个线程持有写锁，而且不能进行读操作。但是当没有写操作的时候允许一个或多个线程持有读锁，可以进行并发的读操作。
typedef struct {
arch_rwlock_t raw_lock;
#ifdef CONFIG_GENERIC_LOCKBREAK
unsigned int break_lock;
#endif
#ifdef CONFIG_DEBUG_SPINLOCK
unsigned int magic, owner_cpu;
void *owner;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
struct lockdep_map dep_map;
#endif
} rwlock_t;
// 初始化
DEFINE_RWLOCK(rwlock_t lock) // 定义并初始化读写锁
void rwlock_init(rwlock_t *lock) // 初始化读写锁。
// 读锁
void read_lock(rwlock_t *lock) // 获取读锁。
void read_unlock(rwlock_t *lock) // 释放读锁。
void read_lock_irq(rwlock_t *lock) // 禁止本地中断，并且获取读锁。
void read_unlock_irq(rwlock_t *lock) // 打开本地中断，并且释放读锁。
void read_lock_irqsave(rwlock_t *lock, unsigned long flags)
// 保存中断状态，禁止本地中断，并获取读锁。
void read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
// 将中断状态恢复到以前的状态，并且激活本地中断，释放读锁。
void read_lock_bh(rwlock_t *lock) // 关闭下半部，并获取读锁。
void read_unlock_bh(rwlock_t *lock) // 打开下半部，并释放读锁。
// 写锁
void write_lock(rwlock_t *lock) // 获取写锁。
void write_unlock(rwlock_t *lock) // 释放写锁。
void write_lock_irq(rwlock_t *lock) // 禁止本地中断，并且获取写锁。
void write_unlock_irq(rwlock_t *lock) // 打开本地中断，并且释放写锁。
void write_lock_irqsave(rwlock_t *lock, unsigned long flags)
// 保存中断状态，禁止本地中断，并获取写锁。
void write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
// 将中断状态恢复到以前的状态，并且激活本地中断，释放读锁。
void write_lock_bh(rwlock_t *lock) // 关闭下半部，并获取读锁。
void write_unlock_bh(rwlock_t *lock) // 打开下半部，并释放读锁。
- 顺序锁
使用顺序锁可以允许在写的时候进行读操作，也就是实现同时读写，但是不允许同时进行并发的写操作。虽然顺序锁的读和写操作可以同时进行，但是如果在读的过程中发生了写操作，最好重新进行读取，保证数据完整性。顺序锁保护的资源不能是指针，因为如果在写操作的时候可能会导致指针无效，而这个时候恰巧有读操作访问指针的话就可能导致意外发生，比如读取野指针导致系统崩溃。
typedef struct {
struct seqcount seqcount;
spinlock_t lock;
} seqlock_t;
// 初始化
DEFINE_SEQLOCK(seqlock_t sl) // 定义并初始化顺序锁
void seqlock_ini seqlock_t *sl) // 初始化顺序锁。
// 顺序锁写操作
void write_seqlock(seqlock_t *sl) // 获取写顺序锁。
void write_sequnlock(seqlock_t *sl) // 释放写顺序锁。
void write_seqlock_irq(seqlock_t *sl) // 禁止本地中断，并且获取写顺序锁
void write_sequnlock_irq(seqlock_t *sl) // 打开本地中断，并且释放写顺序锁。
void write_seqlock_irqsave(seqlock_t *sl, unsigned long flags)
// 保存中断状态，禁止本地中断，并获取写顺序锁。
void write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)
// 将中断状态恢复到以前的状态，并且激活本地中断，释放写顺序锁。
void write_seqlock_bh(seqlock_t *sl) // 关闭下半部，并获取写读锁。
void write_sequnlock_bh(seqlock_t *sl) // 打开下半部，并释放写读锁。
// 顺序锁读操作
unsigned read_seqbegin(const seqlock_t *sl)
// 读单元访问共享资源的时候调用此函数，此函数会返回顺序锁的顺序号。
unsigned read_seqretry(const seqlock_t *sl, unsigned start)
// 读结束以后调用此函数检查在读的过程中有没有对资源进行写操作，如果有的话就要重读
自旋锁注意事项
①、因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长的话要选择其他的并发处理方式，比如信号量和互斥体。
②、自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API 函数，否则的话可能导致死锁。
③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么自己把自己锁死了！
④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。
信号量
信号量常常用于控制对共享资源的访问。相比于自旋锁，信号量可以使线程进入休眠状态。使用信号量会提高处理器的使用效率，不用在那里“自旋”等待。但信号量的开销要比自旋锁大，因为信号量使线程进入休眠状态以后会切换线程，切换线程就会有开销。
- 信号量的特点
1、信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合
2、信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠
3、如果共享资源的持有时间比较短，那就不适合使用信号量了，
因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势
信号量有一个信号量值，可以通过信号量来控制访问共享资源的访问数量，通过信号量控制访问资源的线
程数，在初始化的时候将信号量值设置的大于 1，那么这个信号量就是计数型信号量，计数型
信号量不能用于互斥访问，因为它允许多个线程同时访问共享资源。如果要互斥的访问共享资源
那么信号量的值就不能大于 1，此时的信号量就是一个二值信号量。
信号量 API
Linux 内核使用 semaphore 结构体表示信号量。
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); /* 释放信号量 */
互斥体
将信号量的值设置为 1 就可以使用信号量进行互斥访问了，虽然可以通过信号量实现互斥，但是 Linux 提供了一个比信号量更专业的机制来进行互斥，就是互斥体mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex。
struct mutex {
/* 1: unlocked, 0: locked, negative: locked, possible waiters */
atomic_t count;
spinlock_t wait_lock;
struct list_head wait_list;
#if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_MUTEX_SPIN_ON_OWNER)
struct task_struct *owner;
#endif
#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
struct optimistic_spin_queue osq; /* Spinner MCS lock */
#endif
#ifdef CONFIG_DEBUG_MUTEXES
void *magic;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
struct lockdep_map dep_map;
#endif
};
注意事项
1、mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
2、和信号量一样，mutex 保护的临界区可以调用引起阻塞的 API 函数
3、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。
并且 mutex 不能递归上锁和解锁
互斥体 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); /* 解锁 */