第5章：并发与竞态条件: Quick Reference-优快云博客

并发管理核心接口与函数表

头文件	类型 / 宏 / 函数	描述
`<asm/semaphore.h>`	`DECLARE_MUTEX(name)`	声明并初始化一个互斥模式的信号量（初始为解锁状态）
	`DECLARE_MUTEX_LOCKED(name)`	声明并初始化一个互斥模式的信号量（初始为锁定状态）
	`init_MUTEX(struct semaphore *sem)`	运行时初始化信号量为解锁状态
	`init_MUTEX_LOCKED(struct semaphore *sem)`	运行时初始化信号量为锁定状态
	`down(struct semaphore *sem)`	获取信号量，若不可用则进入不可中断睡眠
	`down_interruptible(struct semaphore *sem)`	获取信号量，若不可用则进入可中断睡眠（可被信号唤醒）
	`down_trylock(struct semaphore *sem)`	尝试获取信号量，若不可用则立即返回（不睡眠）
	`up(struct semaphore *sem)`	释放信号量
	`struct rw_semaphore`	读写信号量结构（允许多读单写）
	`init_rwsem(struct rw_semaphore *sem)`	初始化读写信号量
	`down_read(struct rw_semaphore *sem)`	获取读权限
	`down_read_trylock(struct rw_semaphore *sem)`	尝试获取读权限（不睡眠）
	`up_read(struct rw_semaphore *sem)`	释放读权限
	`down_write(struct rw_semaphore *sem)`	获取写权限
	`down_write_trylock(struct rw_semaphore *sem)`	尝试获取写权限（不睡眠）
	`up_write(struct rw_semaphore *sem)`	释放写权限
	`downgrade_write(struct rw_semaphore *sem)`	将写权限降级为读权限
`<linux/completion.h>`	`DECLARE_COMPLETION(name)`	声明并初始化一个完成量
	`init_completion(struct completion *c)`	运行时初始化完成量
	`INIT_COMPLETION(struct completion c)`	重新初始化已使用过的完成量
	`wait_for_completion(struct completion *c)`	等待完成量被唤醒
	`complete(struct completion *c)`	唤醒至少一个等待该完成量的线程
	`complete_all(struct completion *c)`	唤醒所有等待该完成量的线程
	`complete_and_exit(struct completion *c, long retval)`	唤醒完成量并退出当前线程
`<linux/spinlock.h>`	`spinlock_t lock = SPIN_LOCK_UNLOCKED`	声明并初始化自旋锁（解锁状态）
	`spin_lock_init(spinlock_t *lock)`	初始化自旋锁
	`spin_lock(spinlock_t *lock)`	获取自旋锁（不禁止中断）
	`spin_lock_irqsave(spinlock_t *lock, unsigned long flags)`	获取自旋锁并保存中断状态
	`spin_lock_irq(spinlock_t *lock)`	获取自旋锁并禁止本地中断
	`spin_lock_bh(spinlock_t *lock)`	获取自旋锁并禁止软中断
	`spin_trylock(spinlock_t *lock)`	尝试获取自旋锁（不睡眠，失败返回 0）
	`spin_trylock_bh(spinlock_t *lock)`	尝试获取自旋锁并禁止软中断（失败返回 0）
	`spin_unlock(spinlock_t *lock)`	释放自旋锁
	`spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)`	释放自旋锁并恢复中断状态
	`spin_unlock_irq(spinlock_t *lock)`	释放自旋锁并启用本地中断
	`spin_unlock_bh(spinlock_t *lock)`	释放自旋锁并启用软中断
	`rwlock_t lock = RW_LOCK_UNLOCKED`	声明并初始化读写自旋锁（解锁状态）
	`rwlock_init(rwlock_t *lock)`	初始化读写自旋锁
	`read_lock(rwlock_t *lock)`	获取读锁
	`read_lock_irqsave(rwlock_t *lock, unsigned long flags)`	获取读锁并保存中断状态
	`read_lock_irq(rwlock_t *lock)`	获取读锁并禁止本地中断
	`read_lock_bh(rwlock_t *lock)`	获取读锁并禁止软中断
	`read_unlock(rwlock_t *lock)`	释放读锁
	`read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)`	释放读锁并恢复中断状态
	`read_unlock_irq(rwlock_t *lock)`	释放读锁并启用本地中断
	`read_unlock_bh(rwlock_t *lock)`	释放读锁并启用软中断
	`write_lock(rwlock_t *lock)`	获取写锁
	`write_lock_irqsave(rwlock_t *lock, unsigned long flags)`	获取写锁并保存中断状态
	`write_lock_irq(rwlock_t *lock)`	获取写锁并禁止本地中断
	`write_lock_bh(rwlock_t *lock)`	获取写锁并禁止软中断
	`write_unlock(rwlock_t *lock)`	释放写锁
	`write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)`	释放写锁并恢复中断状态
	`write_unlock_irq(rwlock_t *lock)`	释放写锁并启用本地中断
	`write_unlock_bh(rwlock_t *lock)`	释放写锁并启用软中断
`<asm/atomic.h>`	`atomic_t v = ATOMIC_INIT(value)`	声明并初始化原子变量
	`atomic_set(atomic_t *v, int i)`	设置原子变量的值
	`atomic_read(atomic_t *v)`	读取原子变量的值
	`atomic_add(int i, atomic_t *v)`	原子地增加 i
	`atomic_sub(int i, atomic_t *v)`	原子地减少 i
	`atomic_inc(atomic_t *v)`	原子地自增 1
	`atomic_dec(atomic_t *v)`	原子地自减 1
	`atomic_inc_and_test(atomic_t *v)`	自增后测试是否为 0（为 0 返回 1）
	`atomic_dec_and_test(atomic_t *v)`	自减后测试是否为 0（为 0 返回 1）
	`atomic_sub_and_test(int i, atomic_t *v)`	减 i 后测试是否为 0（为 0 返回 1）
	`atomic_add_negative(int i, atomic_t *v)`	加 i 后测试是否为负数（负数返回 1）
	`atomic_add_return(int i, atomic_t *v)`	加 i 后返回新值
	`atomic_sub_return(int i, atomic_t *v)`	减 i 后返回新值
	`atomic_inc_return(atomic_t *v)`	自增后返回新值
	`atomic_dec_return(atomic_t *v)`	自减后返回新值
`<asm/bitops.h>`	`set_bit(nr, void *addr)`	原子地设置第 nr 位
	`clear_bit(nr, void *addr)`	原子地清除第 nr 位
	`change_bit(nr, void *addr)`	原子地翻转第 nr 位
	`test_bit(nr, void *addr)`	测试第 nr 位的值（返回 0/1）
	`test_and_set_bit(nr, void *addr)`	测试并设置第 nr 位（返回原状态）
	`test_and_clear_bit(nr, void *addr)`	测试并清除第 nr 位（返回原状态）
	`test_and_change_bit(nr, void *addr)`	测试并翻转第 nr 位（返回原状态）
`<linux/seqlock.h>`	`seqlock_t lock = SEQLOCK_UNLOCKED`	声明并初始化顺序锁（解锁状态）
	`seqlock_init(seqlock_t *lock)`	初始化顺序锁
	`read_seqbegin(seqlock_t *lock)`	开始读操作，返回当前序列号
	`read_seqbegin_irqsave(seqlock_t *lock, unsigned long flags)`	开始读操作并保存中断状态
	`read_seqretry(seqlock_t *lock, unsigned int seq)`	重试读操作（序列号不一致则重新读取）
	`read_seqretry_irqrestore(seqlock_t *lock, unsigned int seq, unsigned long flags)`	重试读操作并恢复中断状态
	`write_seqlock(seqlock_t *lock)`	获取写锁
	`write_seqlock_irqsave(seqlock_t *lock, unsigned long flags)`	获取写锁并保存中断状态
	`write_seqlock_irq(seqlock_t *lock)`	获取写锁并禁止本地中断
	`write_seqlock_bh(seqlock_t *lock)`	获取写锁并禁止软中断
	`write_tryseqlock(seqlock_t *lock)`	尝试获取写锁（失败返回 0）
	`write_sequnlock(seqlock_t *lock)`	释放写锁
	`write_sequnlock_irqrestore(seqlock_t *lock, unsigned long flags)`	释放写锁并恢复中断状态
	`write_sequnlock_irq(seqlock_t *lock)`	释放写锁并启用本地中断
	`write_sequnlock_bh(seqlock_t *lock)`	释放写锁并启用软中断
`<linux/rcupdate.h>`	`rcu_read_lock`	进入 RCU 读临界区（原子读）
	`rcu_read_unlock`	退出 RCU 读临界区
	`call_rcu(struct rcu_head head, void (func)(void arg), void arg)`	安排 RCU 回调（所有 CPU 调度后执行资源释放）