1. 信号量(semaphore)主要用于保护临界资源。
进程可以根据它判断是否能访问某些共享资源。
信号量除了用于访问控制外，还可用于进程同步，也就是进程间通信。
2. 信号量分类：
a. 二值信号量： 信号量的值只能取0或1，类似于互斥锁mutex，但两者又不同：
mutex 与 二值信号量的区别：
信号量强调共享资源，只要共享资源可用，其他进程同样可以修改信号量的值；
互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来接锁。
b. 计数信号量：信号量的值可以取任意非负值。
system V信号量通过定义如下概念给信号量增加了另外一级复杂度。
计数信号量集：一个或多个信号量（构成一个集合），其中每个都是计数信号量。每个集合的信号量数存在一个限制，一般在25个数量级。
3.semget函数（信号量的创建）
semget函数创建一个信号量集或访问一个已存在的信号量集。
#include
int senget(key_t key,int nsems,int oflag); nsems参数指定集合中的信号量数。如果我们不创建一个新的信号量集，而只是访问一个已存在的集合，那就可以把该参数指定为0。一旦创建完一个信号量集，我们就不能改变其中的信号量数。
oflag值是SEM_R和SEM_A常值得组合。他们还可以与IPC _CREAT或IPC_CREAT | IPC_EXCL按位或。
当实际操作为创建一个新的信号量集时，相应的semid_ds结构的以下成员将被初始化。
（1）sem_perm结构的uid和cuid成员被置为调用进程的有效用户ID，gid和cgid成员被置为调用进程的有效组ID。
（2）oflag参数中的读写权限位存入sem_perm.mode。
（3）sem_otime被置为0，sem_ctime则被置为当前时间。
（4）sem_nsems被置为nsems参数的值。
（5）与该集合中每个信号量关联的各个sem结构并不初始化。这些结构时在以SET_VAL或SETALL命令调用semctl时初始化的。
4.semop函数（操作信号量）
使用semget打开一个信号量集后，对其中一个或多个信号量的操作就使用semop函数来执行。
#include
int semop(int semid,struct sembuf *opsptr,size_t nops); struct sembuf{
unsigned short sem_num; /* semaphore number */
short sem_op; /* semaphore operation */
short sem_flg; /* operation flags */
};假定有一个信号量变量sv，
P(sv)：用于等待，如果sv大于0，就给它减去1，如果它的值等于0，就挂起该进程的执行
V(sv)：用于发送信号，如果有其他进程因等待sv而挂起，就让它恢复运行，如果没有进程因等待sv而被挂起，就给它加1
semaphore sv=1;
loop forever{
P(sv);
critical code section;
V(sv);
noncritical code section;
}
信号量函数定义如下所示：
#include
int semctl(int sem_id, int sem_num, int command, ...);//用来直接控制信号量信息
int semget(key_t key, int num_sems, int sem_flags);//创建一个新信号量或取得一个已有信号量的键
int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);//用于改变信号量的值
/* After the #includes, the function prototypes and the global variable, we come to the
main function. There the semaphore is created with a call to semget, which returns the
semaphore ID. If the program is the first to be called (i.e. it's called with a parameter
and argc > 1), a call is made to set_semvalue to initialize the semaphore and op_char is
set to X. */
#include
#include
#include
#include
#include "semun.h"
static int set_semvalue(void);
static void del_semvalue(void);
static int semaphore_p(void);
static int semaphore_v(void);
static int sem_id;
int main(int argc, char *argv[])
{
int i;
int pause_time;
char op_char = 'O';
srand((unsigned int)getpid());
sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);
if (argc > 1) {
if (!set_semvalue()) {
fprintf(stderr, "Failed to initialize semaphore\n");
exit(EXIT_FAILURE);
}
op_char = 'X';
sleep(2);
}
/* Then we have a loop which enters and leaves the critical section ten times.
There, we first make a call to semaphore_p which sets the semaphore to wait, as
this program is about to enter the critical section. */
for(i = 0; i < 10; i++) {
if (!semaphore_p()) exit(EXIT_FAILURE);
printf("%c", op_char);fflush(stdout);
pause_time = rand() % 3;
sleep(pause_time);
printf("%c", op_char);fflush(stdout);
/* After the critical section, we call semaphore_v, setting the semaphore available,
before going through the for loop again after a random wait. After the loop, the call
to del_semvalue is made to clean up the code. */
if (!semaphore_v()) exit(EXIT_FAILURE);
pause_time = rand() % 2;
sleep(pause_time);
}
printf("\n%d - finished\n", getpid());
if (argc > 1) {
sleep(10);
del_semvalue();
}
exit(EXIT_SUCCESS);
}
/* The function set_semvalue initializes the semaphore using the SETVAL command in a
semctl call. We need to do this before we can use the semaphore. */
static int set_semvalue(void)
{
union semun sem_union;
sem_union.val = 1;
if (semctl(sem_id, 0, SETVAL, sem_union) == -1) return(0);
return(1);
}
/* The del_semvalue function has almost the same form, except the call to semctl uses
the command IPC_RMID to remove the semaphore's ID. */
static void del_semvalue(void)
{
union semun sem_union;
if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1)
fprintf(stderr, "Failed to delete semaphore\n");
}
/* semaphore_p changes the semaphore by -1 (waiting). */
static int semaphore_p(void)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1; /* P() */
sem_b.sem_flg = SEM_UNDO;
if (semop(sem_id, &sem_b, 1) == -1) {
fprintf(stderr, "semaphore_p failed\n");
return(0);
}
return(1);
}
/* semaphore_v is similar except for setting the sem_op part of the sembuf structure to 1,
so that the semaphore becomes available. */
static int semaphore_v(void)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = 1; /* V() */
sem_b.sem_flg = SEM_UNDO;
if (semop(sem_id, &sem_b, 1) == -1) {
fprintf(stderr, "semaphore_v failed\n");
return(0);
}
return(1);
}