linux 内核同步互斥技术之信号量
信号量
信号量允许多个进程同时进入临界区，大多数情况下只允许一个进程进入临界区，把信号量的计数值设置为 1，即二值信号量，这种信号量称为互斥信号量。可允许多个锁持有者。
和自旋锁相比，信号量适合保护比较长的临界区，因为竞争信号量时进程可能睡眠和再次唤醒，代价很高。中断服务函数不能进行睡眠，因此信号量不能用于中断当中
信号量的使用流程：
定义一个信号量
↓
初始化信号量
↓
获得信号量（减操作）
↓
释放信号量（加操作）
内核使用的信号量定义如下：
include/linux/semaphore.h
struct semaphore {
raw_spinlock_t lock;
unsigned int count;
struct list_head wait_list;
};
成员 lock 是自旋锁，用来保护信号量的其他成员。
成员 count 是计数值，表示还可以允许多少次进入临界区。
成员 wait_list 是等待进入临界区的进程链表。
struct semaphore_waiter {
struct task_struct *task;
bool up;
struct list_head list;
};
初始化静态信号量的方法如下。
（1） __SEMAPHORE_INITIALIZER(name, n)：指定名称和计数值，允许同时n 次进入临界区。
（2） DEFINE_SEMAPHORE(name)：初始化一个互斥信号量。
在运行时动态初始化信号量的方法如下：
static inline void sema_init(struct semaphore *sem, int val);
参数 val 指定允许同时进入临界区的数量。
获取信号量的函数如下。
（1） void down(struct semaphore *sem);
获取信号量，如果计数值是 0，进程深度睡眠。
（2） int down_interruptible(struct semaphore *sem);
获取信号量，如果计数值是 0，进程轻度睡眠（可以被系统消息打断，该函数的调用允许中断）。如果返回0，表示获得信号量正常返回，如果被信号打断，返回-EINTR。
（3） int down_killable(struct semaphore *sem);
获取信号量，如果计数值是 0，进程中度睡眠（可以因为受到致命信号而被唤醒）。
（4） int down_trylock(struct semaphore *sem);
获取信号量，如果计数值是 0，进程不等待不会导致调用者睡眠。
（5） int down_timeout(struct semaphore *sem, long jiffies);
获取信号量，指定等待的时间。
释放信号量的函数如下：
void up(struct semaphore *sem);
使用示例
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/semaphore.h>
#include <linux/delay.h>
int num[2][5]= { {
0,2,4,6,8
}
, {
1,3,5,7,9
}
}
;
struct semaphore sem_first;
struct semaphore sem_second;
struct task_struct * task1;
struct task_struct * task2;
int thread_print_first(void *p) {
int i;
int *num=(int *)p;
if(kthread_should_stop()){
return 0;
}
printk(KERN_ALERT"Hello World:first\n");
for (i=0;i<5;i++) {
down(&sem_first);
printk(KERN_ALERT"Hello World:%d\n",num[i]);
up(&sem_second);
}
do {
msleep(1000);
}
while(!kthread_should_stop());
return 0;
}
int thread_print_second(void *p) {
int i;
int *num=(int *)p;
if(kthread_should_stop()){
return 0;
}
printk(KERN_ALERT"Hello World:second\n");
for (i=0;i<5;i++) {
down(&sem_second);
printk(KERN_ALERT"Hello World:%d\n",num[i]);
up(&sem_first);
}
do {
msleep(1000);
}
while(!kthread_should_stop());
return 0;
}
static int hello_init(void) {
printk(KERN_ALERT"Hello World enter\n");
sema_init(&sem_first,1);
sema_init(&sem_second,0);
task1 = kthread_create(thread_print_first,num[0],"first");
if(IS_ERR(task1)) {
printk(KERN_ALERT"kthread_create error!\n");
return -1;
}
task2 = kthread_create(thread_print_second,num[1],"second");
if(IS_ERR(task2)) {
printk(KERN_ALERT"kthread_create error!\n");
kthread_stop(task1);
return -1;
}
wake_up_process(task1);
wake_up_process(task2);
return 0;
}
static void hello_exit(void) {
int ret;
if (!IS_ERR(task1)) {
ret = kthread_stop(task1);
printk("<<<<<<<<task1 exit, ret = %d\n", ret);
}
if (!IS_ERR(task2)) {
ret = kthread_stop(task2);
printk("<<<<<<<<task2 exit, ret = %d\n", ret);
}
printk(KERN_ALERT"hello world exit\n");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");