Linux 并发与竞争

最新推荐文章于 2024-08-13 21:00:33 发布

Fearlessness

最新推荐文章于 2024-08-13 21:00:33 发布

阅读量954

点赞数 25

文章标签： linux 数据结构算法

本文链接：https://blog.csdn.net/Fearlessness/article/details/140816824

版权

Linux并发与竞争备忘

Linux 作为一个多任务操作系统，存在多个任务共同操作同一段内存或者设备的情况，多个任务甚至中断都能访问的资源叫做共享资源。驱动开发中要注意对共享资源的保护，就是要处理对共享资源的并发访问。

原子操作

用于变量或位操作，变为不能再进一步分割的操作。

原子整形操作API函数

Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量，此结构体定义在 include/linux/types.h 文件中，定义如下：

typedef struct {
	int counter;
} atomic_t;

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

代码示例

atomic_t v = ATOMIC_INIT(0);		/* 定义并初始化原子变零 v=0 */
atomic_set(&v, 10);					/* 设置 v=10*/
atomic_read(&v);					/* 读取 v 的值，肯定是 10*/
atomic_inc(&v);						/* v 的值加 1，v=11*/

struct gpioled_dev{
    ...
	atomic_t lock;		/* 原子变量*/
};

static int led_open(struct inode *inode, struct file *filp)
{
/* 通过判断原子变量的值来检查 LED 有没有被别的应用使用 */
    if (!atomic_dec_and_test(&gpioled.lock)) {
        atomic_inc(&gpioled.lock);		/* 小于 0 的话就加 1,使其原子变量等于 0 */
        return -EBUSY;    				/* LED 被使用，返回忙 */

    }

    filp->private_data = &gpioled; 		/* 设置私有数据 */
    return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = filp->private_data;

    /* 关闭驱动文件的时候释放原子变量 */
    atomic_inc(&dev->lock);

    return 0;
}

static int __init led_init(void)
{
    int ret = 0;
    const char *str;

    /* 1、初始化原子变量*/
    gpioled.lock = (atomic_t)ATOMIC_INIT(0);

    /* 2、原子变量初始值为 1 */
    atomic_set(&gpioled.lock, 1);

    /* 设置 LED 所使用的 GPIO */
    /* 1、获取设备节点：gpioled */
    gpioled.nd = of_find_node_by_path("/gpioled");
    if(gpioled.nd == NULL) {
        printk("gpioled node not find!\r\n");
        return -EINVAL;
    }
    ....
}
....

原子位操作 API 函数

原子位操作是直接对内存进行操作，API 函数如表 11.2.3.1 所示：

函数	描述
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 对结构体变量使用期间，应该禁止其他的线程来访问此结构体变量，这些工作原子操作都不能胜任，需要本节要讲的锁机制，在 Linux内核中就是自旋锁。

当一个线程要访问某个共享资源的时候首先要先获取相应的锁，锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程 A 持有，线程 B 想要获取自旋锁，那么线程 B 就会处于忙循环-旋转-等待状态，线程 B 不会进入休眠状态或者说去做其他的处理，而是会等待锁可用。

在使用自旋锁之前，肯定要先定义一个自旋锁变量，定义方法如下所示：

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

代码节选示例：

.....省略.........
/* gpioled 设备结构体 */
struct gpioled_dev{
    dev_t devid;				/* 设备号*/
    struct cdev cdev;			/* cdev*/
    struct class *class;		/* 类*/
    struct device *device;		/* 设备*/
    int major;					/* 主设备号*/
    int minor;					/* 次设备号*/
    struct device_node *nd; 	/* 设备节点*/
    int led_gpio;				/* led 所使用的 GPIO 编号*/
    
    
    int dev_stats;				/* 设备使用状态，0，设备未使用;>0,设备已经被使用 */
    spinlock_t lock;			/* 定义自旋锁变量 lock */
};

static struct gpioled_dev gpioled;		/* led 设备 */

static int led_open(struct inode *inode, struct file *filp)
{
    unsigned long flags;59
    filp->private_data = &gpioled; 						/* 设置私有数据 */
    spin_lock_irqsave(&gpioled.lock, flags);			/* 上锁 */
    if (gpioled.dev_stats) {							/* 如果设备被使用了 */
        spin_unlock_irqrestore(&gpioled.lock, flags);	/* 解锁 */
        return -EBUSY;
    }
    gpioled.dev_stats++;							/* 如果设备没有打开，那么就标记已经打开了 */
    spin_unlock_irqrestore(&gpioled.lock, flags);	/* 解锁 */
    
    return 0;
}


static int led_release(struct inode *inode, struct file *filp)
{
    unsigned long flags;
    struct gpioled_dev *dev = filp->private_data;

    /* 关闭驱动文件的时候将 dev_stats 减 1 */
    spin_lock_irqsave(&dev->lock, flags);    /* 上锁 */
    if (dev->dev_stats) {
        dev->dev_stats--;
    }
    spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */
    
    return 0;
}

static int __init led_init(void)
{
    ........
    /* 初始化自旋锁 */
    spin_lock_init(&gpioled.lock);/*驱动入口函数 led_init 中调用 spin_lock_init 函数初始化自旋锁*/
    ........
}

死锁：

被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。（自旋锁会自动禁止抢占，也就说当线程 A 得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态，那么线程 A 会自动放弃 CPU 使用权。线程 B 开始运行，线程 B 也想要获取锁，但是此时锁被 A 线程持有，而且内核抢占还被禁止了！线程 B 无法被调度出去，那么线程 A 就无法运行，锁也就无法释放）

中断使用自旋锁时候，在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断，对于多核 SOC 来说会有多个 CPU 核)，否则可能导致锁死现象的发生（线程 A 先运行，并且获取到了 lock 这个锁，当线程 A 运行functionA 函数的时候中断发生了，中断抢走了 CPU 使用权。右边的中断服务函数也要获取 lock 这个锁，但是这个锁被线程 A 占有着，中断就会一直自旋，等待锁有效。）

解决方法就是获取锁之前关闭本地中断，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)	将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁

代码示例：

DEFINE_SPINLOCK(lock)		/* 定义并初始化一个锁*/
    
/* 线程 A */
void functionA (){			/* 定义并初始化一个锁*/
    unsigned long flags;	/* 中断状态*/
    spin_lock_irqsave(&lock, flags)/* 获取锁*/
    /* 临界区 */
    spin_unlock_irqrestore(&lock, flags)/* 释放锁*/
}

/* 中断服务函数 */
void irq() {
    spin_lock(&lock)			/* 获取锁*/
    /* 临界区 */
    spin_unlock(&lock)			/* 释放锁*/
}

信号量

Linux 内核提供了信号量机制，信号量常常用于控制对共享资源的访问。相比于自旋锁，信号量可以使线程进入休眠状态.

信号量的特点：

因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合。
因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。

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

/* gpioled 设备结构体 */
struct gpioled_dev{
    .......
    struct semaphore sem;		/* 信号量 */
};

static struct gpioled_dev gpioled;

static int led_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &gpioled;			/* 设置私有数据 */
    
    /* 获取信号量 */
    if(down_interruptible(&gpioled.sem)){
        return -ERESTARTSYS;
    }
# if 0
    down(&gpioled.sem);
#endif
    return 0;
}
.............
    
struct int led_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = filp->private_data;
    
    up(&dev->sem);
    return 0;
}    
 
static int __init led_init(void){
    int ret = 0;
    const char *str;
    
    /* 初始化信号量 */
    sema_init(&gpioled.sem, 1);
    ............
}
..........

互斥体

将信号量的值设置为 1 就可以使用信号量进行互斥访问了，虽然可以通过信号量实现互斥，但是 Linux 提供了一个比信号量更专业的机制来进行互斥，它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。在我们编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex。

struct mutex {
    atomic_long_t	owner;
    spinlock_t	wait_lock;
};

使用 mutex 的时候要注意如下几点：

mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
和信号量一样，mutex 保护的临界区可以调用引起阻塞的 API 函数。
因为一次只有一个线程可以持有 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，解锁
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);		/* 解锁*/

..........
/* gpioled 设备结构体 */
struct gpioled_dev{
    dev_t devid;					/* 设备号*/
    struct cdev cdev;				/* cdev*/
    struct class *class;			/* 类*/
    struct device *device;			/* 设备*/
    int major;						/* 主设备号*/
    int minor;						/* 次设备号*/
    struct device_node *nd; 		/* 设备节点*/
    int led_gpio;					/* led 所使用的 GPIO 编号*/
    
    struct mutex lock;				/* 定义互斥体 lock*/
};

static struct gpioled_dev gpioled;		/* led 设备 */

static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &gpioled; 		/* 设置私有数据 */
    
    /* 获取互斥体,可以被信号打断 */
    if (mutex_lock_interruptible(&gpioled.lock)) {
        return -ERESTARTSYS;
    }
#if 0
	mutex_lock(&gpioled.lock);		/* 不能被信号打断 */
#endif

    return 0;
}
......
    
static int led_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = filp->private_data;
    
    /* 释放互斥锁 */
    mutex_unlock(&dev->lock);
    return 0;
}
static int __init led_init(void)
{
    int ret = 0;
    const char *str;

    /* 初始化互斥体 */
    mutex_init(&gpioled.lock);
......
}