信号量的应用场景

1、信号量的定义：

struct semaphore {

spinlock_t lock;

unsigned int count;

struct list_head wait_list;

};

在linux中，信号量用上述结构体表示，我们可以通过该结构体定义一个信号量。

2、信号量的初始化：

可用void sema_init(struct semaphore *sem, int val);直接创建，其中val为信号量初值。

也可以用两个宏来定义和初始化信号量的值为1或0：

DECLARE_MUTEX(name) : 定义信号量name并初始化为1

DECLARE_MUTEX_LOCKED(name) : 定义信号量name并初始化为0

还可以用下面的函数初始化：

void init_MUTEX(struct semaphore *sem); //初始化信号量的值为1

void init_MUTEX_LOCKED(struct semaphore *sem); //初始化信号量的值为0

3、信号量的原子操作：

p操作：

* void down(struct semaphore *sem); //用来获取信号量，如果信号量值大于或等于0，获取

信号量，否则进入睡眠状态，睡眠状态不可唤醒

* void down_interruptible(struct semephore *sem); //用来获取信号量，如果信号量大于或

等于0，获取信号量，否则进入睡眠状

态，等待信号量被释放后，激活该程。

* void down_trylock(struct semaphore *sem); //试图获取信号量，如果信号量已被其他进程

获取，则立刻返回非零值，调用者不会睡眠

v操作：

* void up(struct semaphore *sem); //释放信号量，并唤醒等待该资源进程队列的第一个进程

 前面一系列练习已经把进程控制、线程、进程间通信的大概知识过了一遍，现在进入综合练习，首先练习经典问题：生产者和消费者问题

1.问题概述

多个生产/消费者在有界缓冲上操作。它利用N个字节的共享内存作为有界循环缓冲区，利用写一字符模拟放一个产品，利用读一字符模拟消费一个产品。当缓冲区空时消费者应阻塞睡眠，而当缓冲区满时生产者应当阻塞睡眠。一旦缓冲区中有空单元，生产者进程就向空单元中入写字符,并报告写的内容和位置。一旦缓冲区中有未读过的字符，消费者进程就从该单元中读出字符，并报告读取位置。生产者不能向同一单元中连续写两次以上相同的字符，消费者也不能从同一单元中连续读两次以上相同的字符。

2.问题分析

首先看阶层，有两个，分别是生产者和消费者，他们之间的缓冲区是共享内存，首先想到一点：System V共享内存实现这一个缓冲区；又因为缓冲区是临界资源，所以要用一个互斥信号量实现；生产者和消费者要采用PV信号量操作实现进程同步

因为要求多个进程能同步，所以进程访问缓冲的指针也需要共享内存实现

大致框图：

生产者->[位置指针]--------（共享内存）缓冲-------[位置指针]->消费者

 

3.原语

  进程：Producer - 生产者进程，Consumer - 消费者进程
  共有的数据结构：
     buffer: array [0..k-1] of integer;
     in,out: 0..k-1;
       — in记录第一个空缓冲区，out记录第一个不空的缓冲区
     prod_key(缓冲区空的个数),cons_key(缓冲区满的个数),mutex(临界区): semaphore;

       — prod_key控制缓冲区不满,cons_key控制缓冲区不空,mutex保护临界区；
         初始化prod_key=k,cons_key=0,mutex=1
producer（生产者进程）：
   Item_Type item;
  {
     while (true)
     {
       produce(&item);
       p(prod_key);
       p(mutex);
       buffer[in]:=item;
       in:=(in+1) mod k;
       v(mutex);
       v(cons_key);
     }
  }

consumer（消费者进程）：
   Item_Type item;
  {
     while (true)
     {
       p(cons_key);
       p(mutex);
        item:=buffer[out];
        out:=(out+1) mod k;
        v(mutex);
        v(prod_key);
       consume(&item);
     }
   }
4.IPC操作函数

我们编写一个函数实现对IPC 信息队列、共享内存、信号量的包装，以备接下来更好的编写
程序
头文件ipc.h：声明ipc操作函数和一些变量

/*Filename : ipc.h*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#define BUFSZ 256
//建立或获取ipc 的一组函数的原型说明
int get_ipc_id(char *proc_file,key_t key);
char *set_shm(key_t shm_key,int shm_num,int shm_flag);
int set_msq(key_t msq_key,int msq_flag);
int set_sem(key_t sem_key,int sem_val,int sem_flag);
int down(int sem_id);
int up(int sem_id);
/*信号灯控制用的共同体*/
typedef union semuns
{
    int val;
} Sem_uns;
/* 消息结构体*/
typedef struct msgbuf
{
    long mtype;
    char mtext[1];
} Msg_buf;
//生产消费者共享缓冲区即其有关的变量
key_t buff_key;
int buff_num;
char *buff_ptr;
//生产者放产品位置的共享指针
key_t pput_key;
int pput_num;
int *pput_ptr;
//消费者取产品位置的共享指针
key_t cget_key;
int cget_num;
int *cget_ptr;
//生产者有关的信号量
key_t prod_key;     //IPC key标识
int prod_sem;       //生产者同步信号量

//消费者有关的信号量
key_t cons_key;     //IPC key标识
int cons_sem;       //消费者同步信号量
int sem_val;
int sem_flg;
int shm_flg;
/*互斥信号量*/
key_t mtx_key;      //IPC key标识
int mtx_sem;        //互斥信号量

ipc.c:这里包装了一些ipc的操作函数，包括信息队列、共享内存、信号量的创建/获得，及PV操作
这里逐一分析它们的实现过程：（在注释中）

/*ipc.c*/
#include "ipc.h"
/*
* get_ipc_id() 从/proc/sysvipc/文件系统中获取IPC 的id 号
* pfile: 对应/proc/sysvipc/目录中的IPC 文件分别为
* msg-消息队列,sem-信号量,shm-共享内存
* key: 对应要获取的IPC 的id 号的键值
*/
int get_ipc_id(char *proc_file,key_t key)
{
    FILE *pf;
    int i,j;
    char line[BUFSZ],colum[BUFSZ];
    if((pf = fopen(proc_file,"r")) == NULL)
    {
        perror("Proc file not open");
        exit(EXIT_FAILURE);
    }
    fgets(line, BUFSZ,pf);
    while(!feof(pf))
    {
        i = j = 0;
        fgets(line, BUFSZ,pf);
        while(line[i] == ' ')
            i++;
        while(line[i] !=' ')
            colum[j++] = line[i++];
        colum[j] = '/0';
        if(atoi(colum) != key)
            continue;
        j=0;
        while(line[i] == ' ')
            i++;
        while(line[i] !=' ')
            colum[j++] = line[i++];
        colum[j] = '/0';
        i = atoi(colum);
        fclose(pf);
        return i;
    } fclose(pf);
    return -1;
}
/*
* 信号灯上的P/V 操作
* sem_id:信号灯数组标识符
* sem_num:信号灯数组下标
* buf:操作信号灯的结构
*/
/*请求 P操作*/
int P_operation(int sem_id)
{
    struct sembuf buf;
    buf.sem_op = -1;
    buf.sem_num = 0;
    buf.sem_flg = SEM_UNDO;
    if((semop(sem_id,&buf,1)) <0)
    {
        perror("down error ");
        exit(EXIT_FAILURE);
    } return EXIT_SUCCESS;
}
/*释放 V操作*/
int V_operation(int sem_id)
{
    struct sembuf buf;
    buf.sem_op = 1;
    buf.sem_num = 0;
    buf.sem_flg = SEM_UNDO;
    if((semop(sem_id,&buf,1)) <0)
    {
        perror("up error ");
        exit(EXIT_FAILURE);
    } return EXIT_SUCCESS;
}
/*
* set_sem 函数建立一个具有n 个信号灯的信号量
* 如果建立成功，返回一个信号灯数组的标识符sem_id
* 输入参数：
* sem_key 信号灯数组的键值
* sem_val 信号灯数组中信号灯的个数
* sem_flag 信号灯数组的存取权限
*/
/*实现过程:*建立信号灯->设置信号灯初值->返回ID*/
int set_sem(key_t sem_key,int sem_val,int sem_flg)
{
    int sem_id;
    Sem_uns sem_arg;
    //测试由sem_key 标识的信号灯数组是否已经建立
    if((sem_id = get_ipc_id("/proc/sysvipc/sem",sem_key)) < 0 )
    {
        //semget 新建一个信号灯,其标号返回到sem_id
        if((sem_id = semget(sem_key,1,sem_flg)) < 0)
        {
            perror("semaphore create error");
            exit(EXIT_FAILURE);
        }
        //设置信号灯的初值
        sem_arg.val = sem_val;
        if(semctl(sem_id,0,SETVAL,sem_arg) <0)
        {
            perror("semaphore set error");
            exit(EXIT_FAILURE);
        }
    }
    return sem_id;
}
/*
* set_shm 函数建立一个具有n 个字节的共享内存区
* 如果建立成功，返回一个指向该内存区首地址的指针shm_buf
* 输入参数：
* shm_key 共享内存的键值
* shm_val 共享内存字节的长度
* shm_flag 共享内存的存取权限
*/
/*实现过程:创建共享内存->映射到进程的指针并返回*/
char * set_shm(key_t shm_key,int shm_num,int shm_flg)
{
    int i,shm_id;
    char * shm_buf;
    //测试由shm_key 标识的共享内存区是否已经建立
    if((shm_id = get_ipc_id("/proc/sysvipc/shm",shm_key)) < 0 )
    {
        //shmget 新建一个长度为shm_num 字节的共享内存,其标号返回到shm_id
        if((shm_id = shmget(shm_key,shm_num,shm_flg)) <0)
        {
            perror("shareMemory set error");
            exit(EXIT_FAILURE);
        }
        //shmat 将由shm_id 标识的共享内存附加给指针shm_buf
        if((shm_buf = (char *)shmat(shm_id,0,0)) < (char *)0)
        {
            perror("get shareMemory error");
            exit(EXIT_FAILURE);
        }
        /*共享内存区初始化*/
        for(i=0; i<shm_num; i++)
            shm_buf[i] = 0; //初始为0
    }
    //shm_key 标识的共享内存区已经建立,将由shm_id 标识的共享内存附加给指针shm_buf
    if((shm_buf = (char *)shmat(shm_id,0,0)) < (char *)0)
    {
        perror("get shareMemory error");
        exit(EXIT_FAILURE);
    }
    return shm_buf;
}
/*
* set_msq 函数建立一个消息队列
* 如果建立成功，返回一个消息队列的标识符msq_id
* 输入参数：
* msq_key 消息队列的键值
* msq_flag 消息队列的存取权限
*/
/*实现过程:创建消息队列->返回ID*/
int set_msq(key_t msq_key,int msq_flg)
{
    int msq_id;
    //测试由msq_key 标识的消息队列是否已经建立
    if((msq_id = get_ipc_id("/proc/sysvipc/msg",msq_key)) < 0 )
    {
        //msgget 新建一个消息队列,其标号返回到msq_id
        if((msq_id = msgget(msq_key,msq_flg)) < 0)
        {
            perror("messageQueue set error");
            exit(EXIT_FAILURE);
        }
    }
    return msq_id;
}

5.生产者程序实现：

首先建立（已存在时为打开）一系列的信号量和共享内存，接着就按照操作原语去实现了，代码如下：

/*Filename : producer.c*/
#include "ipc.h"
int main(int argc,char *argv[])
{
    int rate;
    //可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度
    if(argv[1] != NULL)
        rate = atoi(argv[1]);
    else
        rate = 3; //不指定为3 秒
    //共享内存使用的变量,其中键值任给,但是注意键值的
    //唯一性,在另外的文件中要用同一共享内存也要采用统一键值
    buff_key = 101;//缓冲区任给的键值
    buff_num = 8;//缓冲区任给的长度
    pput_key = 102;//生产者放产品指针的键值
    pput_num = 1; //指针数
    shm_flg = IPC_CREAT | 0644;//共享内存读写权限
    //获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址
    buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);
    //获取生产者放产品位置指针pput_ptr
    pput_ptr = (int *)set_shm(pput_key,pput_num,shm_flg);
    //信号量使用的变量
    prod_key = 201;//生产者同步信号灯键值
    mtx_key = 202;//互斥信号灯键值
    cons_key = 301;//消费者同步信号灯键值
    sem_flg = IPC_CREAT | 0644;
    //生产者同步信号灯初值设为缓冲区最大可用量
    sem_val = buff_num;
    //获取生产者同步信号灯，引用标识存prod_sem
    prod_sem = set_sem(prod_key,sem_val,sem_flg);
    //消费者初始无产品可取，同步信号灯初值设为0
    sem_val = 0;
    //获取消费者同步信号灯，引用标识存cons_sem
    cons_sem = set_sem(cons_key,sem_val,sem_flg);
    //生产者互斥信号灯初值为1
    sem_val = 1;
    //获取互斥信号灯，引用标识存mtx_sem
    mtx_sem = set_sem(mtx_key,sem_val,sem_flg);
    //循环执行模拟生产者不断放产品
    while(1)
    {
        //如果缓冲区满则生产者阻塞
        P_operation(prod_sem);
        //如果有进程进入，本生产者阻塞
        P_operation(mtx_sem);
        //用写一字符的形式模拟生产者放产品，报告本进程号和放入的字符及存放的位置
        buff_ptr[*pput_ptr] = 'A'+ *pput_ptr;
        //挂起rate秒
        sleep(rate);
        printf("%d producer put: %c to Buffer[%d]/n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
        //存放位置循环下移
        *pput_ptr = (*pput_ptr+1) % buff_num;
        //唤醒阻塞的进程
        V_operation(mtx_sem);
        //唤醒阻塞的消费者
        V_operation(cons_sem);
    }
    return EXIT_SUCCESS;
}

6.消费者程序实现

如同生产者上述，代码如下：

/* consumer.c*/
#include "ipc.h"
int main(int argc,char *argv[])
{
    int rate;
    //可在在命令行第一参数指定一个进程睡眠秒数，以调解进程执行速度
    if(argv[1] != NULL)
        rate = atoi(argv[1]);
    else
        rate = 3; //不指定为3 秒
    //共享内存使用的变量
    buff_key = 101; //缓冲区任给的键值
    buff_num = 8; //缓冲区任给的长度
    cget_key = 103; //消费者取产品指针的键值
    cget_num = 1; //指针数
    shm_flg = IPC_CREAT | 0644; //共享内存读写权限
    //获取缓冲区使用的共享内存，buff_ptr 指向缓冲区首地址
    buff_ptr = (char *)set_shm(buff_key,buff_num,shm_flg);
    //获取消费者取产品指针，cget_ptr 指向索引地址
    cget_ptr = (int *)set_shm(cget_key,cget_num,shm_flg);
    //信号量使用的变量
    prod_key = 201; //生产者同步信号灯键值
    mtx_key = 202; //互斥信号灯键值
    cons_key = 301; //消费者同步信号灯键值
    sem_flg = IPC_CREAT | 0644; //信号灯操作权限
    //生产者同步信号灯初值设为缓冲区最大可用量
    sem_val = buff_num;
    //获取生产者同步信号灯，引用标识存prod_sem
    prod_sem = set_sem(prod_key,sem_val,sem_flg);
    //消费者初始无产品可取，同步信号灯初值设为0
    sem_val = 0;
    //获取消费者同步信号灯，引用标识存cons_sem
    cons_sem = set_sem(cons_key,sem_val,sem_flg);
    //消费者互斥信号灯初值为1
    sem_val = 1;
    //获取互斥信号灯，引用标识存mtx_sem
    mtx_sem = set_sem(mtx_key,sem_val,sem_flg);
    //循环执行模拟消费者不断取产品
    while(1){
        //如果无产品消费者阻塞
        P_operation(cons_sem);
        //如果有进程进入,本消费者阻塞
        P_operation(mtx_sem);
        //用读一字符的形式模拟消费者取产品，报告本进程号和获取的字符及读取的位置
        sleep(rate);
        printf("%d consumer get: %c fromBuffer[%d]/n",getpid(),buff_ptr[*cget_ptr],*cget_ptr);
        //读取位置循环下移
        *cget_ptr = (*cget_ptr+1) % buff_num;
        //唤醒阻塞的进程
        V_operation(mtx_sem);
        //唤醒阻塞的生产者
        V_operation(prod_sem);
    }
    return EXIT_SUCCESS;
}

7.编写Makefile

由于本项目工程有多个文件，所以需要Makefile来方便编译

hdrs = ipc.h
opts = -g -c
c_src = consumer.c ipc.c
c_obj = consumer.o ipc.o
p_src = producer.c ipc.c
p_obj = producer.o ipc.o
all: producer consumer
consumer: $(c_obj)
    gcc $(c_obj) -o consumer
consumer.o: $(c_src) $(hdrs)
    gcc $(opts) $(c_src)
producer: $(p_obj)
    gcc $(p_obj) -o producer
producer.o: $(p_src) $(hdrs)
    gcc $(opts) $(p_src)
clean:
    rm consumer producer *.o

8.编译：

$ make

运行时打开多个终端窗口，输入

$./producer 1

另一个窗口输入：

$./consumer 1

.......

这时可以看到同步过程