llinux设备驱动并发与竞争简介

1.解决并发的方式

1）信号量（struct semaphore）

2）读写信号量（struct rw_semaphore）

3）完成量（struct completion）

4）自旋锁（spinloct_t）

5）读写自旋锁(rwlock_t)

6）顺序锁（seqlock_t）

7）读-拷贝-更新（RCU）

8）原子操作

2.上述方法使用

1）信号量（struct semaphore）

1.定义

struct semaphore sem;

2.初始化

void sema_init (struct semaphore *sem, int val);

 

下面是定义+初始化的宏方式：

DECLARE_MUTEX(name)

DECLARE_MUTEX_LOCKED(name)

3.获取

int down_interruptible(struct semaphore * sem);

void down(struct semaphore * sem);

int down_trylock(struct semaphore * sem);

4.释放

void up(struct semaphore * sem);

 

//定义信号量

DECLARE_MUTEX(mount_sem);

down(&mount_sem);//获取信号量，保护临界区

...

critical section //临界区

...

up(&mount_sem);//释放信号量

 

2）完成量（struct completion）

1.定义

struct completion my_completion;

2.初始化

init_completion(&my_completion);

 

DECLARE_COMPLETION(my_completion);

3.等待完成量

wait_for_completion(&my_completion);

4.唤醒完成量

complete(&my_completion);

completion_all(&my_completion);

3）读写信号量（struct rw_semaphore）

1.定义

Struct rw_semophore my_rws;

2.初始化

Init_rwsem(&my_rws);

3.获取读、写信号量

读：void down_read(struct rw_semaphore *sem);

int down_read_trylock(struct rw_semaphore *sem);

写：void down_write(struct rw_semaphore *sem);

int down_write_trylock(struct rw_semaphore *sem);

4.释放读、写信号量

读：void up_read(struct rw_semaphore *sem);

写：void up_write(struct rw_semaphore *sem);

4）自旋锁（spinloct_t）

1.定义

spinlock_t lock;

2.初始化

Spin_lock_init(&lock);

3.获取

Spin_lock(&lock);

4.释放

Spin_unlock(&lock);

5）读写自旋锁(rwlock_t)

1.定义

Rw_lock_t rw_lock;

2.初始化

Rw_lock_init(&rw_lock);

3.获取读锁、写锁

Read_lock(&rw_lock); 、 write_lock(&rw_lock);

4.释放读锁、写锁

Read_unlock(&rw_lock); 、 write_unlock(&rw_lock);

6）顺序锁（seqlock_t）

1.写单元

write_seqlock(&seqlock_a);

...//写操作代码块

write_sequnlock(&seqlock_a);

2.读单元

Unsigned int seqnum;

do {

seqnum = read_seqbegin(&seqlock_a);

//读操作代码块

...

} while (read_seqretry(&seqlock_a, seqnum));

7）读-拷贝-更新（RCU）

3.个人理解

1）信号量与自旋锁：

信号量可用于保护引发阻塞的代码，自旋锁不可以；

信号量可用于代码量较多，自旋锁用于代码量较少的地方；

若被保护的资源在中断或者软中断下使用，不选择信号量，选择自旋锁；

2）完成量

用于同步机制；

 

 

当信号量初始化时，信号量的值为0也可用于同步（最好使用完成量进行同步操作）；

 

3）读写信号量

1. 同一时刻最多有一个写者（writer）获得锁；

2. 同一时刻可以有多个读者（reader）获得锁；

3. 同一时刻写者和读者不能同时获得锁；

rw_semaphore rw_sem; //定义读写信号量

init_rwsem(&rw_sem); //初始化读写信号量

//读时获取信号量

down_read(&rw_sem);

... //临界资源

up_read(&rw_sem);

//写时获取信号量

down_write(&rw_sem);

... //临界资源

up_write(&rw_sem);

4)顺序锁

保护的资源小，简单，频繁访问且写入访问很少且速度快；

不能用于保护包含有指针的结构体；