进程间同步互斥经典问题(一)生产者-消费者问题

问题描述:


生产者-消费者问题,也叫做缓存绑定问题(bounded-buffer),是一个多进程同步问题。

  • 即有两个进程:制造少和消费者,共享一个固定大小的缓存
  • 制造商的工作是制造一段数据,放进缓存,如此重复。
  • 消费者一次消费一段数据,从缓存中取出。
  • 要保证不让制造商在缓存还是满的时候仍要向内写数据,不让消费者试图从空的缓存中取出数据。

问题分析:


  1. 要避免多个生产商竞争一个空位的情况。
  2. 要避免生产商和消费者同时睡觉,造成死锁
  3. 要避免多个消费者竞争同一段数据的情况

基本思路:


  • 首先我们需要定义三个信号量:
    • empty:用来表示空位的数量,初值为n(缓存区的规模)
    • full:用来表示剩余商品的数量,初值为0
    • mutex:用来表示互斥量,同一时间共享的内存只能由一个进程访问。
  • 首先考虑生产商,在多个生产商和多个消费者同时运行的情况下:
    • 1.检查共享内存是否满
      • 如果满,说明无法急需生产,那么睡觉。
      • 否则,p(empty),进程继续
    • 2.每一个生产商在执行操作前申请互斥锁
      • 如果被其他进程上锁,说明当前共享内存区域被其他进程使用,那么进入等待队列等待互斥锁被释放
      • 否则,对互斥锁上锁,进程继续
    • 3.生产一个新的商品放入空位,并且释放互斥锁,v(full)
  • 然后考虑消费者,在多个消费者和多个生产商同时存在的情况下:
    • 1.检查共享的内存中数据是否为空
      • 如果空,说明无法消费,那么睡觉
      • 否则,p(full),进程继续
    • 2.在执行操作前申请互斥锁
      • 如果被其他进程上锁,说明当前共享内存区域被其他进程使用,那么进入等待队列等待互斥锁被释放
      • 否则,对互斥锁上锁,进程继续
    • 3.消费一个商品,并且释放互斥锁,v(empty)

注释完整的实现方案(C语言)


  • init.c : 对共享内存的数据进行初始化和清理工作
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include "ipc.h"

int main ( int argc , char * argv[] )
{
    int i,producer_pid,consumer_pid,item,shmid;
    semaphore mutex,empty,full;//定义互斥量mutex,定义信号量empty,full;
    union semun sem_union;
    void* shared_memory = (void*)0;
    struct shared_use_st * shared_stuff;
    /*
        int semget ( key_t key , int num_sems , int sem_flags );
        1.第一个参数key是一个用来允许不相关的进程访问相同信号量的整数值,
        所有的信号量信号量是为不同的程序提供一个key来简介访问的,
        对于每一个信号量系统生成一个信号量标识符。符号量键值只可以由semget
        获得,所有其他的信号量函数所用的信号量标识符都是由semget所返回的。

        2.num_sems参数是所需要的信号量数目,这个值通常是1

        3.sem_flags参数是一个标记集合
        IPC_CREAT与IPC_EXCL的组合来保证我们可以的到一个新的唯一的信号量
        如果得不到会报错

        4.返回值如果是一个整数,这是用于其他信号量函数的标识符,
        如果失败,则会返回-1
    */
        if ( ( mutex = semget ( (key_t) KEY_MUTEX , 1 , 0666|IPC_CREAT)) == -1 )
        {
            fprintf ( stderr , "Failed to create semaphore!");
            exit(EXIT_FAILURE);
        }
        if (( empty = semget( (key_t) KEY_EMPTY , 1 , 0666|IPC_CREAT)) == -1 )
        {
            fprintf ( stderr , "Failed to create semaphore!");
            exit(EXIT_FAILURE);
        }
        if (( full = semget((key_t) KEY_FULL , 1 , 0666|IPC_CREAT)) == -1 )
        {
            fprintf ( stderr , "Failed to create semaphore!");
            exit(EXIT_FAILURE);
        }
        if ((shmid = shmget ((key_t)KEY_SHM,sizeof (struct shared_use_st),0666|IPC_CREAT))==-1)
        {
            fprintf ( stderr , "Failerd to create shared memory!");
            exit(EXIT_FAILURE);           
        }

        sem_union.val = 1;
        if ( semctl(mutex,0,SETVAL,sem_union) == -1 )
        {
            fprintf ( stderr , "Failed to set semaphore!");
            exit(EXIT_FAILURE);
        }

        sem_union.val = 0;
        if ( semctl(full,0,SETVAL,sem_union) == -1 )
        {
            fprintf ( stderr , "Failed to set semaphore!");
            exit(EXIT_FAILURE);
        }


        sem_union.val = BUFFER_SIZE;
        if ( semctl(empty, 0 , SETVAL , sem_union) == -1 )
        {
            fprintf ( stderr , "Failed to set semaphore!");
            exit(EXIT_FAILURE);
        }
        /*
            void* shmat ( int shmid , const void* shmaddr , int shmflg )
            链接共享内存标识符为shmid的共享内存,链接成功后把共享内存区对象
            映射到调用进程的地址空间,随后可像本地空间一样访问。
            shmid  共享内存标识符
            shmaddr 指定共享内存出现在进程内存地址的什么位置,直接指定为NULL让内核自己决定
            一个合适的地址位置.
            SHM_RDONLY 为只读模式,其他为读写模式
        */
        if (( shared_memory = shmat( shmid ,(void*)0 , 0)) == (void*)-1 )
        {
            fprintf ( stderr , "shmat failed\n");
            exit(EXIT_FAILURE);
        }

        shared_stuff = ( struct shared_use_st * ) shared_memory;

        for ( i = 0; i < BUFFER_SIZE ; i ++ )
        {
            shared_stuff->buffer[i] = 0;
        }
        shared_stuff->low = 0;
        shared_stuff->high = 0;
        shared_stuff->cur = 0;

        exit(EXIT_SUCCESS);
}

    /*
       int shmdt ( const void* shmaddr )
       与shmat相反,是用来断开与共享内存附加点的地址,进制本进程访问瓷片共享内存
       shmaddr:链接共享内存的起始地址
       成功返回0,除错返回-1
    */
  • producer.c: 生产商的进程代码
#include "ipc.h"


int main ( int argc , char * argv[] )
{
    int i,item,shmid;
    semaphore  mutex,empty,full;
    union semun sem_union;
    void* shared_memory = (void*)0;
    struct shared_use_st *shared_stuff;

    if ((mutex = semget((key_t)KEY_MUTEX,1,0666|IPC_CREAT)) == -1 )
    {
        fprintf ( stderr , "Failed to create semaphore!");
        exit(EXIT_FAILURE);
    }
    if ((empty = semget((key_t)KEY_EMPTY,1,0666|IPC_CREAT)) == -1 )
    {
        fprintf ( stderr , "Failed to create semaphore!");
        exit(EXIT_FAILURE);
    }
    if ((full = semget((key_t)KEY_FULL,1,0666|IPC_CREAT)) == -1 )
    {
        fprintf ( stderr , "Failed to create semaphore!");
        exit(EXIT_FAILURE);
    }
    if ((shmid=shmget((key_t)KEY_SHM,sizeof(struct shared_use_st),0666|IPC_CREAT)) == -1 )
    {
        fprintf ( stderr , "Failed to create semaphore!");
        exit(EXIT_FAILURE);
    }
    if ((shared_memory = shmat(shmid,(void*)0,0)) == (void*)-1)
    {
        fprintf ( stderr , "shmat failed\n");
        exit(EXIT_FAILURE);
    }
    shared_stuff = ( struct shared_use_st * ) shared_memory;
    for ( i = 0 ; i < 30 ; i++ )
    {
        item = ++(shared_stuff->cur);
        sleep(1);
        printf ( "Producing item %d\n" , item );
        sem_p ( empty );//减少一个空位
        sem_p ( mutex );//锁上互斥锁
        (shared_stuff->buffer)[(shared_stuff->high)] = item;
        (shared_stuff->high) = ((shared_stuff->high)+1) % BUFFER_SIZE;
        printf ( "Inserting item %d\n" , item );
        sem_v ( mutex );
        sem_v ( full );
    }

    if ( shmdt(shared_memory) == -1 )
    {
        fprintf ( stderr , "shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf ( "Finish!\n" );
    getchar();
    exit(EXIT_SUCCESS);
}
  • consumer.c: 消费者的进程代码
#include "ipc.h"

int main ( int argc , char* argv[] )
{
    int i,item,shmid;
    semaphore mutex,empty,full;
    void* shared_memory = ( void* ) 0;
    struct shared_use_st* shared_stuff;

    if ((mutex=semget((key_t)KEY_MUTEX,1,0666|IPC_CREAT)) == -1 )
    {
        fprintf (stderr , "Failed to create semaphore!");
        exit(EXIT_FAILURE);
    }
    if ((empty=semget((key_t)KEY_EMPTY,1,0666|IPC_CREAT)) == -1 )
    {
        fprintf (stderr , "Failed to create semaphore!");
        exit(EXIT_FAILURE);
    }
    if ((full=semget((key_t)KEY_FULL,1,0666|IPC_CREAT)) == -1 )
    {
        fprintf (stderr , "Failed to create semaphore!");
        exit(EXIT_FAILURE);
    }
    if ((shared_memory = shmat(shmid,(void*)0,0) ) ==(void*)-1 )
    {
        fprintf ( stderr , "shmat failed\n");
        exit(EXIT_FAILURE);
    }
    shared_stuff = (struct shared_use_st*)shared_memory;
    for(i=0;i<30;i++)
    {
        sem_p(full);
        sem_p(mutex);
        item = shared_stuff->buffer[shared_stuff->low];
        (shared_stuff->buffer)[(shared_stuff->low)]=0;
        shared_stuff->low = ((shared_stuff->low)+1)%BUFFER_SIZE;
        printf ( "Removing item %d\n" , item );
        sem_v(mutex);
        sem_v(empty);
        printf ( "Consuming item %d\n" ,item );
        sleep(2);
    }

    if ( shmdt(shared_memory) == -1 ) 
    {
        fprintf ( stderr , "shmat failed\n" );
        exit ( EXIT_FAILURE);
    }
    printf ( "Finish!\n" );
    getchar();
    exit(EXIT_SUCCESS);
}

  • 9
    点赞
  • 49
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
实验题目: 生产者消费者(综合性实验) 实验环境: C语言编译器 实验内容: ① 由用户指定要产生的进程及其类别,存入进入就绪队列。    ② 调度程序从就绪队列中提取一个就绪进程运行。如果申请的资源被阻塞则进入相应的等待队列,调度程序调度就绪队列中的下一个进程进程运行结束时,会检查对应的等待队列,激活队列中的进程进入就绪队列。运行结束的进程进入over链表。重复这一过程直至就绪队列为空。    ③ 程序询问是否要继续?如果要转直①开始执行,否则退出程序。 实验目的: 通过实验模拟生产者消费者的关系,了解并掌握他们之的关系及其原理。由此增加对进程同步问题的了解。 实验要求: 每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程类型标号、进程系统号、进程状态、进程产品(字符)、进程链指针等等。 系统开辟了一个缓冲区,大小由buffersize指定。 程序中有三个链队列,一个链表。一个就绪队列(ready),两个等待队列:生产者等待队列(producer);消费者队列(consumer)。一个链表(over),用于收集已经运行结束的进程 本程序通过函数模拟信号量的操作。 参考书目: 1)徐甲同等编,计算机操作系统教程,西安电子科技大学出版社 2)Andrew S. Tanenbaum著,陈向群,马红兵译. 现代操作系统(第2版). 机械工业出版社 3)Abranham Silberschatz, Peter Baer Galvin, Greg Gagne著. 郑扣根译. 操作系统概念(第2版). 高等教育出版社 4)张尧学编著. 计算机操作系统教程(第2版)习题解答与实验指导. 清华大学出版社 实验报告要求: (1) 每位同学交一份电子版本的实验报告,上传到202.204.125.21服务器中。 (2) 文件名格式为班级、学号加上个人姓名,例如: 电子04-1-040824101**.doc   表示电子04-1班学号为040824101号的**同学的实验报告。 (3) 实验报告内容的开始处要列出实验的目的,实验环境、实验内容等的说明,报告中要附上程序代码,并对实验过程进行说明。 基本数据结构: PCB* readyhead=NULL, * readytail=NULL; // 就绪队列 PCB* consumerhead=NULL, * consumertail=NULL; // 消费者队列 PCB* producerhead=NULL, * producertail=NULL; // 生产者队列 over=(PCB*)malloc(sizeof(PCB)); // over链表 int productnum=0; //产品数量 int full=0, empty=buffersize; // semaphore char buffer[buffersize]; // 缓冲区 int bufferpoint=0; // 缓冲区指针 struct pcb { /* 定义进程控制块PCB */ int flag; // flag=1 denote producer; flag=2 denote consumer; int numlabel; char product; char state; struct pcb * processlink; …… }; processproc( )--- 给PCB分配内存。产生相应的的进程:输入1为生产者进程;输入2为消费者进程,并把这些进程放入就绪队列中。 waitempty( )--- 如果缓冲区满,该进程进入生产者等待队列;linkqueue(exe,&producertail); // 把就绪队列里的进程放入生产者队列的尾部 void signalempty() bool waitfull() void signalfull() void producerrun() void comsuerrun() void main() { processproc(); element=hasElement(readyhead); while(element){ exe=getq(readyhead,&readytail); printf("进程%d申请运行,它是一个",exe->numlabel); exe->flag==1? printf("生产者\n"):printf("消费者\n"); if(exe->flag==1) producerrun();

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值