原创 并发和竞争情况总结

/*初始化函数*/
void
sema_init(struct
semaphore *sem,
int
val);

/*方法一、声明+初始化宏*/
DECLARE_MUTEX(name);
DECLARE_MUTEX_LOCKED(name);

/*方法二、初始化函数*/
void
init_MUTEX(struct
semaphore *sem);
void
init_MUTEX_LOCKED(struct
semaphore
*sem);

/*带有“_LOCKED”的是将信号量初始化为0，即锁定，允许任何线程访问时必须先解锁。没带的为1。*/

void
down(struct
semaphore *sem);
/*不推荐使用，会建立不可杀进程*/
int
down_interruptible(struct
semaphore
*sem);/*推荐使用，使用down_interruptible需要格外小心，若操作被中断，该函数会返回非零值，而调用这不会拥有该信号量。对down_interruptible的正确使用需要始终检查返回值，并做出相应的响应。*/
int
down_trylock(struct
semaphore *sem);/*带有“_trylock”的永不休眠，若信号量在调用是不可获得，会返回非零值。*/

void
up(struct
semaphore
*sem);/*任何拿到信号量的线程都必须通过一次（只有一次）对up的调用而释放该信号量。在出错时，要特别小心；若在拥有一个信号量时发生错误，必须在将错误状态返回前释放信号量。*/

/*
Initialize each device. */
    for
(i
=
0;
i <
scull_nr_devs;
i++)
{
        scull_devices[i].quantum
=
scull_quantum;
        scull_devices[i].qset
=
scull_qset;
        init_MUTEX(&scull_devices[i].sem);/* 注意顺序：先初始化好互斥信号量
，再使scull_devices可用。*/
        scull_setup_cdev(&scull_devices[i],
i);
    }

void
init_rwsem(struct
rw_semaphore *sem);

void
down_read(struct
rw_semaphore *sem);
int
down_read_trylock(struct
rw_semaphore *sem);
void
up_read(struct
rw_semaphore *sem);

void
down_write(struct
rw_semaphore *sem);
int
down_write_trylock(struct
rw_semaphore *sem);
void
up_write(struct
rw_semaphore *sem);

void
downgrade_write(struct
rw_semaphore
*sem);/*该函数用于把写者降级为读者，这有时是必要的。因为写者是排他性的，因此在写者保持读写信号量期间，任何读者或写者都将无法访问该读写信号量保护的共享资源，对于那些当前条件下不需要写访问的写者，降级为读者将，使得等待访问的读者能够立刻访问，从而增加了并发性，提高了效率。*/

DECLARE_COMPLETION(my_completion);/*
创建completion（声明+初始化）
*/

/////////////////////////////////////////////////////////

struct
completion my_completion;/*
动态声明completion
结构体*/
static
inline
void
init_completion(&my_completion);/*动态初始化completion*/

///////////////////////////////////////////////////////

void
wait_for_completion(struct
completion *c);/*
等待completion
*/
void
complete(struct
completion *c);/*唤醒一个等待completion的线程*/
void
complete_all(struct
completion
*c);/*唤醒所有等待completion的线程*/

/*如果未使用completion_all，completion可重复使用；否则必须使用以下函数重新初始化completion*/
INIT_COMPLETION(struct
completion c);/*快速重新初始化completion*/

void
complete_and_exit(struct
completion *c,
long
retval);

spinlock_t
my_lock =
SPIN_LOCK_UNLOCKED;/*
编译时初始化spinlock*/
void
spin_lock_init(spinlock_t
*lock);/*
运行时初始化spinlock*/

/*
所有spinlock等待本质上是不可中断的，一旦调用spin_lock，在获得锁之前一直处于自旋状态*/
void
spin_lock(spinlock_t
*lock);/*
获得spinlock*/
void
spin_lock_irqsave(spinlock_t
*lock,
unsigned
long
flags);/*
获得spinlock，禁止本地cpu中断，保存中断标志于flags*/
void
spin_lock_irq(spinlock_t
*lock);/*
获得spinlock,禁止本地cpu中断*/
void
spin_lock_bh(spinlock_t
*lock)/*
获得spinlock,禁止软件中断，保持硬件中断打开*/
/*
以下是对应的锁释放函数*/
void
spin_unlock(spinlock_t
*lock);
void
spin_unlock_irqrestore(spinlock_t
*lock,
unsigned
long
flags);
void
spin_unlock_irq(spinlock_t
*lock);
void
spin_unlock_bh(spinlock_t
*lock);

/*
以下非阻塞自旋锁函数，成功获得，返回非零值；否则返回零*/
int
spin_trylock(spinlock_t
*lock);
int
spin_trylock_bh(spinlock_t
*lock);

/*新内核的<linux/spinlock.h>包含了更多函数*/

rwlock_t
my_rwlock =
RW_LOCK_UNLOCKED;/*
编译时初始化*/

rwlock_t
my_rwlock;
rwlock_init(&my_rwlock);
/*
运行时初始化*/

void
read_lock(rwlock_t
*lock);
void
read_lock_irqsave(rwlock_t
*lock,
unsigned
long
flags);
void
read_lock_irq(rwlock_t
*lock);
void
read_lock_bh(rwlock_t
*lock);

void
read_unlock(rwlock_t
*lock);
void
read_unlock_irqrestore(rwlock_t
*lock,
unsigned
long
flags);
void
read_unlock_irq(rwlock_t
*lock);
void
read_unlock_bh(rwlock_t
*lock);

/*
新内核已经有了read_trylock*/

void
write_lock(rwlock_t
*lock);
void
write_lock_irqsave(rwlock_t
*lock,
unsigned
long
flags);
void
write_lock_irq(rwlock_t
*lock);
void
write_lock_bh(rwlock_t
*lock);
int
write_trylock(rwlock_t
*lock);

void
write_unlock(rwlock_t
*lock);
void
write_unlock_irqrestore(rwlock_t
*lock,
unsigned
long
flags);
void
write_unlock_irq(rwlock_t
*lock);
void
write_unlock_bh(rwlock_t
*lock);

/*新内核的<linux/spinlock.h>包含了更多函数*/

void
atomic_set(atomic_t
*v,
int
i);
/*设置原子变量
v
为整数值
i.*/
atomic_t
v =
ATOMIC_INIT(0);  /*编译时使用宏定义
ATOMIC_INIT
初始化原子值.*/

int
atomic_read(atomic_t
*v);
/*返回
v
的当前值.*/

void
atomic_add(int
i,
atomic_t *v);/*由
v
指向的原子变量加
i.
返回值是
void*/
void
atomic_sub(int
i,
atomic_t *v);
/*从
*v
减去
i.*/

void
atomic_inc(atomic_t
*v);
void
atomic_dec(atomic_t
*v);
/*递增或递减一个原子变量.*/

int
atomic_inc_and_test(atomic_t
*v);
int
atomic_dec_and_test(atomic_t
*v);
int
atomic_sub_and_test(int
i,
atomic_t *v);
/*进行一个特定的操作并且测试结果;
如果,
在操作后,
原子值是
0,
那么返回值是真;
否则,
它是假.
注意没有
atomic_add_and_test.*/

int
atomic_add_negative(int
i,
atomic_t *v);
/*加整数变量
i
到
v.
如果结果是负值返回值是真,
否则为假.*/

int
atomic_add_return(int
i,
atomic_t *v);
int
atomic_sub_return(int
i,
atomic_t *v);
int
atomic_inc_return(atomic_t
*v);
int
atomic_dec_return(atomic_t
*v);
/*像
atomic_add
和其类似函数,
除了它们返回原子变量的新值给调用者.*/

void
set_bit(nr,
void
*addr);
/*设置第
nr
位在
addr
指向的数据项中。*/

void
clear_bit(nr,
void
*addr);
/*清除指定位在
addr
处的无符号长型数据.*/

void
change_bit(nr,
void
*addr);/*翻转nr位.*/

test_bit(nr,
void
*addr);
/*这个函数是唯一一个不需要是原子的位操作;
它简单地返回这个位的当前值.*/

/*以下原子操作如同前面列出的,
除了它们还返回这个位以前的值.*/

int
test_and_set_bit(nr,
void
*addr);
int
test_and_clear_bit(nr,
void
*addr);
int
test_and_change_bit(nr,
void
*addr);

/*两种初始化方法*/
seqlock_t
lock1 =
SEQLOCK_UNLOCKED;

seqlock_t
lock2;
seqlock_init(&lock2);

unsigned
int
seq;
do
{
    seq
=
read_seqbegin(&the_lock);
    /*
Do what you need to do */
}
while
read_seqretry(&the_lock,
seq);

unsigned
int
read_seqbegin_irqsave(seqlock_t
*lock,
unsigned
long
flags);
int
read_seqretry_irqrestore(seqlock_t
*lock,
unsigned
int
seq,
unsigned
long
flags);

void
write_seqlock(seqlock_t
*lock);
void
write_sequnlock(seqlock_t
*lock);

void
write_seqlock_irqsave(seqlock_t
*lock,
unsigned
long
flags);
void
write_seqlock_irq(seqlock_t
*lock);
void
write_seqlock_bh(seqlock_t
*lock);

void
write_sequnlock_irqrestore(seqlock_t
*lock,
unsigned
long
flags);
void
write_sequnlock_irq(seqlock_t
*lock);
void
write_sequnlock_bh(seqlock_t
*lock);