栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

内核原子操作、互斥锁、信号量

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

内核原子操作、互斥锁、信号量

原子操作

原子操作是指不被打断的操作,即它是最小的执行单位。
最简单的原子操作就是一条条的汇编指令不包括一些伪指令,伪指令会被汇编器解释成多条汇编指令 。
防止打开进程切换。

定义

在linux 中原子操作对应的数据结构为atomic_t ,定义如下

typedef struct {
	int counter;
} atomic_t;

赋值操作
•#define atomic_set(v,i) (((v)–>counter) = (i))
读操作
•#define atomic_read(v) (*(volatile int *)&(v)–>counter)
加操作
•static inline void atomic_add (int i , atomic_t *v)

常用操作

#define atomic_inc_and_test
  (atomic_inc_return (v) == 0
先将原子变量的值加 1 并判断是不是 0 ,中间操作不会被打断
加完的值为 0 返回为真

#define atomic_dec_and_test
  (atomic_dec_return (v) == 0
将原子变量的值减 1 并判断是不是 0 ,中间操作不会被打断
减完的值为 0 返回为真

举个栗子
static int hello_open (struct inode *inode, struct file *filep)
{

	if(!atomic_dec_and_test(&v))   
	{//如果减1之后不为0,说明繁忙,为假,所以取反
		atomic_inc(&v);
		//加1是因为你判断为繁忙,所以没有调用它,加个1让它恢复原样。
		return -EBUSY; 
	}
	return 0;
}

static int hello_release (struct inode *inode, struct file *filep)
{
	//关闭的前提是它已经被打开了,所以被减了1,释放的时候需要加1。
	atomic_inc(&v);
	printk("hello_release()n");	
	return 0;
}

互斥锁 互斥概念

信号量是在并行处理环境中对多个处理器访问某个公共资源进行保护的机制, mutex 用于互斥操作。

mutex 的语义相对于信号量要简单轻便一些,在锁争用激烈的测试场景下, mutex 比信号量执行速度更快,可扩展性更好,另外 mutex 数据结构的定义比信号量小。

进入临界区,访问全局变量列表等时,必须先申请锁才有资格访问修改;如果申请不到程序进入休眠。
互斥锁是用来保护两个锁之间的:在解锁之前的(全局)变量不会被修改和访问的。


定义
//静态定义
DEFINE_MUTXE(name);
//动态定义
mutex_init(&mutex);

mutex_lock (struct mutex*)
为指定的 mutex 上锁,如果不可用则睡眠

mutex_unlock (struct mutex*)
为指定的 mutex 解锁

mutex_trylock (struct mutex*)
尝试获取指定的 mutex ,如果成功则返回 1 ;否则锁被获取,返回值是 0;不会导致休眠

mutex_is_lock (struct mutex*)
如果锁已被征用,则返回 1 ;否则返回 0;看一下锁有没有被占用。

举个栗子
struct mutex mutex;
mutex_init(&mutex); 
//加锁
mutex_lock(&mutex);

//临界区

//解锁
mutex_unlock(&mutex);

临界区:全局变量这类。

static int hello_init(void)
{
	int result;	
	printk("hello_init n");
	result = register_chrdev( major, "hello", &hello_ops);
	mutex_init(&mutex); 
	....

static int hello_open (struct inode *inode, struct file *filep)
{
	printk("hello_open()n");
	mutex_lock(&mutex); 
	if(flage != 1)
	{
		mutex_unlock(&mutex); 
		return -EBUSY;
	}
	flage = 0;
	mutex_unlock(&mutex); 
	return 0;
}

锁的初始化在init内完成;由open等调用。使用互斥锁去保护临界区。



信号量

它是用来协调不同进程间的数据对象的,而最主要的应用是共享内存方式的进程间通信 。
本质上信号量是一个计数器,它用来记录对某个资源,如共享内存的存取状况 。


PV操作

P:
如果有一个任务想要获得已经被占用的信号量时,信号量会将其放入一个等待队列然后让其睡眠。

但有时希望任务在等待休眠期间不被打断,一直等待;但又有时候希望可以被打断。
down_interruptible()
这个函数的功能就是获得信号量,如果得不到信号量就睡眠,此时没有信号打断,那么进入睡眠。
down_killable()
用来获取信号量,将信号量sem的计数器值减1,但它是可被致命信号杀死的,这一点与down()函数不同,down()不能被任何信号打断,也与down_interruptible()函数不同,down_interruptible()可被一般信号中断。当有另外的内核控制路径给这个因为竞争不到信号量而睡眠的进程发送了一个致命信号时(一般信号将不会响应),它收到信号后就会立即返回,而放弃继续获得信号量。
down_trylock()
即调用该函数的进程在不能获取信号量的情况下会立即返回,不会睡眠。

注意:
比如在使用down(),以阻塞形式且不接受外部信号时;如果输入外部信号会被存起来,当成功获取信号量时,优先执行外部信号再执行下面命令。
外部信号输入:Ctrl+c、Ctrl+z


V:
当持有信号量的进程将信号释放后,处于等待队列中的一个任务将被唤醒(因为队列中可能不止一个任务),并让其获得信号量 。

信号量往往对应可使用资源的个数。

举个栗子
#include 
struct semaphore sem ;
//当然,初始化也可以为2,3,4等等
sema_init(&sem,1);


int hello_open (struct inode inode,struct file * filp )
{
	if(down_interruptible(&sem))
		return -ERESTARTSYS;
	return 0 ;
}

int hello_release (struct inode inode,struct file * filp)
{
	up(&sem)
	return 0 ;
}

当程序正常执行到down_(信息量)系列时,会根据down_的类型决定接下来干什么。比如down_interruptible会堵塞这种。
当别的程序来申请信号量,如果剩余量不足1,就会进入等待队列(可能是挂起、堵塞等待),等有信号量被释放就会依次替补;当然在替补之前会执行一些在堵塞时被输入的信号。


自旋锁 概念

锁一般都是用来保护一个临界资源(大抵是全局静态变量这种)的,防止一个在访问时,另外一个程序也来访问
一般使用于运行和等待时间较短的

内核当发生访问资源冲突的时候,可以有两种锁的解决方案选择:一个是原地等待 一个是挂起当前进程,调度
其他进程执行(睡眠)。

Spinlock 是内核中提供的一种比较常见的锁机制,自旋锁是“原地等待”的方式解决资源冲突的,即:
一个线程获取了一个自旋锁后,另外一个线程期望获取该自旋锁,获取不到,只能够原地“打转”(仍然占用CPU,并不是休眠:忙等待)。
所以自旋锁不会导致线程状态的切换,一直处于用户态 即线程一直都是 active 的。不会使线程进入阻塞状态,减少了不必要的上下文切换,执行速度快。
(上下文切换:当程序休眠时,CPU会切换到其他程序处,然后再切换回来)

注意事项

进程拥有自旋锁的时候,该 cpu 上是禁止抢占的;只要进入自旋,就一直占据CPU;

一般用于多 cpu 之间的资源竞争;

由于自旋锁的这个忙等待的特性,注定了它使用场景上的限制,自旋锁不应该被长时间的持有(消耗 CPU资源),一般应用在中断上下文。

定义和使用
动态的:
spinlock_t lock;
spin_lock_init (&lock);
静态的:
DEFINE_SPINLOCK(lock);

加锁
spin_lock(&lock);
解锁
spin_unlock(&lock);

1、我们要访问临界资源需要首先申请自旋锁;
2、获取不到锁就自旋,如果能获得锁就进入临界区;
3、当自旋锁释放后,自旋在这个锁的任务即可获得锁并进入临界区,退出临界区的任务必须释放自旋锁。

static spinlock_t lock;
static int flag = 1;


static int hello_open (struct inode *inode, struct file *filep)
{
	printk("hello_open()n");
	spin_lock(&lock);
	if(flage != 1)
	{
		spin_unlock(&lock);
		return -EBUSY;
	}
	flag = 0;
	spin_unlock(&lock);	
	return 0;
}

static int hello_release (struct inode *inode, struct file *filep)
{
	printk("hello_release()n");
	flage = 1;
	return 0;.
}

自旋锁保护的是flag,当flag为1的时候可以继续进行;
注意:当上锁之后因为任何情况而退出时,都要释放锁

死锁

1、拥有自旋锁的进程 A 在内核态阻塞了,内核调度 B 进程,碰巧 B 进程也要获得自旋锁,此时 B 只能自旋转 。 而此时抢占已经关闭(单核)不会 调度 A 进程了 B 永远自旋,产生死锁 。

2、进程 A 拥有自旋锁,中断到来,CPU 执行中断函数中断处理函数 中断处理函数需要获得自旋锁 访问共享资源,此时无法获得锁 只能自旋 产生死锁 。

主要原因:进入sleep暂时不会占用CPU,结果CPU被趁虚而入,被自旋锁占用;无法再运行别的命令。

自旋锁最核心的问题就是申请不到锁,就会一直占据一个CPU;如果这个锁一直不被释放那么就会导致死锁;不被释放可能是由于带锁的程序被自旋锁抢占了CPU,或者自己出不来了等等。


如何选择锁


1、在中断中只能使用自旋锁是为了快,尽可能少的占用CPU时间;
2、任务睡眠使用互斥体;

互斥体和信号量

互斥体和信号量很相似,内核中两者共存会令人混淆。所幸,它们的标准使用方式都有简单规范:除非 mutex 的某个约束妨碍你使用,否则相比信号量要优先使用 mutex 。

当你写新代码时,只有碰到特殊场合(一般是很底层代码)才会需要使用信号量。因此建议选 mutex 。如果发现不能满足其约束条件,且没有其他别的选择时,再考虑选择信号量。

问题是互斥体只限于一个访问,信号量可以多个坑位。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/985343.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号