【Linux】Linux驱动开发：并发与竞态（原子操作、自旋锁、信号量、互斥体）

原创 已于 2024-08-31 16:23:04 修改 · 1.8k 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#驱动开发 #同步与互斥 #并发与竞态 #自旋锁 #互斥体
于 2023-05-14 15:29:12 首次发布
本文详细介绍了Linux内核中四种主要的锁机制：原子操作、自旋锁、信号量和互斥体。分别阐述了它们的概念、API用法以及特点，并提供了实例代码，展示了如何在实际的设备驱动开发中使用这些锁来保护资源的并发访问。原子操作保证操作的不可分割性，自旋锁适用于短时间的临界区，信号量允许进程休眠等待，而互斥体则是一种更安全的进程同步机制。

目录

1、原子操作

1.1 原子操作的概念

1.2 原子操作的API

1.2.1 ATOMIC_INIT：定义并初始化原子变量

1.2.2 atomic_dec_and_test：上锁（减去1后和0比较）

1.2.3 atomic_inc_and_test：上锁（加上1后和0比较）

1.2.4 atomic_inc：解锁

1.2.5 atomic_dec：解锁

1.3 实例代码

2、自旋锁

2.1 自旋锁的概念

2.2 自旋锁的API

2.2.1 spinlock_t lock：定义自旋锁

2.2.2 spin_lock_init：初始化自旋锁

2.2.3 spin_lock：上锁

2.2.4 spin_unlock：解锁

2.2.5 spin_lock_irq：在中断中上锁

2.2.6 spin_unlock_irq：解锁

2.2.7 spin_lock_irqsave：嵌套锁

2.2.8 spin_unlock_irqrestore：解锁

2.3 实例代码

3、信号量

3.1 信号量的概念

3.2 信号量的API

3.2.1 struct semaphore：定义信号量

3.2.2 sema_init：初始化信号量

3.2.3 down：上锁

3.2.4 dowm_interruptible：休眠时可以被信号打断

3.2.5 dowm_killable：休眠时可以被kill掉

3.2.6 dowm_trylock：尝试获取锁，获取不到也不会休眠

3.2.7 dowm_timeout：休眠时加上超时检测

3.2.8 up：解锁

3.3 实例代码

4、互斥体

4.1 互斥体的概念

4.2 互斥体的API

4.2.1 struct mutex lock：定义互斥体

4.2.2 mutex_init：初始化互斥体

4.2.3 mutex_lock：上锁

4.2.4 mutex_trylock：尝试获取锁，获取不到也不会休眠

4.2.5 mutex_unlock：解锁

4.3 实例代码

5、额外小知识

5.1 静态初始化与动态初始化

5.2 各对象的静态初始化 

1、原子操作

1.1 原子操作的概念

        在函数操作内部保证只有一个核心在操作这个原子变量，并且对这个变量的修改通过内联汇编完成了，省去中间的环节，可以把整个操作看成一个不可被分割的整体，这就是原子操作。原子操作本质就是一个变量，没有自旋或者休眠的特点。

1.2 原子操作的API

1.2.1 ATOMIC_INIT：定义并初始化原子变量

//配合 atomic_dec_and_test 使用
atomic_t lock = ATOMIC_INIT(1);  //定义并初始化原子变量

//配合 atomic_inc_and_test 使用
atomic_t lock = ATOMIC_INIT(-1);  //定义并初始化原子变量

1.2.2 atomic_dec_and_test：上锁（减去1后和0比较）

//减去1和0比较，如果结果为0表示获取锁成功了（成功返回真），否则获取锁失败了（失败返回假）
atomic_dec_and_test(&lock);

1.2.3 atomic_inc_and_test：上锁（加上1后和0比较）

//加1和0比较，如果结果为0表示获取锁成功了（成功返回真），否则获取锁失败了（失败返回假）
atomic_inc_and_test(&lock);

1.2.4 atomic_inc：解锁

atomic_inc(&lock);

1.2.5 atomic_dec：解锁

atomic_dec(&lock);

1.3 实例代码

#define CNAME "mycdev"
struct cdev* cdev;
int major = 0;
int minor = 0;
const int count = 3;
struct class* cls;
struct device* dev;
char kbuf[128] = { 0 };

//初始化
atomic_t lock = ATOMIC_INIT(1);

int mycdev_open(struct inode* inode, struct file* file)
{
    //上锁
    if (!atomic_dec_and_test(&lock)) {
        atomic_inc(&lock);
        return -EBUSY;
    }

    return 0;
}
ssize_t mycdev_read(struct file* file,
    char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    //校验大小
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    //完成数据传输
    ret = copy_to_user(ubuf, kbuf, size);

    return size;
}
ssize_t mycdev_write(struct file* file,
    const char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    //校验大小
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    //完成数据传输
    ret = copy_from_user(kbuf, ubuf, size);

    return size;
}
int mycdev_close(struct inode* inode, struct file* file)
{
    //解锁
    atomic_inc(&lock);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    int ret, i;
    dev_t devno;
    // 1.分配对象
    cdev = cdev_alloc();

    // 2.对象初始化
    cdev_init(cdev, &fops);

    // 3.申请设备号
    if (major > 0) {
        ret = register_chrdev_region(MKDEV(major, minor), count, CNAME);
    } else if (major == 0) {
        ret = alloc_chrdev_region(&devno, minor, count, CNAME);
        major = MAJOR(devno);
        minor = MINOR(devno);
    }
    // 4.注册
    ret = cdev_add(cdev, MKDEV(major, minor), count);

    // 5.自动创建设备节点
    cls = class_create(THIS_MODULE, CNAME);

    for (i = 0; i < count; i++) {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "mycdev%d", i);
    }

    return 0; 
}
static void __exit mycdev_exit(void)
{
    int i;
    for (i = 0; i < count; i++) {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major, minor), count);
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);

2、自旋锁

2.1 自旋锁的概念

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

         Spinlock 是内核中提供的一种比较常见的锁机制，自旋锁是“原地等待”的方式解决资源冲突的，即，一个线程获取了一个自旋锁后，另外一个线程期望获取该自旋锁，获取不到，只能够原地“打转”（忙等待）。

        自旋锁不会使线程状态发生切换一直处于用户态，即线程一直都是 active 的，不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快。

自旋锁的特点：

1、忙等的过程是需要消耗cpu资源的

2、自旋锁保护的临界要尽可能的短，在临界区中不能够有延时，耗时，甚至休眠的动作。

另外在临界区中也不能够有copy_to_user/copy_form_user的调用

3、自旋锁会产生死锁（在同一个进程中多次获取同一把未解锁的锁）

4、自旋锁可以工作中断上下文

5、自旋锁在上锁前会关闭抢占

2.2 自旋锁的API

2.2.1 spinlock_t lock：定义自旋锁

spinlock_t lock;

2.2.2 spin_lock_init：初始化自旋锁

void spin_lock_init(spinlock_t *lock);

2.2.3 spin_lock：上锁

//会关闭抢占，但是不会关闭中断
void spin_lock(spinlock_t *lock);

2.2.4 spin_unlock：解锁

void spin_unlock(spinlock_t *lock);

2.2.5 spin_lock_irq：在中断中上锁

//既会关闭抢占，也会关闭中断，关闭当前核的中断
 void spin_lock_irq(spinlock_t *lock);

2.2.6 spin_unlock_irq：解锁

void spin_unlock_irq(spinlock_t *lock);

2.2.7 spin_lock_irqsave：嵌套锁

//在使用前保存中断的状态，如果之前中断是关闭的，解锁后中断也是关闭的，
//如果之前中断是打开的，解锁后中断还是打开的
//即如果在中断中，需要嵌套使用自旋锁，就用这个
void spin_lock_irqsave(spinlock_t *lock, unsigned long f) //嵌套的时候使用

2.2.8 spin_unlock_irqrestore：解锁

void spin_unlock_irqrestore(spinlock_t *lock, unsigned long f);

2.3 实例代码

#define CNAME "mycdev"
struct cdev *cdev;
int major = 0;
int minor = 0;
const int count=3;
struct class *cls;
struct device *dev;
char kbuf[128] = {0};
//1.定义自旋锁
spinlock_t lock;
int flags=0;

int mycdev_open(struct inode*inode, struct file*file)
{
    //上锁
    spin_lock(&lock);
    if(flags != 0){        
        //解锁
        spin_unlock(&lock);
        return -EBUSY;
    }
    flags=1;
    //解锁
    spin_unlock(&lock);

    return 0;
}
ssize_t mycdev_read(struct file*file, 
    char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    //校验大小
    if(size>sizeof(kbuf)) size = sizeof(kbuf);
    //完成数据传输
    ret = copy_to_user(ubuf,kbuf,size);
    return size;
}
ssize_t mycdev_write(struct file*file, 
    const char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    //校验大小
    if(size>sizeof(kbuf)) size = sizeof(kbuf);
    //完成数据传输
    ret = copy_from_user(kbuf,ubuf,size);
    return size;
}
int mycdev_close(struct inode*inode, struct file*file)
{
    //上锁
    spin_lock(&lock);
    flags=0;
    //解锁
    spin_unlock(&lock);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    int ret,i;
    dev_t devno;
    //1.分配对象
    cdev = cdev_alloc();

    //2.对象初始化
    cdev_init(cdev,&fops);

    //3.申请设备号
    if(major > 0){
        ret = register_chrdev_region(MKDEV(major,minor),count,CNAME);
    }else if(major == 0){
        ret = alloc_chrdev_region(&devno,minor,count,CNAME);
        major = MAJOR(devno);
        minor = MINOR(devno);
    }
    //4.注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);

    //5.自动创建设备节点
    cls = class_create(THIS_MODULE,CNAME);

    for(i=0;i<count;i++){
        dev = device_create(cls,NULL,MKDEV(major,i),NULL,"mycdev%d",i);
    }

    //2.初始化自旋锁
    spin_lock_init(&lock);

    return 0; 
}
static void __exit mycdev_exit(void)
{
    int i;
    for(i=0;i<count;i++){
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major,minor),count);
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);

3、信号量

3.1 信号量的概念

        信号量是一个计数器，它用来记录对共享的存取状况，信号量是一种同步的机制，只有val初始化为1的时候才有互斥的效果。

信号量的特点：

1、信号量在获取不到资源的时候休眠

2、信号量保护的临界区可以很大，里面可以有延时，耗时，甚至休眠的操作

3、信号量不会产生死锁

4、信号量工作于进程上下文

5、信号量不会关闭抢占

3.2 信号量的API

3.2.1 struct semaphore：定义信号量

struct semaphore lock;

3.2.2 sema_init：初始化信号量

//初始化信号量，只有val初始化为1的时候才有互斥的效果。
//如果val初始化为0，同步机制
void sema_init(struct semaphore *sem, int val);

3.2.3 down：上锁

void down(struct semaphore *sem);

3.2.4 dowm_interruptible：休眠时可以被信号打断

int  down_interruptible(struct semaphore *sem);

3.2.5 dowm_killable：休眠时可以被kill掉

int  down_killable(struct semaphore *sem);

3.2.6 dowm_trylock：尝试获取锁，获取不到也不会休眠

//获取到锁的时候返回0，失败返回1，即使没有资源也不会休眠
int  down_trylock(struct semaphore *sem);

3.2.7 dowm_timeout：休眠时加上超时检测

//如果在超时时间到了还没有获取到信号量，返回-ETIME错误码，否则返回0
int  down_timeout(struct semaphore *sem, long jiffies);

3.2.8 up：解锁

void up(struct semaphore *sem);

3.3 实例代码

#define CNAME "mycdev"
struct cdev *cdev;
int major = 0;
int minor = 0;
const int count=3;
struct class *cls;
struct device *dev;
char kbuf[128] = {0};

struct semaphore lock;

int mycdev_open(struct inode*inode, struct file*file)
{
    //上锁
    if(down_trylock(&lock)){
        return -EBUSY;
    }

    return 0;
}
ssize_t mycdev_read(struct file*file, 
    char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    //校验大小
    if(size>sizeof(kbuf)) size = sizeof(kbuf);
    //完成数据传输
    ret = copy_to_user(ubuf,kbuf,size);
    return size;
}
ssize_t mycdev_write(struct file*file, 
    const char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    //校验大小
    if(size>sizeof(kbuf)) size = sizeof(kbuf);
    //完成数据传输
    ret = copy_from_user(kbuf,ubuf,size);
    return size;
}
int mycdev_close(struct inode*inode, struct file*file)
{
    //解锁
    up(&lock);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    int ret,i;
    dev_t devno;
    //1.分配对象
    cdev = cdev_alloc();

    //2.对象初始化
    cdev_init(cdev,&fops);

    //3.申请设备号
    if(major > 0){
        ret = register_chrdev_region(MKDEV(major,minor),count,CNAME);
    }else if(major == 0){
        ret = alloc_chrdev_region(&devno,minor,count,CNAME);
        major = MAJOR(devno);
        minor = MINOR(devno);
    }
    //4.注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);

    //5.自动创建设备节点
    cls = class_create(THIS_MODULE,CNAME);

    for(i=0;i<count;i++){
        dev = device_create(cls,NULL,MKDEV(major,i),NULL,"mycdev%d",i);
    }
    //初始化信号量
    sema_init(&lock,1);

    return 0;
}
static void __exit mycdev_exit(void)
{
    int i;
    for(i=0;i<count;i++){
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major,minor),count);
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);

4、互斥体

4.1 互斥体的概念

        在一个进程获取到互斥体的时候，另外一个进程也想获取这个互斥体此时，后一个进程处于休眠状态。

互斥体与信号量的区别：

        信号量是在并行处理环境中对多个处理器访问某个公共资源进行保护的机制， mutex 用于互斥操作。mutex 的语义相对于信号量要简单轻便一些，在锁争用激烈的测试场景下， mutex 比信号量执行速度更快，可扩展性更好，另外 mutex 数据结构的定义比信号量小。

互斥体的特点：

1、互斥体在获取不到资源的时候休眠

2、互斥体保护的临界区可以很大，里面可以有延时，耗时，甚至休眠的操作

3、互斥体不会产生死锁

4、互斥体工作于进程上下文

5、互斥体不会关闭抢占

6、互斥体在进入休眠前会稍微等一会，在对临界区比较小的临界资源保护的时候，互斥体的效率比信号量的高

互斥体使用的注意事项：

1、同一时刻只有一个线程可以持有 mutex 。
2、只有锁持有者可以解锁，不能在一个进程中持有 mutex ，在另外一个进程中释放他。
3、不允许递归地加锁和解锁。
4、当进程持有 mutex 时，进程不可以退出。
5、mutex 可以睡眠，所以不允许在中断处理程序或者中断下半部中使用，例如 tasklet 、定时器等。

4.2 互斥体的API

4.2.1 struct mutex lock：定义互斥体

struct mutex lock;

4.2.2 mutex_init：初始化互斥体

mutex_init(&lock);

4.2.3 mutex_lock：上锁

void mutex_lock(struct mutex *lock);

4.2.4 mutex_trylock：尝试获取锁，获取不到也不会休眠

//尝试获取互斥体，成功返回1，失败返回0
int mutex_trylock(struct mutex *lock);

4.2.5 mutex_unlock：解锁

void mutex_unlock(struct mutex *lock);

4.3 实例代码

#define CNAME "mycdev"
struct cdev *cdev;
int major = 0;
int minor = 0;
const int count=3;
struct class *cls;
struct device *dev;
char kbuf[128] = {0};

struct mutex lock;

int mycdev_open(struct inode*inode, struct file*file)
{
    //上锁
    if(!mutex_trylock(&lock)){
        return -EBUSY;
    }

    return 0;
}
ssize_t mycdev_read(struct file*file, 
    char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    //校验大小
    if(size>sizeof(kbuf)) size = sizeof(kbuf);
    //完成数据传输
    ret = copy_to_user(ubuf,kbuf,size);
    return size;
}
ssize_t mycdev_write(struct file*file, 
    const char __user*ubuf, size_t size, loff_t*offs)
{
    int ret;
    //校验大小
    if(size>sizeof(kbuf)) size = sizeof(kbuf);
    //完成数据传输
    ret = copy_from_user(kbuf,ubuf,size);
    return size;
}
int mycdev_close(struct inode*inode, struct file*file)
{
    解锁
    mutex_unlock(&lock);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int __init mycdev_init(void)
{
    int ret,i;
    dev_t devno;
    //1.分配对象
    cdev = cdev_alloc();

    //2.对象初始化
    cdev_init(cdev,&fops);

    //3.申请设备号
    if(major > 0){
        ret = register_chrdev_region(MKDEV(major,minor),count,CNAME);
    }else if(major == 0){
        ret = alloc_chrdev_region(&devno,minor,count,CNAME);
        major = MAJOR(devno);
        minor = MINOR(devno);
    }
    //4.注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);

    //5.自动创建设备节点
    cls = class_create(THIS_MODULE,CNAME);
    for(i=0;i<count;i++){
        dev = device_create(cls,NULL,MKDEV(major,i),NULL,"mycdev%d",i);
    }
    //初始化互斥体
    mutex_init(&lock);

    return 0;
}
static void __exit mycdev_exit(void)
{
    int i;
    for(i=0;i<count;i++){
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major,minor),count);
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);

5、额外小知识

5.1 静态初始化与动态初始化

静态初始化：

        1、静态初始化互斥体时，在编译时就已经完成了初始化，不需要在运行时再进行初始化。

        2、这种方式下，互斥体的生命周期与程序的生命周期相同，无需手动释放。

        3、静态初始化的互斥体通常在全局范围内声明和使用。

动态初始化：

        1、动态初始化互斥体时，需要在运行时显式地初始化互斥体。

        2、在动态初始化的情况下，互斥体的生命周期需要手动管理，包括创建和销毁。

        3、动态初始化的互斥体通常在局部范围内声明和使用，以便于管理其生命周期。

5.2 各对象的静态初始化 

自旋锁;

        DEFINE_SPINLOCK(lock)

互斥体：

        DEFINE_MUTEX(mutexname)

信号量：

        DEFINE_SEMAPHORE(name)

读写信号量：

        DECLARE_RWSEM(name)

Linux 内核同步机制--ATOMIC_INIT ()
MHD0815的博客
05-23 322
对于atomic_t类型，宏通常定义如下：c深色版本这表示它接受一个整数值i作为参数，并将其设置为原子变量的初始值。是一个宏，用于在声明时初始化原子变量。原子变量提供了对整数操作的原子性保证，适用于多线程环境下的计数器和状态标记。结合原子操作函数（如atomic_setatomic_inc等），可以实现高效且无锁的同步控制。在编写内核模块或驱动程序时，合理利用原子变量可以简化并发编程，提高系统稳定性和性能。
【Linux驱动编程】并发与竞态（如何选择合适的保护机制）
只要思想不滑坡，想法总比问题多。
04-19 1716
linux系统作为一个现代高级操作系统，支持多用户、多任务访问，这就存在多个任务同时访问共享资源的情况，进而引发并发和竞态问题。
linux内核部件分析（二）——原子性操作atomic_t
热门推荐
qb_2008的专栏
10-02 2万+
在任何处理器平台下，都会有一些原子性操作，供操作系统使用，我们这里只讲x86下面的。在单处理器情况下，每条指令的执行都是原子性的，但在多处理器情况下，只有那些单独的读操作或写操作才是原子性的。为了弥补这一缺点，x86提供了附加的lock前缀，使带lock前缀的读修改写指令也能原子
Linux内核原子操作（1）基本原理
Aspiresky的专栏
07-23 3437
原子（atomic）本意是“不能被进一步分割的最小粒子”，而原子操作（atomicoperation）意为“不可被中断的一个或一系列操作”，可以保证指令以原子的方式运行，即执行过程不被打断，如果被中断则可能会引起执行结果和预期不符。.........
Linux驱动_原子操作
qq_42174306的博客
03-22 2791
上节回顾：Linux驱动_并发与竞争_anieoo的博客-CSDN博客 之前学习了原子操作指的是由多步操作组成的一个操作。如果该操作不能原子地执行，则要么执行完所有步骤，要么一步也不执行，不可能只执行所有步骤的一个子集。 本节实验我们利用原子变量模拟原子操作，通过此实验可以实现在一个驱动被应用占用的过程中，如果另一个驱动再次访问就会返回错误。 步骤如下： ①在驱动的入口函数中中定义一个原子变量： atomic_set(&gpioled.l...
linux内核同步机制之原子操作
ddffyhg的博客
03-25 808
原子操作 原子的操作指的就是在执行过程中不会被别的代码所中断的操作，也就是最小执行单位。在Linux中原子操作的方法有很多，有整型原子和位原子，他们在任何情况下操作都是原子的，这些原子操作的实现都是依赖CPU来实现的，因此这些函数都与CPU架构密切相关。 整型原子 我们arm架构的原子实现在kernel/arch/arm/include/asm/atomic.h 1. 设置源自变量的值 ...
Linux设备驱动开发详解：第7章 Linux设备驱动中的并发控制
qq_41962968的博客
01-26 1299
(1)、自旋锁：是一种典型的 对临界资源进行互斥访问的手段，其名称来源于它的工作方式。(2)、 local_irq_disable()与local_irq_enable()都只能禁止和使能本CPU内的中断，因此并不能解决SMP多CPU引发的竞态，使用上述接口意味着bug，它适合于自旋锁联合使用；(3)、 local_irq_save(flags)除了进行禁止中断的操作以外，还保存目前CPU的中断位信息， local_irq_restore(flags)与之相反，对于ARM而言，就是保存和恢复CPSR;
linux设备驱动程序学习之并发与竞态
最新发布
阿龙的工作记录
01-08 334
并发指的是多个执行单元（进程、线程、中断等）同时（并行）或交替执行（时间片轮转）的状况。竞态则是并发编程中的一种错误状态，指多个线程或进程对共享资源的访问顺序不确定，导致程序行为依赖于执行时序，可能产生不可预测的结果。并发的根源主要来自三个方面：1.对称多处理器（SMP）：真正的并行，多个CPU核心可能同时执行驱动代码2.内核抢占：高优先级进程可以抢占正在内核态执行的较低优先级进程3.中断：中断处理程序可以异步打断正在执行的进程。
Day10_Linux内核竞态
liujing10232929的博客
10-03 981
描述符的表中，然后调用select/poll/epoll统一监听，如果所有的文件。互斥体在获取不到资源的时候会适当等一会儿，如果等待期间有资源就不会进入休眠态，原子操作在对变量操作的时候只保证有一个核在处理，原子变量的值的修改。如果硬件的数据就绪read能够正确的读取到数据，调用read的时。fd对应的数据就绪休眠被唤醒，然后从就绪的文件描述符表中找出就绪。的文件描述符，然后从就绪的文件描述符中将数据读取到用户空间即可。读取硬件的数据，数据就绪read返回读取到的数据，数据没有就绪。
linux 同步 api,Linux内核API atomic_dec_and_test
weixin_32150221的博客
05-13 1446
函数atomic_dec_and_test()的功能是将原子类型的变量v的值原子地递减1，并判断执行该操作后v的值是否为0。atomic_dec_and_test文件包含atomic_dec_and_test函数定义在内核源码中的位置：linux-3.19.3/arch/x86/include/asm/atomic.h函数定义格式：atomic_dec_and_test输入参数说明v：原子类型变量...
Linux原子操作的分析（经典）
zhangxinrun的专栏
12-26 1845
转载：http://blog.csdn.net/carry1314lele/article/details/4886709 本文针对Linux提供的原子操作函数atomic_dec_and_test做了详细的实例分析，解释了其原子性的本质意义。 并对volatile产生的误解做了解释。 1.   atomic_dec_and_test分析 （1）先来看atomic_dec_a
atomic基本操作
wangkai6666的博客
11-20 1901
/include/linux/types.h typedef struct { int counter; } atomic_t; #define ATOMIC_INIT(i) { (i) } #ifdef CONFIG_64BIT typedef struct { s64 counter; } atomic64_t; #endif #define ATOMIC64_INIT(i) { (i) } /include/linux/atomic/atomic-long.h #ifdef CONFIG
Linux 设备驱动--- 并发 与 竞态 --- atomic_t --- atomic_dec_and_test --- 原子操作
zjy900507的博客
02-21 850
并发： 多个执行单元同时被执行. 竞态： 并发的执行单元对资源 ( 硬件资源和软件上的全局变量等 ) 的访问导致的竞争状态. 并发的处理： 处理并发的常用技术是加锁或者互斥，即保证在任何时间只有一个执行单元可以操作共享资源. 在 Linux 内核中主要通过 semaphore 机制(信号...
设备驱动中的并发控制-原子操作
the_wan的博客
09-01 822
现代操作系统有三大特性；中断处理、多任务处理、多处理器(SMP)。这些特性导致当多个进程、线程或CPU同时访问同一个资源时，可能会发生错误。为了避免这种错误，内核需要提供并发控制机制，对公共资源进行保护。 1. 并发与竞争 并发是指在操作系统中，同一时间段内有几个程序都处在已启动状态，且这几个程序都是在同一处理机上运行，但是任意时间点只有一个程序在处理机上运行。并发容易导致竞争问题。竞争就是两个或两个以上的进程同时访问同一资源，从而引起的错误。 ...
linux内核的原子操作简述
10-18 2036
linux内核原子操作简述
请我为详细讲解C11的新增原子操作
cp3alai的专栏
04-13 2183
另外，需要注意的是，C11 标准中的原子操作只是一种语言层面的支持，底层硬件并不一定支持原子操作。因此，在使用原子操作时，需要确保目标平台支持原子操作，并且需要进行相应的测试和调试，以确保程序在不同平台上的正确性和可移植性。最后，需要注意的是，本回答仅介绍了 C11 新增的原子操作，并不是所有的多线程编程技术和方法。需要注意的是，原子操作只能用于支持原子操作的数据类型，例如。用于交换原子变量的值，并返回原来的值。是要进行比较和交换的原子变量的指针，是要初始化的原子变量的指针，是要交换值的原子变量的指针，
原子性操作atomic_t
被遗忘的前辈
04-13 1万+
内核定义了atomic_t 数据类型，作为对整数计数器的原子操作的基础。 各个CPU平台有各自的原子操作实现方式，基本都是通过汇编实现的。  原子操作 原子操作是Linux中提供的一种实现同步的方法，所谓原子操作是指某一操作在执行过程中是不可以被打断的，它要么全部执行完毕，要么就一点也不执行。也就是说原子操作是绝对不会出现该操作执行了一半，内核又去执行其他操作的情况。 原子操作分为原子位
c++11 std::atomic
Oliver King 的小窝
10-20 615
reference： c++11 std::atomic https://www.jianshu.com/p/b7a2b36f43d9 使用原子的变量，++ 和 -- 的次数相同，最终为0； 没有使用原则的变量，++ 和 -- 的次数不相同，最终不为0； c++新特性之std::atomic https://blog.csdn.net/delongwang520/article/details/79604329 ...
c++ 11 原子操作库 （std::atomic）（二）
qq_40788199的博客
09-20 4689
每个 std::atomic 模板的实例化和全特化定义一个原子类型。若一个线程写入原子对象，同时另一线程从它读取，则行为良好定义（数据竞争的细节见内存模型）。
arm-linux 原子操作
L1153413073的博客
06-29 400
arm-linux 原子操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值