一、并发与竞争 并发是指多个 多个执行单元同时执行,而这对对共享的资源,比如硬件的资源、软件的全局变量、静态变量 的访问,很容易导致竞态,
1.1、中断屏蔽 在单核的 CPU 里,避免竞态的一个简单有效的方法是,在进入临界区之前,就屏蔽系统的中断。也就是说,在进入临界区之前,中断被关闭,使得中断与进程之间的并发不会发生,而且,因为进程的调度器是依赖于中断来实现的,没有了中断,进程就不能被切换,保证了进程之间的并发不会发生。
方法:
local_irq_disable()
XXXXX 临界区的代码
local_irq_enable()
虽然 local_irq_disable() 和 local_irq_enable() 可以关闭本 CPU 的中断,但是在 多核的 CPU里面,并不能解决问题,因为 它们只能禁止和使能本 CPU 的中断,并不能解决多 CPU 引发的竞争,所以在多个的里面,一般是将关闭中断的方法与 自旋锁 结合使用。
如果指向禁止中断的底部,在应该使用 locak_bh_disable() ,使能的是, local_bh_enable();
1.2、原子操作 原子操作,可以保证对一个整型数据的修改的排他性,也就是说,原子操作是对一个数据进行操作,操作的过程,是不会被线程的调度机制给打断,也就是说,一旦开始,是绝对不会睡眠和阻塞的,直到操作结束。对于整形数的操作,分别是对整型数和位进行原子的操作。
1.2.1、整型原子的操作
(1)设置原子变量的值
void atomic_set(atomic_t *v,int i); // 设置原子变量的值为 i
atomic_t v = ATOMIC_INIT(0) ; // 定义原子变量 V,并初始化为 0
(2)获取原子变量的值
atomic_read(atomic_t *v) // 返回值就是原子变量的值
(3)原子的操作
void atomic_add(int i, atomic_t *v) // i + v
void atomic_sub(int i,atomic_t *v ) // v – i
(4)操作并测试
int atomic_inc_an_test(atomic_t *v) // 自加1,测试是否为0,使得话返回 true
int atomic_dec_and_test(atomic_t *v) // 自减 1,测试是否为 0,使得话,返回 true
(5)操作与返回
int atomic_add_reture(int i, atomic_t *v); // V + i,返回新的值
int atomic _sub_return(int i, atomic_t *v) // v – i ,返回新的值
int atomic_inc_return(atomic_t *v) // V + 1
int atomic_dec_return(atomic_t *v) // V – 1
1.2.2、位原子的操作 (1)设置为
void set_bit(nr,void * addr) // 设置地址 addr 的 第 nr 位 为 1
(2)清除位
void clear_bit(nr, void *addr) // 设置地址 addr 的 第 nr 位 为 0
(3)改变位
void change_bit(nr, void *addr) // 设置地址 addr 的 第 nr 位 反转
(4)检测位
test_bit(nr, void *addr); // 返回 addr 第 nr 位的 值
(5)测试与操作为
int test_and_set_bit(nr, void *addr);
先进行测试,之后在进行位的设置。
1.2.3、原子操作的特性 原子操作的特性,就对原子数的操作的时候,绝对不会被线程的调度器进行打断,也就说,这个时间段,是没进程的上下文之间的切换,进一步说,就是绝对不会出现睡眠和阻塞。
1.3、自旋锁 自旋锁 spin lock,是另外一种对临界资源进行互斥访问的手段,它的实现也是借助了 原子操作实现的。自旋锁的机制是,进程对资源的访问之前,需要对特性的内存进行读取,当读取到值,也就是获得到锁的时候,就有权限进入下一步的操作;而其他的进程没有获得到锁的时候,就就如原地的等待,然后再次进行读取,这个等待、读取的过程,我们称之为自旋。
1.3.1、自旋的 API (1)锁的定义
spinlock_t lock;
(2)锁的初始化
spin_lock_init(lock) // 完成初始化
(3)获得锁
spin_lock(lock)
尝试去获得锁,如果获得,就马上返回,没有获得的话,就进入自旋的状态,Linux 也提供非阻塞的方式:
spin_trylock(lock)
获得锁的时候,返回 true,没有获得的时候,就返回 false
(4)释放锁
spin_unlock(lock)
1.3.2、一般执行方式 spinlock_t lock;
spin_init_lock(lock);
spin_lock(lock);
XXXX 临界区代码
spin_unlock(lock);
1.3.3、自旋锁与中断 在单 CPU 和内核可被抢占的系统中,自旋锁在获得锁的期间,内核的抢占就是被禁止的,因此,这个时候,是可以完全保证获得锁器件的临界区操作代码,不收到其他进程的打扰;但是在 多核的 CPU 中,其中的一个 CPU 获得了自旋锁,但是,只是在该 CPU 上的抢占调度被禁止了,其他核心的CPU 是并没有被禁止抢占调度的,所以为了保证在多核的情况,临界区不受到本 CPU 和其他的 CPU 抢占进程的打扰。
因为自旋锁的底层是借助原子操作实现的,保证了获得锁的器件的操作是不会被被本 CPU 和其他 CPU 的进程调度所影响,而且,自旋锁关闭了抢占系统,但是这些特性并不能保证在得到锁的的时候,执行临界区代码的时候,不受到中断和底部(BH)的影响,也就是这个时候,本 CPU 的中断发生的时候,还是会反过来影响临界区的代码,所以一般是假如关闭中断的操作,这个时候就借助了锁的衍生机制
spin_lock_irq = spin_lock() + local_irq_disable() // 获得锁的同时,关闭中断
spin_inlock_irq = spin_unlock() + local_irq_enable // 释放锁的同时,打开中断
spin_lock_irqsave = spin_lock() + locak_irq_save() // 获得锁的同时,关闭中断,且保存中断的状态
spin_lock_irqrestore() = spin_unlock() + locak_irq_restore() // 释放锁的同时,将中断状态进行回复
spin_lock_bh() = spin_lock() + local_bh_disable() ; // 获得锁的同时,关闭底部中断
spin_unlock_bh() = spin_unlock() + local_bh_enable // 释放锁,且恢复底部中断
当在自旋锁内部加了中断的时候,CPU0 获得了自旋锁,进入了原子的操而CPU 1 在 CPU0 还没有释放锁的时候,CPU1 就只等原地等待(浪费
了 CPU);而且,中断的话,就避免受到 本 CPU 的影响,保证了内核并发的可能。
1.3.4、自旋锁注意事项
(1)因为在获得了自旋锁之后,CPU 就开始了原子的操作,其他的CPU 就会原地一直自旋,等待的过程,并不是睡眠,所以浪费了 N 多的资源,所以,一般上,进程拥有锁的时间都是非常的短的,这样才是比较的划算;如果临界区的代码非常大的话,其他的 CPU 就一直原地等待,浪费了资源,导致了系统性能的降低。
(2)进程在拥有一个锁的期间,不能再尝试去获取本锁,否则导致死锁。
(3)在获得自旋锁的器件,绝对不能出现进程调度的情况,也就是,绝对不能出现进程的睡眠和进程的阻塞,不能出现 copy_tousr或者copy_from_usr,kmalloc、msleep等函数,因为自旋锁实现就是通过原子操作实现的,原子操作的特性,就是一旦开始执行,绝对不会出现进程的调度,否则会导致内核的崩溃。
1.4、信号量 信号量,是非常常用的一种同步互斥的手段,类似于灯,当等的个数不为零的时候,进程获取资源的时候,就将灯拿走一个;当释放资源的时候,就将灯放回去;当灯为零的时候,这个时候,进程将被挂起,进入睡眠的状态,直到被唤醒。
1.4.1、API
(1)定义信号量
struct semaphore sem;
(2)初始化信号量
void sema_init(struct semaphore * sem, int val)
初始化信号量的值为 val
(3)获得信号量
int down(struct semaphore * sem)
获得信号量,和获得锁差不多,当没有得到信号量的时候,就进入睡眠的状态,也就是说,不能在中断里面被使用,因为中断全部被关闭了,进程的调度器是依赖中断实现的,没有了中断,当睡眠的进程,拥有没有进程调度器去唤醒进程,导致程序用死停在那里。内核也提供了可以被打断的接口
int down_interruptible(struct semaphore *sem)
回去尝试去获取信号量,没有获得的时候,进入睡眠,但是可以被打断,,
int dowun_trylock(struct semaphore *sem)
即使在没有活动信号量的情况下,也不会导致睡眠,而是立即返回,所以可以在中断的上下文进行使用
(4)释放信号量
void up(struct semaphore *sem)
当信号量初始化为 1 的时候,实现的就是互斥锁的功能
1.5、互斥锁 互斥锁的使用方法,和信号量的几乎一模一样 ,只是接口名字不一样而已。
(1)定义互斥锁
struct mutex mymutex;
(2)初始化互斥锁
mutex_init( struct mutex *mymutex)
(3)获得互斥锁
void mutex_lock( struct mutex mymutex;)
当然也有,void mutex_lock_interruptible( struct mutex mymutex;) 和 void mutex_trylock( struct mutex mymutex;)
(4)释放互斥锁
void mutex_unlock(struct mutex mymutex)
1.5.1、自旋锁和互斥锁的选择 (1) 自旋锁在没有获得锁的时候,就只能是原地的等地,因此开销就是其他进程获得锁执行的时间;而互斥锁的话,在没有获得锁,就会睡眠当前的进程,锁带来的开销,是进程切换带来的开销。
(2)互斥锁的过程,会带来进程的睡眠 ,因此,互斥锁是绝对不能出现在中断的上下文;自旋锁则不然,非常适合与中断一起配合使用;自旋锁保护的临界区,绝对不能出现进程的阻塞以及睡眠。