信号量sem

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,使操做系统跟踪信号，  
                    //并在进程没有释放该信号量而终止时，操做系统释放信号量  
};  

　　

三、semctl函数

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

 

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

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

union semun{  
    int val;  
    struct semid_ds *buf;  
    unsigned short *arry;  
};  

　　

前两个参数与前面一个函数中的同样，command一般是下面两个值中的其中一个

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

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

 

4、进程使用信号量通讯

下面使用一个例子来讲明进程间如何使用信号量来进行通讯，这个例子是两个相同的程序同时向屏幕输出数据，咱们能够看到如何使用信号量来使两个进程协调工做，使同一时间只有一个进程能够向屏幕输出数据。注意，若是程序是第一次被调用（为了区分，第一次调用程序时带一个要输出到屏幕中的字符做为一个参数），则须要调用set_semvalue函数初始化信号并将message字符设置为传递给程序的参数的第一个字符，同时第一个启动的进程还负责信号量的删除工做。若是不删除信号量，它将继续在系统中存在，即便程序已经退出，它可能在你下次运行此程序时引起问题，并且信号量是一种有限的资源。

 

在main函数中调用semget来建立一个信号量，该函数将返回一个信号量标识符，保存于全局变量sem_id中，而后之后的函数就使用这个标识符来访问信号量。

 

源代码以下：

 

#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>


static int sem_id = 0;

static int init_sem()
{
    semun sem_union;
    sem_union.val = 1;
    
    if (semctl(sem_id, 0, SETVAL, sem_union) == -1) {
        printf("error to open semaphore!\n");
        return 0;
    }
    
    return 1;
}

static int del_sem()
{
    semun sem_union;
    
    if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1) {
        printf("err to delete semaphore!\n");
        
        return 0;
    }
    
    return 1;
}

static int semaphore_p()
{
    sembuf sem_buf;
    
    sem_buf.sem_num = 0;
    sem_buf.sem_op = -1;
    sem_buf.sem_flg = SEM_UNDO;
    
    
    if (semop(sem_id, &sem_buf, 1) == -1) {
        printf("semaphore failed\n");
        return 0;
    }
    
    return 1;
}

static int semaphore_v()
{
    sembuf sem_buf;
    
    sem_buf.sem_num = 0;
    sem_buf.sem_op = 1;
    sem_buf.sem_flg = SEM_UNDO;
    
    if (semop(sem_id, &sem_buf, 1) == -1) {
        printf("semaphore failed\n");
        return 0;
    }
    
    return 1;
}

int main(int argc, char* argv[])
{
    char message = 'X';
    
    sem_id = semget((key_t)1234, 1, 0666|IPC_CREAT);
    
    if (argc > 1) {
        if (!init_sem()) {
            printf("create semaphore failed\n");
            exit(EXIT_FAILURE);
        }
        
        message = 'F';
        sleep(3);
    }
    
    for (int i = 0; i < 10; i++) {
        if (!semaphore_p()) {
            exit(EXIT_FAILURE);
        }
        
        printf("%c", message);
        fflush(stdout);
        sleep(rand()%3 );
        
        printf("%c", message);
        fflush(stdout);
        sleep(rand()%2);
        
        if (!semaphore_v()) {
            exit(EXIT_FAILURE);
        }
        
        sleep(rand()%2);
    }
    
    sleep(10);
    printf("\n %d- finished\n", getpid());
    
    if (argc > 1) {
        sleep(3);
        del_sem();
    }
    exit(EXIT_FAILURE);
    
    
    
    return 0;
}

　　

须要注意，执行的方法：

brackendeMacBook-Pro:cpp_test bracken$ gcc -o selm.exe main.cpp -lm
brackendeMacBook-Pro:cpp_test bracken$ ./selm.exe 0 & ./selm.exe 
[1] 10796
XXFFXXXXFFFFXXFFXXXXFFXXFFXXFFXXFFXXFFFF
 10797- finished
brackendeMacBook-Pro:cpp_test bracken$ 
 10796- finished

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