>
Home

登龙（DLonng）

选择大于努力

Linux 高级编程 - 信号量 semaphore

版权声明：本文为 DLonng 原创文章，可以随意转载，但必须在明确位置注明出处！

信号量 semaphore

信号量（semaphore）与之前介绍的管道，消息队列的等 IPC 的思想不同，信号量是一个计数器，用来为多个进程或线程提供对共享数据的访问。

信号量的原理

常用的信号量是二值信号量，它控制单个共享资源，初始值为 1，操作如下：

  1. 测试该信号量是否可用
  2. 若信号量为 1，则当前进程使用共享资源，并将信号量减 1（加锁）
  3. 若信号量为 0，则当前进程不可以使用共享资源并休眠，必须等待信号量为 1 时进程才能继续执行（解锁）

要注意因为是使用信号量来保护共享资源，所以信号量本身的操作不能被打断，即必须是原子操作，因此由内核来实现信号量。

查看信号量

类似消息队列和共享内存，我们也可以使用 ipcs 命令来查看当前系统的信号量资源：

ipcs -s

------ Semaphore Arrays --------
key        semid      owner      perms      nsems

目前我的系统中没有信号量，在后面例子中会使用这个命令来查看创建的信号量。

信号量的基本操作

Linux 内核提供了一套对信号量的操作，包括获取，设置，操作信号量，下面就来学习具体的 API。

1. 获取信号量

使用 semget 来创建或获取一个与 key 有关的信号量。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

/*
 * key：返回的 ID 与 key 有关系
 * nsems：信号量的值
 * semflg：创建标记
 * return：成功返回信号量 ID，失败返回 -1，并设置 erron
 */
int semget(key_t key, int nsems, int semflg);

关于参数的详细解释参考 man semget

2. 操作信号量

使用 semop 可以对一个信号量加 1 或者减 1：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

/*
 * semid：信号量 ID
 * sops：对信号量的操作
 * nsops：要操作的信号数量
 * return：成功返回 0，失败返回 -1，并设置 erron
 */
int semop(int semid, struct sembuf *sops, size_t nsops);

sembuf 表示了对信号量操作的属性：

struct sembuf {
	/* 信号量的个数，除非使用多个信号量，否则设置为 0 */
	unsigned short sem_num;  

	/* 信号量的操作，-1 表示 p 操作，1 表示 v 操作 */
	short          sem_op;   

	/* 通常设置为 SEM_UNDO，使得 OS 能够跟踪信号量并在没有释放时自动释放 */
	short          sem_flg;  
};

在进行信号量的 pv 操作时都是使用这个结构作为参数，详细解释参考 man semop。

3. 设置信号量

使用 semctl 可以设置一个信号量的初始值：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

/*
 * semid：要设置的信号量 ID
 * semnum：要设置的信号量的个数
 * cmd：设置的属性
 */
int semctl(int semid, int semnum, int cmd, ...);

第 4 个参数的类型是 union semun 结构：

union semun {
	int              val;    /* Value for SETVAL */
	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
	unsigned short  *array;  /* Array for GETALL, SETALL */
};

在使用信号量时必须手动定义这个结构，并且在初始化设置信号量（SETVAL）时需要使用这个参数，详细解释可以参考 man semctl。

例子：使用信号量进行进程间的同步

下面来学习一个实际使用信号量来进行进程间通信的例子，例子实现的功能是：一个程序的两个实例同步访问同一段代码，先来看看使用的关键的函数。

1. 获取信号量

在这个例子中将获取信号量包装成一个函数 sem_get：

// 创建或获取一个信号量
int sem_get(int sem_key) {
	int sem_id = semget(sem_key, 1, IPC_CREAT | 0666);

	if (sem_id == -1) {
		printf("sem get failed.\n");
		exit(-1);
	} else {
		printf("sem_id = %d\n", sem_id);
		return sem_id;
	}
}

创建或者获取成功打印信号量的 id，否则打印错误信息。

2. 初始化信号量

我们只初始化一个信号量，并设置 val = 1：

// 初始化信号量
int set_sem(int sem_id) {
	union semun sem_union;  
	sem_union.val = 1;  
	if(semctl(sem_id, 0, SETVAL, sem_union) == -1) {
		fprintf(stderr, "Failed to set sem\n");  
		return 0;  
	}
	return 1;  
}

主要使用了 union semun 作为第 4 个参数，其中 sem_union.val = 1，并且第 3 个参数必须为 SETVAL。

3. 删除信号量

虽然可以指定 OS 自动释放信号量，但这个还是要介绍手动释放的方法：

// 删除信号量  
void del_sem(int sem_id) {  
	union semun sem_union;  
	if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1)  
		fprintf(stderr, "Failed to delete sem, sem has been del.\n");  
}

第 3 个参数指定 IPC_RMID 来删除信号量。

4. 信号量的 PV 操作

下面的函数将信号量的 val 减 1，实现了 PV 操作：

// 减 1，加锁，P 操作
void sem_down(int sem_id) {
	if (-1 == semop(sem_id, &sem_lock, 1))
		fprintf(stderr, "semaphore lock failed.\n");
}

// 加 1，解锁，V 操作
void sem_up(int sem_id) {
	if (-1 == semop(sem_id, &sem_unlock, 1))
		fprintf(stderr, "semaphore unlock failed.\n");
}

5. main 函数

最后来看看主程序的逻辑，先创建或获取信号量，然后在第一次调用时初始化，接着执行 PV 操作，最后在第二次调用后删除信号量：

int main(int argc, char **argv) {
	int sem_id = sem_get(12);

	// 第一次调用多加一个参数，第二次调用不加参数，仅在第一次调用时创建信号量
	if (argc > 1 && (!set_sem(sem_id))) {
		printf("set sem failed.\n");
		return -1;
	}

	// P 操作
	sem_down(sem_id);
	printf("sem lock...\n");

	printf("do something...\n");
	sleep(10);

	// V 操作
	sem_up(sem_id);
	printf("sem unlock...\n");

	// 第二次调用后删除信号量
	if (argc == 1)
		del_sem(sem_id);

	return 0;
}

6. 编译，运行，测试

先编译：

gcc sem.c -o sem

在第一个终端运行，我们多加一个无用的参数来表示这是第一次运行：

./sem 1

sem_id = 0
sem lock...
do something...
# 10 s 等待
sem unlock...

我们使用 ipcs -s 查看一下当前系统中的信号量：

ipcs -s

------ Semaphore Arrays --------
key        semid      owner      perms      nsems     
0x0000000c 0          orange     666        1

看到用户 orange 已经成功创建了一个权限为 666 ，ID 为 0 的信号量了，再打开第二个终端，不加额外的参数再运行一次：

./sem

sem_id = 0
# 第一个终端打印完 sem unlock 后
sem lock...
do something...
# 10 s 等待
sem unlock...

因为是第二次运行，所以最后信号量会被删除，我们再来看看 ipcs -s 的结果：

ipcs -s

------ Semaphore Arrays --------
key        semid      owner      perms      nsems

可以看到信号量被成功删除了，这个效果亲自运行测试后可以理解的更加深刻，这两个进程是同步访问 do something 这部分代码的，第二个进程会等待第一个进程 unlock 后再运行，建议你下载代码实际运行一下。

拓展：信号量在 Linux 内核中的实现机制

最后，我们再来简单分析下信号量在 Linux 内核中的实现机制，了解机制可以帮助我们更好的理解和使用信号量。其实内核中的共享内存，消息队列和信号量的实现机制几乎是相同的，信号量也是开辟一片内存，然后对链表进行操作。

1. glibc 信号量函数分析

int semget (key, nsems, semflg)
key_t key;
int nsems;
int semflg;
{
    return INLINE_SYSCALL (ipc, 5, IPCOP_semget, key, nsems, semflg, NULL);
}

semget 函数直接使用 INLINE_SYSCALL 进行系统调用陷入内核，semop 和 semctl 也是类似，下面来看看内核中的实现。

2. semget 分析

semget 函数为信号量开辟一片新的内存，内核中的调用如下，也是使用了 ipc_ops 这个数据结构：

semget

其中回调了 newary 这个函数，它完成信号量的创建和获取：

newary

可以看出，整个过程与消息队列和共享内存几乎相同。

3. semop 分析

semop 对信号量进行 PV 操作，其中主要是对 sem_op 进行加 1 或者减 1，大体的过程如下：

semop

4. semctl 分析

semctl 对信号量进行控制，主要是使用 switch 来判断当前的命令然后执行相应的操作：

semctl

要注意的是，主要的处理逻辑在 semctl_main 这个函数中，其中每个 cmd 都有具体的执行逻辑，有兴趣可以详细分析。

结语

本次就简单地介绍了信号量的基本操作和内核的实现机制，对与信号量的应用并没有介绍太多，更多的应用方法还需要在实际工作中去实践。建议你将共享内存，消息队列和信号量自己总结对照分析一遍，看看它们的实现机制是不是几乎相同的，这可以加深你对他们的理解，了解些原理总是有些好处的。那我们下次再见，谢谢你的阅读。

本文原创首发于微信公号「登龙」，分享机器学习、算法编程、Python、机器人技术等原创文章，扫码即可关注！

DLonng at 09/02/17

‹ ›