Linux进程间通信：信号量 semget()、semop()、semctl()

本文转自：https://www.cnblogs.com/52php/p/5851570.html
  这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信 – 信号。下面就进入信号量的讲解。

一、什么是信号量

    为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码需要独占式地执行。而信号量就可以提供这样的一种访问机制，让一个临界区同一时间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。
    信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，叫做二进制信号量。而可以取多个正整数的信号量被称为通用信号量。这里主要讨论二进制信号量。

二、信号量的工作原理

    由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：
P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行
V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1。
    举个例子，就是两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减1。而第二个进程将被阻止进入临界区，因为当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行。

三、Linux的信号量机制

    Linux提供了一组精心设计的信号量接口来对信号进行操作，它们不只是针对二进制信号量，下面将会对这些函数进行介绍，但请注意，这些函数都是用来对成组的信号量值进行操作的。它们声明在头文件sys/sem.h中。

1、semget()函数

    它的作用是创建一个新信号量或取得一个已有信号量，原型为：
int semget(key_t key, int num_sems, int sem_flags);

第一个参数key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget()函数并提供一个键，再由系统生成一个相应的信号标识符（semget()函数的返回值），只有semget()函数才直接使用信号量键，所有其他的信号量函数使用由semget()函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。

第二个参数num_sems指定需要的信号量数目，它的值几乎总是1。

第三个参数sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。

semget()函数成功返回一个相应信号标识符（非零），失败返回-1.

2、semop()函数

    它的作用是改变信号量的值，原型为：
int semop(int semid, struct sembuf *sops, unsigned nsops);

sem_id是由semget()返回的信号量标识符;
sembuf结构的定义如下：

struct sembuf {
	short sem_num; // 除非使用一组信号量，否则它为0
	short sem_op;  // 信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即P（等待）操作，
	               // 一个是+1，即V（发送信号）操作。
	short flag;  // 0 设置信号量的默认操作
	             // IPC_NOWAIT设置信号量操作不等待
	             // SEM_UNDO 选项会让内核记录一个与调用进程相关的UNDO记录，如果该进程崩溃，则根据这个进程的UNDO记录
	             // 自动恢复相应信号量的计数值
	short sem_flg; // 通常为SEM_UNDO,使操作系统跟踪信号，并在进程没有释放该信号量而终止时，操作系统释放信号量
};

nsops：进行操作信号量的个数，即sops结构变量的个数，需大于或等于1。最常见设置此值等于1，只完成对一个信号量的操作

3、semctl()函数

    该函数用来直接控制信号量信息，它的原型为：
int semctl(int semid, int semnum, int cmd, union semun arg)；

函数传入值	semid	信号量集标识符
	semnum	信号量集数组上的下标，表示某一个信号量
	cmd	见下文表
	arg	union semun {      short val; /*SETVAL用的值*/      struct semid_ds* buf; /*IPC_STAT、IPC_SET用的semid_ds结构*/      unsigned short* array; /*SETALL、GETALL用的数组值*/      struct seminfo *buf; /*为控制IPC_INFO提供的缓存*/ } arg;
函数返回值	成功：大于或等于0，具体说明请参考下表
	出错：-1，错误原因存于error中
错误代码	EACCESS：权限不够 EFAULT：arg指向的地址无效 EIDRM：信号量集已经删除 EINVAL：信号量集不存在，或者semid无效 EPERM：进程有效用户没有cmd的权限 ERANGE：信号量值超出范围

semctl函数cmd形参说明表

命令	解释
IPC_STAT	从信号量集上检索semid_ds结构，并存到semun联合体参数的成员buf的地址中
IPC_SET	设置一个信号量集合的semid_ds结构中ipc_perm域的值，并从semun的buf中取出值
IPC_RMID	从内核中删除信号量集合
GETALL	从信号量集合中获得所有信号量的值，并把其整数值存到semun联合体成员的一个指针数组中
GETNCNT	返回当前等待资源的进程个数
GETPID	返回最后一个执行系统调用semop()进程的PID
GETVAL	返回信号量集合内单个信号量的值
GETZCNT	返回当前等待100%资源利用的进程个数
SETALL	与GETALL正好相反
SETVAL	用联合体中val成员的值设置信号量集合中单个信号量的值

四、进程使用信号量通信

demo 1

     sem.c源代码如下：

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

union semun {
    int val; /* value for SETVAL */
    struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
    unsigned short *array; /* array for GETALL, SETALL */
    struct seminfo *__buf; /* buffer for IPC_INFO */
    };

/***对信号量数组semnum编号的信号量做P操作***/
int P(int semid, int semnum)
{
	struct sembuf sops={semnum,-1, SEM_UNDO};
    return (semop(semid,&sops,1));
}

/***对信号量数组semnum编号的信号量做V操作***/
int V(int semid, int semnum)
{
    struct sembuf sops={semnum,+1, SEM_UNDO};
    return (semop(semid,&sops,1));
}

int main(int argc, char **argv)
{
    int key ;
    int semid,ret;
    union semun arg;
    struct sembuf semop;
    int flag ;
    
    key = ftok("/tmp", 0x66 ) ;
    
    if ( key < 0 )
    {
        perror("ftok key error") ;
        return -1 ;
    }

    /***本程序创建了三个信号量，实际使用时只用了一个0号信号量***/
    semid = semget(key,3,IPC_CREAT|0600);
   
    if (semid == -1)
    {
        perror("create semget error");
        return ;
    }

    if ( argc == 1 )
    {
        arg.val = 1;
        
        /***对0号信号量设置初始值***/
        ret =semctl(semid,0,SETVAL,arg);

        if (ret < 0 )
        {
            perror("ctl sem error");
            semctl(semid,0,IPC_RMID,arg);
            return -1 ;
        }
    }

    /***取0号信号量的值***/
    ret =semctl(semid,0,GETVAL,arg);
    printf("after semctl setval  sem[0].val =[%d]\n",ret);
    system("date") ;
    printf("P operate begin\n") ;
    flag = P(semid,0)  ;
    
    if ( flag )
    {
        perror("P operate error") ;
        return -1 ;
    }

    printf("P operate end\n") ;
    ret =semctl(semid,0,GETVAL,arg);
    printf("after P sem[0].val=[%d]\n",ret);
    system("date") ;
    
    if ( argc == 1 )
    {
        sleep(120) ;
    }
    
    printf("V operate begin\n") ;
    
    if (V(semid, 0) < 0)
    {
        perror("V operate error") ;
        return -1 ;
    }

    printf("V operate end\n") ;
    ret =semctl(semid,0,GETVAL,arg);
    printf("after V sem[0].val=%d\n",ret);
    system("date") ;

    if ( argc >1 )
    {
            semctl(semid,0,IPC_RMID,arg);
     }
    
    return 0 ;
}

① 编译 gcc sem.c –o sem。

② 在一窗口执行./sem，执行结果如下：

after semctl setval sem[0].val =[1]

2011年 01月 11日 星期二 10:08:11 CST

P operate begin

P operate end

after P sem[0].val=[0]

2011年 01月 11日 星期二 10:08:11 CST

V operate begin

V operate end

after V sem[0].val=0

2011年 01月 11日 星期二 10:10:11 CST

③ 然后在另一窗口中执行./sem test1，执行结果如下：

after semctl setval sem[0].val =[0]

2011年 01月 11日 星期二 10:08:36 CST

P operate begin

P operate end

after P sem[0].val=[0]

2011年 01月 11日 星期二 10:10:11 CST

V operate begin

V operate end

after V sem[0].val=1

2011年 01月 11日 星期二 10:10:11 CST

demo 2

    下面使用一个例子来说明进程间如何使用信号量来进行通信，这个例子是两个相同的程序同时向屏幕输出数据，我们可以看到如何使用信号量来使两个进程协调工作，使同一时间只有一个进程可以向屏幕输出数据。注意，如果程序是第一次被调用（为了区分，第一次调用程序时带一个要输出到屏幕中的字符作为一个参数），则需要调用set_semvalue()函数初始化信号并将message字符设置为传递给程序的参数的第一个字符，同时第一个启动的进程还负责信号量的删除工作。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
    在main函数中调用semget()来创建一个信号量，该函数将返回一个信号量标识符，保存于全局变量sem_id中，然后以后的函数就使用这个标识符来访问信号量。源文件为seml.c，代码如下：

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/sem.h>
 
//union semun
//{
//  int val;
//  struct semid_ds *buf;
//  unsigned short *arry;
//};
 
static int sem_id = 0;
static int set_semvalue();
static void del_semvalue();
static int semaphore_p();
static int semaphore_v();
 
int main(int argc, char *argv[])
{
    char message = 'X';
    int i = 0;
 
    // 创建信号量
    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);
        }
 
        // 设置要输出到屏幕中的信息，即其参数的第一个字符
        message = argv[1][0];
        sleep(2);
    }
 
    for (i = 0; i < 10; ++i)
    {
        // 进入临界区
        if (!semaphore_p())
        {
            exit(EXIT_FAILURE);
        }
 
        // 向屏幕中输出数据
        printf("%c", message);
 
        // 清理缓冲区，然后休眠随机时间
        fflush(stdout);
        sleep(rand() % 3);
 
        // 离开临界区前再一次向屏幕输出数据
        printf("%c", message);
        fflush(stdout);
 
        // 离开临界区，休眠随机时间后继续循环
        if (!semaphore_v())
        {
            exit(EXIT_FAILURE);
        }
        sleep(rand() % 2);
    }
 
    sleep(10);
    printf("\n%d - finished\n", getpid());
 
    if (argc > 1)
    {
        // 如果程序是第一次被调用，则在退出前删除信号量
        sleep(3);
        del_semvalue();
    }
    exit(EXIT_SUCCESS);
}
 
static int set_semvalue()
{
    // 用于初始化信号量，在使用信号量前必须这样做
    union semun sem_union;
 
    sem_union.val = 1;
    if (semctl(sem_id, 0, SETVAL, sem_union) == -1)
    {
        return 0;
    }
    return 1;
}
 
static void del_semvalue()
{
    // 删除信号量
    union semun sem_union;
 
    if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1)
    {
        fprintf(stderr, "Failed to delete semaphore\n");
    }
}
 
static int semaphore_p()
{
    // 对信号量做减1操作，即等待P（sv）
    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;
}
 
static int semaphore_v()
{
    // 这是一个释放操作，它使信号量变为可用，即发送信号V（sv）
    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;
}

运行结果如下：

注：这个程序的临界区为main函数for循环不的semaphore_p()和semaphore_v()函数中间的代码。

例子分析：
    同时运行一个程序的两个实例，注意第一次运行时，要加上一个字符作为参数，例如本例中的字符‘O’，它用于区分是否为第一次调用，同时这个字符输出到屏幕中。因为每个程序都在其进入临界区后和离开临界区前打印一个字符，所以每个字符都应该成对出现，正如你看到的上图的输出那样。在main函数中循环中我们可以看到，每次进程要访问stdout（标准输出），即要输出字符时，每次都要检查信号量是否可用（即stdout有没有正在被其他进程使用）。所以，当一个进程A在调用函数semaphore_p()进入了临界区，输出字符后，调用sleep()时，另一个进程B可能想访问stdout，但是信号量的P请求操作失败，只能挂起自己的执行，当进程A调用函数semaphore_v()离开了临界区，进程B马上被恢复执行。然后进程A和进程B就这样一直循环了10次。

    看了上面的例子，你可能还不是很明白，不过没关系，下面我就以另一个例子来说明一下，它实现的功能与前面的例子一样，运行方式也一样，都是两个相同的进程，同时向stdout中输出字符，只是没有使用信号量，两个进程在互相竞争stdout。它的代码非常简单，文件名为normalprint.c，代码如下：

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
    char message = 'X';
    int i = 0;
    if (argc > 1)
    {
        message = argv[1][0];
    }
     
    for (i = 0; i < 10; ++i)
    {
        printf("%c", message);
        fflush(stdout);
        sleep(rand() % 3);
        printf("%c", message);
        fflush(stdout);
        sleep(rand() % 2);
    }
    sleep(10);
    printf("\n%d - finished\n", getpid());
     
    exit(EXIT_SUCCESS);
}

运行结果如下：

例子分析：
    从上面的输出结果，我们可以看到字符‘X’和‘O’并不像前面的例子那样，总是成对出现，因为当第一个进程A输出了字符后，调用sleep休眠时，另一个进程B立即输出并休眠，而进程A醒来时，再继续执行输出，同样的进程B也是如此。所以输出的字符就是不成对的出现。这两个进程在竞争stdout这一共同的资源。通过两个例子的对比，我想信号量的意义和使用应该比较清楚了。

五、信号量的总结

    信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。我们通常通过信号来解决多个进程对同一资源的访问竞争的问题，使在任一时刻只能有一个执行线程访问代码的临界区域，也可以说它是协调进程间的对同一资源的访问权，也就是用于同步进程的。