操作系统进程通信编程，pv操作

[sheva999]

系统管理实践与进程控制、进程通信实现
进程通信题目：若零件A的最大库容量为m，零件B的最大库容量为n，当A和B的产量差超过k时，暂停对数量大的零件的生产而补充生产数量少的零件。用p，v操作实现进程的同步。 m=4,n=3,k=2

[帅得不敢出门]

生产A B可否同步？

[xuruichen]

长长见识，顶顶楼主。

[xiaoyisnail]

这里有个例子，可以看看：
http://blog.csdn.net/yexianyi/archive/2008/11/19/3336741.aspxhttp://blog.csdn.net/yexianyi/archive/2008/11/19/3336741.aspx
相关资料：
http://download.csdn.net/sort/tag/PV%E6%93%8D%E4%BD%9C

[太乙]

呵呵~~其实pv操作和信号量比较像，lz可以看看用pv怎么实现生产者消费者，然后看看这题就 简单些~~

[tianjiao85]

先看下操作系统，偶不会。

[waizqfor]

//信号量与PV操作的一个例子，模拟借书还书操作，共4个用户，每用户最多借15本书，书库共40本书，在书库没书时，该用户处于睡眠等待状态，直到有其他用户还书，若所有用户均处于等待状态，则产生了死锁

int Semget(key_t semkey,int nsems,int semflgs);
bool P(int sid,int semnum,int n);
bool V(int sid,int semnum,int n);
void sig_usr1(int);
static int pid[4];
int main(int argc,char **argv)
{
    int semid;
    if((semid=Semget(4446,1,IPC_CREAT|IPC_EXCL|0666))==-1)exit(-1);
    if(semctl(semid,0,SETVAL,40)==-1)perr_exit("semctl");   //书的总量

    int book,sleeptime;
    int borrow;
    for(int i=0;i<4;i++){      //4个用户
        pid[i]=fork();
        if(pid[i]<0){perror("Fork");i--;}
        else if(pid[i]==0){
            srand(time(NULL)+i);
            book=0;
            while(1){
                sleeptime=rand()%7;
                borrow=sleeptime-3;   //每次最多借还3本
                if(borrow>0&&borrow+book<=15)   //每人最多借15本
                {
                    if(!P(semid,0,borrow))
                        continue;
                    book+=borrow;
                    cout<<"User "<<i<<" borrow "<<borrow<<" books from libary,"
                        <<"now it remains ";
                    
                    cout<<semctl(semid,0,GETVAL,0)<<" books\n";
                    sleep(sleeptime);
                }
                else if(borrow<0&&borrow+book>=0)
                {
                    if(!V(semid,0,-borrow))continue;
                    book+=borrow;
                    cout<<"User "<<i<<" gives "<<-borrow<<" books back to libary,"
                        <<"now it remains ";   //由于V与GETVAL并不是原子操作，此处可能打印错误
                                                //有可能在归还与取值之间，书被借出
                    
                    cout<<semctl(semid,0,GETVAL,0)<<" books\n";
                    
                    sleep(sleeptime);
                }
            }
            return 0;
        }
    }
    signal(SIGUSR1,sig_usr1);
    while(1)usleep(1000);
    return 0;
}

int Semget(key_t semkey,int nsems,int semflgs)
{
    int semid;
    if ((semid = semget(semkey, 0, 0)) == -1) {  /* Semaphore does not exist - Create. */
        if ((semid = semget(semkey,nsems,semflgs)) != -1)
            return semid;
        else if (errno == EEXIST) {
            if((semid = semget(semkey, 0, 0)) == -1) {
                perror("IPC error 1: semget"); return -1;
            }
        }
        else {
            perror("IPC error 2: semget"); return -1;
        }
    }
    return semid;
}

void sig_usr1(int sig)
{
    for(int i=0;i<4;i++)
        kill(pid[i],SIGQUIT);
    kill(getpid(),SIGQUIT);
}

bool Semset(int sid,int semnum,int n)
{
    struct sembuf sm;
    sm.sem_num=semnum;
    sm.sem_op=n;
    sm.sem_flg=SEM_UNDO;
    if(semop(sid,&sm,1)==-1){
        perror ("semop");
        return false;
    }
    return true;
}

bool P(int sid,int semnum,int n)
{
    return Semset(sid,semnum,-n);
}

bool V(int sid,int semnum,int n)
{
    return Semset(sid,semnum,n);
}

LZ问题没明白 先看看代码吧 不懂得话 就看看PV操作原理

[roadblossom]

up

[wiowei]

[Quote=引用楼主 sheva999 的帖子:]
系统管理实践与进程控制、进程通信实现
进程通信题目：若零件A的最大库容量为m，零件B的最大库容量为n，当A和B的产量差超过k时，暂停对数量大的零件的生产而补充生产数量少的零件。用p，v操作实现进程的同步。 m=4,n=3,k=2
[/Quote]
你这题目有点不太清楚，两个进程制造A和B？没有共享资源？

A和B的制造有个同步是产量差，可以用pv实现：
设Sab用来控制A产量-B产量，Sba用来控制B产量-A产量
初始Sab = k,Sba = k
A制造：执行V(Sab),P(Sba),然后制造一个零件A
B制造：执行P(Sab),V(Sba),然后制造一个零件B

至于最大库容量，从题目看不出A和B有何关系，不需要pv操作，难不成凑上去：
信号量Sa初始为零件A最大数量，Sb初始为零件B最大数量，A：P(Sa)，B: P(Sb)？

[sheva999]

/*主控制程序*/

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>
#include <string.h>
#define SHMKEYA 9070 /*零件A的共享存储区的键*/
#define SHMKEYB 9074 /*零件B的共享存储区的键*/
#define SEMKEY_PRODUCERA 9084 /*零件A的生产者键值*/
#define SEMKEY_PRODUCERB 9085 /*零件B的生产者键值*/
#define SEMKEY_CONSUMERA 9086 /*零件A的消费者键值*/
#define SEMKEY_CONSUMERB 9087 /*零件B的消费者键值*/
#define SEMKEY_A 9088 /*零件A产量差值的键*//*注意:上面的键在系统中必须唯一*/
#define SEMKEY_B 9089 /*零件B产量差值的键*//*注意:上面的键在系统中必须唯一*/

#define BUFF_LENA 4 /*零件A的缓冲区可以存放4个产品*/
#define BUFF_LENB 3 /*零件B的缓冲区可以存放3个产品*/

#define PRODUCT_LEN 32 /*每个产品是一个字符串:<=32字符*/

void set_sembuf_struct(struct sembuf *sem,int semnum, int semop,int semflg)
{
/* 设置信号量结构 */
sem->sem_num=semnum;
sem->sem_op=semop;
sem->sem_flg=semflg;
}

main()
{
char *addra;
char *addrb, end; /*存放零件A、B的缓冲区*/
int shmida,shmidb;
int semid_producera, semid_consumera, semid_a;/*零件A信号量id*/
int semid_producerb, semid_consumerb, semid_b;/*零件B信号量id*/
struct sembuf sem_tmp;

/*开辟零件A共享存储区*/
if (((shmida = shmget(SHMKEYA, BUFF_LENA* PRODUCT_LEN+2, 0777|IPC_CREAT|IPC_EXCL)) == -1)| ((shmidb = shmget(SHMKEYB, BUFF_LENB* PRODUCT_LEN+2, 0777|IPC_CREAT|IPC_EXCL))) == -1)
{
if (errno == EEXIST)
{
printf("The Buffer A or B Has Existed!\n");
printf("Do You Want To Delete The Buffer (Y = yes)?\n====:");
scanf("%c", &end);
if(end == 'y' || end == 'Y')
{
/* 共享存储区、信号量并不随程序的结束而被删除,如果我们没删除的话，
可以用ipcs命令查看,用ipcrm删除 */
/*释放缓冲区*/
shmida = shmget(SHMKEYA, BUFF_LENA * PRODUCT_LEN+2, 0777);
if (shmctl(shmida,IPC_RMID,0) < 0)
perror("shmctl:");
shmidb = shmget(SHMKEYB, BUFF_LENB * PRODUCT_LEN+2, 0777);
if (shmctl(shmidb,IPC_RMID,0) < 0)
perror("shmctl:");

/*同时释放A信号量*/
semid_a = semget(SEMKEY_A,1, 0777);
semid_producera = semget(SEMKEY_PRODUCERA,1, 0777);
semid_consumera = semget(SEMKEY_CONSUMERA,1, 0777);
semctl(semid_a,0,IPC_RMID);
semctl(semid_producera,0,IPC_RMID);
semctl(semid_consumera,0,IPC_RMID); /*同时释放B信号量*/
semid_b = semget(SEMKEY_B,1, 0777);
semid_producerb = semget(SEMKEY_PRODUCERB,1, 0777);
semid_consumerb = semget(SEMKEY_CONSUMERB,1, 0777);
semctl(semid_b,0,IPC_RMID);
semctl(semid_producerb,0,IPC_RMID);
semctl(semid_consumerb,0,IPC_RMID);
}
}
else
printf("Fail To Create BufferA!\n");
return -1;
}

addra = (char*)shmat(shmida, 0, 0);/*连接缓冲区*/
memset(addra, 0, BUFF_LENA * PRODUCT_LEN+2);
shmdt(addra); /*离开缓零件A的冲区*/


addrb = (char*)shmat(shmidb, 0, 0);/*连接缓冲区*/
memset(addrb, 0, BUFF_LENB * PRODUCT_LEN+2);
shmdt(addrb); /*离开缓零件A的冲区*/

/*创建6个信号量:4个用于生产者、消费者同步，2个用于零件A和B之间差值的协调*/
if((semid_a = semget(SEMKEY_A,1, 0777|IPC_CREAT|IPC_EXCL))==-1)
{
if (errno == EEXIST)
printf("The SEMKEY_A Has Existed!\n");
else
printf("Fail To Create SEMKEY_A!\n");
return -1;
}

if((semid_consumera = semget(SEMKEY_CONSUMERA,1, 0777|IPC_CREAT|IPC_EXCL))==-1)
{
if (errno == EEXIST)
printf("The SEMKEY_CONSUMERA Has Existed!\n");
else
printf("Fail To Create SEMKEY_CONSUMERA!\n");
return -1;
}

if((semid_producera = semget(SEMKEY_PRODUCERA,1, 0777|IPC_CREAT|IPC_EXCL))==-1)
{
if (errno == EEXIST)
printf("The SEMKEY_PRODUCERA Has Existed!\n");
else
printf("Fail To Create SEMKEY_PRODUCERA!\n");
return -1;
}
if((semid_b = semget(SEMKEY_B,1, 0777|IPC_CREAT|IPC_EXCL))==-1)
{
if (errno == EEXIST)
printf("The SEMKEY_B Has Existed!\n");
else
printf("Fail To Create SEMKEY_B!\n");
return -1;
}

if((semid_consumerb = semget(SEMKEY_CONSUMERB,1, 0777|IPC_CREAT|IPC_EXCL))==-1)
{
if (errno == EEXIST)
printf("The SEMKEY_CONSUMERB Has Existed!\n");
else
printf("Fail To Create SEMKEY_CONSUMERB!\n");
return -1;
}

if((semid_producerb = semget(SEMKEY_PRODUCERB,1, 0777|IPC_CREAT|IPC_EXCL))==-1)
{
if (errno == EEXIST)
printf("The SEMKEY_PRODUCERB Has Existed!\n");
else
printf("Fail To Create SEMKEY_PRODUCERB!\n");
return -1;
}
/*给信号量赋初值*/
set_sembuf_struct(&sem_tmp, 0, BUFF_LENA, 0);/*BUFF_LENA，m=4*/
semop(semid_producera, &sem_tmp,1);

set_sembuf_struct(&sem_tmp, 0, 0, 0);/*0*/
semop(semid_consumera, &sem_tmp,1);

set_sembuf_struct(&sem_tmp, 0, 2, 0);/*k=2*/
semop(semid_a, &sem_tmp,1);

set_sembuf_struct(&sem_tmp, 0, BUFF_LENB, 0);/*BUFF_LENA，n=3*/
semop(semid_producerb, &sem_tmp,1);

set_sembuf_struct(&sem_tmp, 0, 0, 0);/*0*/
semop(semid_consumerb, &sem_tmp,1);

set_sembuf_struct(&sem_tmp, 0, 2, 0);/*k=2*/
semop(semid_b, &sem_tmp,1);

return 0;
}

[sheva999]

/*对仓库A的存入*/
/*生产者:producer.c*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>
#include <string.h>
#define SHMKEYA 9070 /*零件A的共享存储区的键*/
#define SHMKEYB 9074 /*零件B的共享存储区的键*/
#define SEMKEY_PRODUCERA 9084 /*零件A的生产者键值*/
#define SEMKEY_PRODUCERB 9085 /*零件B的生产者键值*/
#define SEMKEY_CONSUMERA 9086 /*零件A的消费者键值*/
#define SEMKEY_CONSUMERB 9087 /*零件B的消费者键值*/
#define SEMKEY_A 9088 /*零件A产量差值的键*//*注意:上面的键在系统中必须唯一*/
#define SEMKEY_B 9089 /*零件B产量差值的键*//*注意:上面的键在系统中必须唯一*/

#define BUFF_LENA 4 /*零件A的缓冲区可以存放4个产品*/
#define BUFF_LENB 3 /*零件B的缓冲区可以存放3个产品*/

#define PRODUCT_LEN 32 /*每个产品是一个字符串:<=32字符*/
/*下面的P,V是对系统调用的简单封装*/
int P(int semid)
{
struct sembuf p_buf;
p_buf.sem_num = 0;
p_buf.sem_op = -1;
p_buf.sem_flg = 0;
if(semop(semid, &p_buf, 1)==-1)/*semop参见课件ppt*/
{
perror ("p (semid) falsed");
exit (1);
}
else
return (0);
}

int V(int semid)
{
struct sembuf v_buf;/*struct sembuf 参见课件ppt*/
v_buf.sem_num = 0;
v_buf.sem_op = 1;
v_buf.sem_flg = 0;
if(semop(semid, &v_buf, 1)==-1)
{
perror (" v (semid) failed");
exit (1);
}
else
return (0);
}

main()
{
char *p_buffera;/*零件A的共享存储区地址*/
unsigned char in;/*生产者存放产品的指针:它的值存放在零件A的全局缓冲区第一个字节*/
char product[128];/*事实只使用32B,128为了避免屏幕输入超过32*/
int shmida;/*零件A共享存储区id*/
int semid_producera, semid_consumera, semid_a,semid_b;/*信号量集合id*/

shmida = shmget(SHMKEYA, BUFF_LENA * PRODUCT_LEN+2, 0777);/*连接共享存储区:2 存放in,out的值*/
p_buffera = (char*)shmat(shmida, 0, 0);/*取共享存储区地址*/

semid_a = semget(SEMKEY_A,1, 0777);/*获取全局信号量id*/
semid_b = semget(SEMKEY_B,1, 0777);
semid_producera = semget(SEMKEY_PRODUCERA,1, 0777);
semid_consumera = semget(SEMKEY_CONSUMERA,1, 0777);

/*从屏幕接收产品*/
printf("A:::::::::Please Product(a string ,length <= 32B):\n====:");
gets(product);/*128的意义在此,此函数不检查字符串长度*/

/*进入临界区*/
P(semid_producera);/*对私有信号量作P操作,判断零件A的仓库是否满*/
P(semid_a);/*判断A与B产量之差是否超过限值*/
in = (unsigned char)(*p_buffera);
strncpy(p_buffera + 2 + in * PRODUCT_LEN, product, PRODUCT_LEN);
in = (in + 1) % BUFF_LENA;
*p_buffera = (char)in;
shmdt(p_buffera); /*离开缓冲区*/

/*离开临界区*/
V(semid_b);
V(semid_consumera);

}
/*对仓库a的消费*/
/*消费者:consumer.c*/
/*#include "stdafx.h"*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>
#include <string.h>
#define SHMKEYA 9070 /*零件A的共享存储区的键*/
#define SHMKEYB 9074 /*零件B的共享存储区的键*/
#define SEMKEY_PRODUCERA 9084 /*零件A的生产者键值*/
#define SEMKEY_PRODUCERB 9085 /*零件B的生产者键值*/
#define SEMKEY_CONSUMERA 9086 /*零件A的消费者键值*/
#define SEMKEY_CONSUMERB 9087 /*零件B的消费者键值*/
#define SEMKEY_A 9088 /*零件A产量差值的键*//*注意:上面的键在系统中必须唯一*/
#define SEMKEY_B 9089 /*零件B产量差值的键*//*注意:上面的键在系统中必须唯一*/
#define BUFF_LENA 4 /*零件A的缓冲区可以存放4个产品*/
#define BUFF_LENB 3 /*零件B的缓冲区可以存放3个产品*/
#define PRODUCT_LEN 32 /*每个产品是一个字符串:<=32字符*/

/*下面的P,V是对系统调用的简单封装*/
int P(int semid)
{
struct sembuf p_buf;/*struct sembuf 参见课件ppt*/
p_buf.sem_num = 0;
p_buf.sem_op = -1;
p_buf.sem_flg = 0;
if(semop(semid, &p_buf, 1)==-1)/*semop参见课件ppt*/
{
perror ("p (semid) falsed");
exit (1);
}
else
return (0);
}

int V(int semid)
{
struct sembuf v_buf;
v_buf.sem_num = 0;
v_buf.sem_op = 1;
v_buf.sem_flg = 0;
if(semop(semid, &v_buf, 1)==-1)
{
perror (" v (semid) failed");
exit (1);
}
else
return (0);
}


main()
{
char *p_buffera;/*共享存储区地址*/
unsigned char out;/*消费者取出产品的指针:它的值存放在零件A的全局缓冲区第二个字节*/
char product[33];/*它的数据从缓冲区中取*/
int shmida;/*零件A的共享存储区id*/
int semid_producera, semid_consumera;/*信号量集合id*/

shmida = shmget(SHMKEYA, BUFF_LENA * PRODUCT_LEN+2, 0777);/*连接共享存储区:2 存放in,out的值*/
p_buffera = (char*)shmat(shmida, 0, 0);/*取共享存储区地址*/


semid_producera = semget(SEMKEY_PRODUCERA,1, 0777);
semid_consumera = semget(SEMKEY_CONSUMERA,1, 0777);

/*进入临界区*/
P(semid_consumera);/*对私有信号量作P操作,判断是否有产品可以取*/

p_buffera++;

out = (unsigned char)(*p_buffera);
strcpy(product, p_buffera + 1 + out * PRODUCT_LEN);
out = (out + 1) % BUFF_LENA;
*p_buffera = (char)out;
p_buffera--;
shmdt(p_buffera); /*离开缓冲区*/

/*离开临界区*/
V(semid_producera);


/*消费产品:在屏幕上输出*/
printf("A::::::::Consume a Product:\n");
printf("====:%s\n", product);
}

[sheva999]

/*对仓库b的存入*/
/*生产者:producerb.c*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>
#include <string.h>
#define SHMKEYA 9070 /*零件A的共享存储区的键*/
#define SHMKEYB 9074 /*零件B的共享存储区的键*/
#define SEMKEY_PRODUCERA 9084 /*零件A的生产者键值*/
#define SEMKEY_PRODUCERB 9085 /*零件B的生产者键值*/
#define SEMKEY_CONSUMERA 9086 /*零件A的消费者键值*/
#define SEMKEY_CONSUMERB 9087 /*零件B的消费者键值*/
#define SEMKEY_A 9088 /*零件A产量差值的键*//*注意:上面的键在系统中必须唯一*/
#define SEMKEY_B 9089 /*零件B产量差值的键*//*注意:上面的键在系统中必须唯一*/

#define BUFF_LENA 4 /*零件A的缓冲区可以存放4个产品*/
#define BUFF_LENB 3 /*零件B的缓冲区可以存放3个产品*/

#define PRODUCT_LEN 32 /*每个产品是一个字符串:<=32字符*/
/*下面的P,V是对系统调用的简单封装*/
int P(int semid)
{
struct sembuf p_buf;
p_buf.sem_num = 0;
p_buf.sem_op = -1;
p_buf.sem_flg = 0;
if(semop(semid, &p_buf, 1)==-1)/*semop参见课件ppt*/
{
perror ("p (semid) falsed");
exit (1);
}
else
return (0);
}

int V(int semid)
{
struct sembuf v_buf;/*struct sembuf 参见课件ppt*/
v_buf.sem_num = 0;
v_buf.sem_op = 1;
v_buf.sem_flg = 0;
if(semop(semid, &v_buf, 1)==-1)
{
perror (" v (semid) failed");
exit (1);
}
else
return (0);
}

main()
{
char *p_bufferb;/*零件A的共享存储区地址*/
unsigned char in;/*生产者存放产品的指针:它的值存放在零件A的全局缓冲区第一个字节*/
char product[128];/*事实只使用32B,128为了避免屏幕输入超过32*/
int shmidb;/*零件A共享存储区id*/
int semid_producerb, semid_consumerb, semid_b,semid_a;/*信号量集合id*/

shmidb = shmget(SHMKEYB, BUFF_LENB * PRODUCT_LEN+2, 0777);/*连接共享存储区:2 存放in,out的值*/
p_bufferb = (char*)shmat(shmidb, 0, 0);/*取共享存储区地址*/

semid_b = semget(SEMKEY_B,1, 0777);/*获取全局信号量id*/
semid_a = semget(SEMKEY_A,1, 0777);
semid_producerb = semget(SEMKEY_PRODUCERB,1, 0777);
semid_consumerb = semget(SEMKEY_CONSUMERB,1, 0777);

/*从屏幕接收产品*/
printf("B:::::::::Please Product(a string ,length <= 32B):\n====:");
gets(product);/*128的意义在此,此函数不检查字符串长度*/

/*进入临界区*/
P(semid_producerb);/*对私有信号量作P操作,判断零件B的仓库是否满*/
P(semid_b);/*判断A与B产量之差是否超过限值*/
in = (unsigned char)(*p_bufferb);
strncpy(p_bufferb + 2 + in * PRODUCT_LEN, product, PRODUCT_LEN);
in = (in + 1) % BUFF_LENB;
*p_bufferb = (char)in;
shmdt(p_bufferb); /*离开缓冲区*/

/*离开临界区*/
V(semid_a);
V(semid_consumerb);

}
/*对仓库b的消费*/
/*消费者:consumerb.c*/
/*#include "stdafx.h"*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>
#include <string.h>
#define SHMKEYA 9070 /*零件A的共享存储区的键*/
#define SHMKEYB 9074 /*零件B的共享存储区的键*/
#define SEMKEY_PRODUCERA 9084 /*零件A的生产者键值*/
#define SEMKEY_PRODUCERB 9085 /*零件B的生产者键值*/
#define SEMKEY_CONSUMERA 9086 /*零件A的消费者键值*/
#define SEMKEY_CONSUMERB 9087 /*零件B的消费者键值*/
#define SEMKEY_A 9088 /*零件A产量差值的键*//*注意:上面的键在系统中必须唯一*/
#define SEMKEY_B 9089 /*零件B产量差值的键*//*注意:上面的键在系统中必须唯一*/
#define BUFF_LENA 4 /*零件A的缓冲区可以存放4个产品*/
#define BUFF_LENB 3 /*零件B的缓冲区可以存放3个产品*/
#define PRODUCT_LEN 32 /*每个产品是一个字符串:<=32字符*/

/*下面的P,V是对系统调用的简单封装*/
int P(int semid)
{
struct sembuf p_buf;/*struct sembuf 参见课件ppt*/
p_buf.sem_num = 0;
p_buf.sem_op = -1;
p_buf.sem_flg = 0;
if(semop(semid, &p_buf, 1)==-1)/*semop参见课件ppt*/
{
perror ("p (semid) falsed");
exit (1);
}
else
return (0);
}

int V(int semid)
{
struct sembuf v_buf;
v_buf.sem_num = 0;
v_buf.sem_op = 1;
v_buf.sem_flg = 0;
if(semop(semid, &v_buf, 1)==-1)
{
perror (" v (semid) failed");
exit (1);
}
else
return (0);
}


main()
{
char *p_bufferb;/*共享存储区地址*/
unsigned char out;/*消费者取出产品的指针:它的值存放在零件A的全局缓冲区第二个字节*/
char product[33];/*它的数据从缓冲区中取*/
int shmidb;/*零件B的共享存储区id*/
int semid_producerb, semid_consumerb;/*信号量集合id*/

shmidb = shmget(SHMKEYB, BUFF_LENB * PRODUCT_LEN+2, 0777);/*连接共享存储区:2 存放in,out的值*/
p_bufferb = (char*)shmat(shmidb, 0, 0);/*取共享存储区地址*/


semid_producerb = semget(SEMKEY_PRODUCERB,1, 0777);
semid_consumerb = semget(SEMKEY_CONSUMERB,1, 0777);

/*进入临界区*/
P(semid_consumerb);/*对私有信号量作P操作,判断是否有产品可以取*/

p_bufferb++;

out = (unsigned char)(*p_bufferb);
strcpy(product, p_bufferb + 1 + out * PRODUCT_LEN);
out = (out + 1) % BUFF_LENB;
*p_bufferb = (char)out;
p_bufferb--;
shmdt(p_bufferb); /*离开缓冲区*/

/*离开临界区*/
V(semid_producerb);


/*消费产品:在屏幕上输出*/
printf("B::::::::Consume a Product:\n");
printf("====:%s\n", product);
}

[ccnu_hslk324]

ding