互斥锁，自旋锁，原子操作原理和实现

Posted 2023-04-25

参考技术A

注意：互斥锁在上锁的过程中，需要用自旋锁保证原子操作（包括修改原子量和锁的相关数据结构）

自旋锁是采用忙等的状态获取锁，所以会一直占用cpu资源，但是允许不关闭中断的情况下，是可以被其他内核执行路径抢占的（中断嵌套的情况下，注意嵌套的中断不能申请同一个锁，这样会造成死等）。同时因为线程对cpu一直保持占用状态，所以对小资源加锁效率比较高，不需要做任何的线程切换，一般情况下如果加锁资源的运行延迟小于线程或者进程切换的时延则推荐使用自旋锁。如果需要等待耗时操作，则建议放弃cpu，采用信号量或者互斥锁

上图指令可以实现加操作的原子性，但是这种总线锁不能滥用，在没有共享同步问题的时候，这会阻止cpu并行计算的优化，甚至会阻塞cpu对其他内存的访问，导致效率的下降。所以除此之外我们可以使用缓存锁来执行复杂的原子操作。

频繁使用的内存会缓存在处理器的L1、L2和L3高速缓存里，那么原子操作就可以直接在处理器内部缓存中进行，并不需要声明总线锁，在Pentium 6和目前的处理器中可以使用“缓存锁定”的方式来实现复杂的原子性。 所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声言LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效，在如图2-3所示的例子中，当CPU1修改缓存行中的i时使用了缓存锁定，那么CPU2就不能同时缓存i的缓存行。
但是有两种情况下处理器不会使用缓存锁定。

未完待续。。。。

https://www.cnblogs.com/alinh/p/6905221.html
https://blog.csdn.net/mcgrady_tracy/article/details/34829019
https://leetcode.com/discuss/interview-question/operating-system/125169/Mutex-vs-Semaphore
https://blog.csdn.net/zxx901221/article/details/83033998
https://leetcode.com/discuss/interview-question/operating-system/134290/Implement-your-own-spinlock

Linux驱动开发原子操作自旋锁信号量互斥体

Linux系统是多任务操作系统，存在多个任务同时访问同一片内存区域的情况，多个任务可能会相互覆盖掉内存中的数据，造成内存数据混乱。

Linux系统并发主要原因

• 多线程并发访问
• 抢占式并发访问
• 中断程序并发访问
• 多核间并发访问

通常需要对全局变量、设备结构体这些共享资源进行保护，局部变量不需要保护，其他类型数据视情况而定。

原子操作

原子操作是不能再进一步分割的操作，只能用于整型变量或位操作。

Linux内核提供两组原子操作API函数，一组是对整型变量进行操作，另一组是对位进行操作。

整型操作API函数

Linux内核定义atomic_t结构体对整型数据进行原子操作。64位定义atomic64_t结构体，atomic_t其他相关API函数替换为atomic64_t即可。

在驱动入口函数xxx_init中atomic_set初始化，在xxx_open函数中atomic_read判断原子变量的值，并atomic_dec减一，在xxx_release函数中atomic_inc加一。或使用!atomic_dec_and_test判断。

定义atomic_t变量

atomic_t a;

定义atomic_t变量并使用宏ATOMIC_INIT赋初值0

atomic_t a = ATOMIC_INIT(0);

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

位操作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 位原来的值

自旋锁

原子操作只能对整型变量或位进行保护，对于设备结构变量等其他变量无法进行原子操作。

当一个线程访问某个共享资源时，首先要获得相应的锁，锁只能被一个线程持有，线程不释放持有的锁，其他线程就不能获得锁。

自旋锁被线程A持有时，线程B要获得自旋锁，线程B会处于自旋等待状态，不会进入休眠或去进行其他操作。

等待自旋锁的线程会一直处于自旋的状态，会浪费处理器时间，降低系统性能，所以自旋锁持有时间不能太长，适用于短时间轻量级加锁。

自旋锁不能直接判断，需要定义全局变量dev_status（0可用，大于1不可用）标记某个驱动是否被使用。在驱动入口函数xxx_init中spin_lock_init初始化，自旋锁持有时间不能太长，所以不能在open申请和release释放，在xxx_open函数中spin_lock加锁，加锁代码后面为代码保护区判断全局变量dev_status为0可用，然后加1，执行完毕后spin_unlock解锁，在xxx_release函数中spin_lock加锁，加锁代码后面为代码保护区判断全局变量dev_status减1，执行完毕后spin_unlock解锁。推荐使用 spin_lock_irqsave 和 spin_unlock_irqrestore。

Linux内核定义spinlock_t结构体表示自旋锁。

使用自旋锁之前，定义自旋锁变量。

spinlock_t lock;

自旋锁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。

适用支持抢占的单CPU下线程间访问或多核间访问，自旋锁会自动禁止抢占，被自旋锁保护的临界区不能调用引起睡眠和阻塞的函数，否则会发生死锁现象。 

自旋锁中断API函数

中断里面可以使用自旋锁，中断在获得锁之前要先禁止本地中断（本CPU中断），否则会发生死锁现象。

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 ，这两个函数加锁会保存中断状态，释放锁会恢复中断状态。 

自旋锁中断下半部API函数

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

自旋锁注意事项

1. 自旋锁持有时间不能太长，否则会降低系统性能。
2. 自旋锁保护的临界区内不能调用任何可能导致线程休眠或阻塞的API函数，否则会导致死锁。
3. 不能递归申请自旋锁，否则会导致死锁。
4. 考虑驱动的可移植性，按照多核SOC编写驱动程序。

信号量

信号量可以使线程进入休眠状态，提高处理器使用效率，但是信号量的开销大，信号量使线程进入休眠状态后会切换线程，切换线程会有开销。

在驱动入口函数xxx_init中sema_init初始化，在xxx_open函数中down或down_interruptible加锁，在xxx_release函数中up加锁。

Linux内核定义semaphore结构体表示信号量。定义信号量。

struct semaphore sem;

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

信号量注意事项

1. 信号量可以使等待的线程进入休眠状态，适用于占用资源比较久的场合。
2. 信号量会引起休眠，所以不能在中断中使用信号量。
3. 共享资源持有时间短的场合不适合使用信号量，频繁的休眠和切换线程引起的开销要远大于信号量带来的优势。

计数型信号量

通过信号量访问资源的线程数，初始化时将信号量值设置大于1，这个信号量就是计数型信号量。因为计数型信号量允许多个线程同时访问共享资源，所以不能用于互斥访问。

二值信号量

通过信号量访问资源的线程数，初始化时将信号量值设置不能大于1，这个信号量就是二值型信号量。可以互斥访问。

互斥体

互斥访问就是一次只能有一个线程访问共享资源，不能递归申请互斥体。将信号量值设置为1就可以互斥访问，但是Linux提供一个更专业的互斥体机制表示互斥。

在驱动入口函数xxx_init中mutex_init初始化，在xxx_open函数中mutex_lock或加锁，在xxx_release函数中mutex_unlock加锁。

Linux内核定义mutex结构体表示互斥体。定义一个互斥体。

struct mutex lock;

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

互斥体注意事项

1. 互斥体会导致休眠，所以不能在中断中使用互斥体。中断中只能使用自旋锁。
2. 互斥体保护的临界区可以调用引起阻塞的API函数。
3. 互斥体由互斥锁的持有者进行释放。
4. 互斥体不能递归上锁和解锁。

驱动开发大部分都是互斥体