进程间通讯之信号量

进程间通讯之信号量

1、什么是信号量

为了防止出现因多个程序同时访问一个共享资源而引起的一系列问题，咱们须要一种方法，它能够经过生成并使用令牌来受权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码须要独占式地执行。而信号量就能够提供这样的一种访问机制，让一个临界区同一时间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。

信号量是一个特殊的变量，程序对其访问都是原子操做，且只容许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操做。最简单的信号量是只能取0和1的变量，这也是信号量最多见的一种形式，叫作二进制信号量（二元信号量）。而能够取多个正整数的信号量被称为通用信号量。这里主要讨论二进制信号量。

2、信号量的工做原理

因为信号量只能进行两种操做等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：

P(sv)：若是sv的值大于零，就给它减1；若是它的值为零，就挂起该进程的执行

V(sv)：若是有其余进程因等待sv而被挂起，就让它恢复运行，若是没有进程因等待sv而挂起，就给它加1。

举个例子：

两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操做，它将获得信号量，并能够进入临界区，使sv减1。而第二个进程将被阻止进入临界区，由于当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就能够恢复执行。

3、Linux的信号量机制

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

一、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.

 二、semop函数

它的做用是改变信号量的值，原型为：

int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);  

sem_id是由semget返回的信号量标识符，sembuf结构的定义以下：

struct sembuf{

    short sem_num;  //除非使用一组信号量，不然它为0

    short sem_op;     //信号量在一次操做中须要改变的数据，一般是两个数，

                                 //一个是-1，即P（等待）操做，

                                //一个是+1，即V（发送信号）操做。

    short sem_flg;    //一般为SEM_UNDO,使操做系统跟踪信号，

                               //并在进程没有释放该信号量而终止时，操做系统释放信号量

};

num_sem_ops是信号操做结构的数量，恒大于或等于1。

三、semctl函数

该函数用来直接控制信号量信息，它的原型为：

int semctl(int sem_id, int sem_num, int command, ...);

若是有第四个参数，它一般是一个union semum结构，定义以下：

union semun{

    int val;

    struct semid_ds *buf;

    unsigned short *arry;

};

sem_id是由semget返回的信号量标识符。sem_num参数是操做信号在信号集中的编号，第一个信号的编号是0。command一般是下面两个值中的其中一个

SETVAL：用来把信号量初始化为一个已知的值。p 这个值经过union semun中的val成员设置，其做用是在信号量第一次使用前对它进行设置。

IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。

举个例子：

下面这个例子由两个进程（父子进程）同时向屏幕输出字符，父进程每次输出两个‘B’，子进程每次输出两个‘A’，若是不加信号量控制的话，则输出的字符并无规律。

此时利用一个二元信号量加以控制，则输出的字符变得有规律了。

 程序组成：

comm.h：封装所需的函数声明

comm.c：函数的实现

test_sem.c：测试代码

代码：

comm.h

#pragma once

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

#define _PROJ_NAME_ "./tmp"
#define _PROJ_ID_ 0x6666

//struct sembuf
//{
//    unsigned short sem_num;  /* semaphore number */
//    short          sem_op;   /* semaphore operation */
//    short          sem_flg;  /* operation flags */
//};

int creat_sem_set(int sems);
int init_sem_set(int msg_id, int which, int val);
int get_sem_set();
int destory_sem_set(int msg_id);
int P(int sem_id, int which);
int V(int sem_id, int which);

comm.c

#include "comm.h"


static int comm_sem_set(int sems, int flag)
{
    key_t _key = ftok(_PROJ_NAME_, _PROJ_ID_);
    if(_key < 0)
    {
        perror("ftok");
        return -1;
    }

    int sem_id = semget(_key, sems, flag); 
    if(sem_id < 0)
    {
        perror("semget");
        return -2;
    }

    return sem_id;
}

int create_sem_set(int sems)
{
    int flag = IPC_CREAT | IPC_EXCL | 0644;
    return comm_sem_set(sems, flag);
}

int init_sem_set(int msg_id, int which, int val)
{
    int ret = semctl(msg_id, which, SETVAL, val);
    if(ret < 0)
    {
        perror("semctl");
        return -1;
    }
    return 0;
}


int get_sem_set()
{
    int flag = IPC_CREAT;
    return comm_sem_set(0, flag);
}

int destory_sem_set(int sem_id)
{
    int ret = semctl(sem_id, 0, IPC_RMID);
    if(ret < 0)
    {
        perror("semctl");
        return -1;
    }
    return 0;
}

static int op(int sem_id, int which, int op)
{
    struct sembuf _sem;
    _sem.sem_num = which;
    _sem.sem_op = op;
    _sem.sem_flg = 0;

    int ret = semop(sem_id, &_sem, 1);
    if(ret < 0)
    {
        perror("semop");
        return -1;
    }
    return 0;
}

int P(int sem_id, int which)
{
    return op(sem_id, which, -1);
}

int V(int sem_id, int which)
{
    return op(sem_id, which, +1);
}

test_sem.c

#include "comm.h"

int main()
{

    int sem_id = create_sem_set(1);
    init_sem_set(sem_id, 0, 1);
    pid_t id = fork();
    if(id == 0)  //child
    {
        int c_sem_id = get_sem_set();
        while(1)
        {
            P(c_sem_id, 0);
            printf("A");
            fflush(stdout);
            usleep(rand()%123456);
            printf("A");
            fflush(stdout);
            usleep(rand()%12345);
            V(c_sem_id, 0);
        }
    }
    else  // father
    {
        while(1)
        {
            P(sem_id, 0);
            printf("B");
            fflush(stdout);
            usleep(rand()%123459);
            printf("B");
            fflush(stdout);
            usleep(rand()%12344);
            V(sem_id, 0);
        }

        wait(NULL);
        destory_sem_set(sem_id);
    }

    return 0;
}

总结

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