带fork和共享内存的POSIX in C信号量，

我正在尝试用信号量、fork和共享内存编写一个程序

父级假设创建共享内存并将数字插入缓冲区打印完成 然后，孩子将从共享内存中读取并打印数字的总和 程序运行，但只有父级打印完成，而子级不执行任何操作

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

#include <netinet/in.h>
#include <netdb.h> 

#include<netinet/in.h>
#include<netdb.h>
#include<sys/wait.h>
#include<unistd.h>

#include <sys/shm.h>




char buffer[10];
char *data; 
    int commNo =0;
    key_t key;
    int shmid;
    char *shrmem;
    int mode;

void error(char *msg)
{
    perror(msg);
    exit(0);
}
int rem[10];

key_t key; /* key to pass to semget() */ 
key_t key1; /* key to pass to semget() */ 
key_t key2; /* key to pass to semget() */ 
key_t key3; /* key to pass to semget() */ 
int semflg; /* semflg to pass tosemget() */ 
int nsems; /* nsems to pass to semget() */ 
int semid; /* return value from semget() */ 
#define   MAX_COUNT  200
#define  N  100      /* shared buffer of size 100 */

void  ChildProcess(void);                /* child process prototype  */
void  ParentProcess(void);               /* parent process prototype */




//things for ftok 
char *path = "/tmp";
int id = 'S';
//create sembuf

  //struct sembuf{
    //            ushort  sem_num;        /* semaphore index in array */
      //          short   sem_op;         /* semaphore operation */
        //        short   sem_flg;        /* operation flags */
        //};



int locksem = 1;     /* binary semaphore for  locking-unlocking: initiall  unlocked : 1 */
int emptysem = 100;  /* counting semaphore for  empty slots */
int fullsem = 0;      /* counting semaphore for  filled slots*/


 struct sembuf oplock;// = (struct sembuf *) malloc(2*sizeof(struct sembuf));
//static struct sembuf oplock;
//oplock.sem_num = 0;
//oplock.sem_op = -1;
//oplock.sem_flg = SEM_UNDO;

struct sembuf opunlock; // = (struct sembuf *) malloc(2*sizeof(struct sembuf));

//static struct sembuf opunlock;
//opunlock.sem_num = 0;
//opunlock.sem_op = 1;
//opunlock.sem_flg = SEM_UNDO;



void creatmemory(){



      /* make the key: */
    if ((key = ftok("/tmp",1)) == -1) {

        perror("ftok");
        //clientnumber
        exit(1);
    }
      /* connect to (and possibly create) the segment: */
    if ((shmid = shmget(key, 15, 0644| IPC_CREAT)) == -1) {

        perror("shmget");
        exit(1);
    }


     /* attach to the segment to get a pointer to it: */

    data = shmat(shmid, (void *)0, 0);

    if (data == (char *)(-1)) {

        perror("shmat");
        exit(1);
    }


}




int main(int argc, char *argv[]){
     pid_t pid;

     nsems = 1;


//static struct sembuf oplock;
oplock.sem_num = 0;
oplock.sem_op = -1;
oplock.sem_flg = SEM_UNDO;


//static struct sembuf opunlock;
opunlock.sem_num = 0;
opunlock.sem_op = 1;
opunlock.sem_flg = SEM_UNDO;


//to create new one
semflg = IPC_CREAT;


         /* Get unique key for semaphore. */
if ((key1 =  ftok(path,1)) == (key_t) -1) {
    perror("IPC error: ftok"); exit(1);
}
/* Get unique key for semaphore. */
if ((key2 =  ftok(path,2)) == (key_t) -1) {
    perror("IPC error: ftok"); exit(1);
}
/* Get unique key for semaphore. */
if ((key3 =  ftok(path,3)) == (key_t) -1) {
    perror("IPC error: ftok"); exit(1);
}


     pid = fork();
     if (pid == 0) {

     //***************************************************************************************************************



//
int n =0;
while(n < 3){

locksem = semget(key1, nsems, semflg);   /* open-create locksem*/
emptysem = semget(key2, nsems, semflg);
fullsem = semget(key3, nsems, semflg);
    semop(fullsem,&oplock,1);  /* check filled slots */
    semop(locksem,&oplock,1);      /* lock shared buffer*/
   // itx= remove_item(); 
   /* remove an item from buffer */
   int i;
   for (i =0; i<10; i++){
   rem[i] = data[i];}
   bzero(buffer,10);
   bzero(data,strlen(data));
    /* detach from the segment: */
    if (shmdt(data) == -1) {
        perror("shmdt");
        exit(1);
    }
    semop(locksem,&opunlock,1);  /* unlock the buffer */
    semop(emptysem,&opunlock,1);  /* increment emptysem*/
    //consume_item(itx);
    int sum = 0;
for(i =0; i<10; i++){
sum += rem[i];}
printf("the sum is:%d \n", sum);
    n++;} 
    }

         //consumer();
     else 
     {

      creatmemory();
     int n =0;
while( n < 3) {  

locksem = semget(key1, nsems, semflg);   /* open-create locksem*/
emptysem = semget(key2, nsems, semflg);
fullsem = semget(key3, nsems, semflg);

bzero(buffer,10);
int i;
for(i =0; i<10; i++)
buffer[i] = i;

    semop(emptysem,&oplock,1);  /* check empty slots */
    semop(locksem,&oplock,1);      /* lock shared buffer*/
/* insert item into the buffer */

strncpy(data, buffer, strlen(buffer));  
printf("done \n");
    semop(locksem,&opunlock,1);  /* unlock the buffer */
    semop(fullsem,&opunlock,1);  /* increment fullsem*/

    sleep(10);      

     n++;}  
     }
         // producer();


}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
字符缓冲区[10]；
字符*数据；
int commNo=0；
钥匙(t)钥匙;；
int shmid；
char*shrmem；
int模式；
无效错误（字符*消息）
{
佩罗尔（味精）；
出口（0）；
}
int-rem[10]；
键\u t键；/*要传递给semget（）的键*/
键\u t键1；/*要传递给semget（）的键*/
键\u t键2；/*要传递给semget（）的键*/
键\u t键3；/*要传递给semget（）的键*/
int semflg；/*要传递给semget（）的semflg*/
int nsems；/*要传递给semget（）的nsems*/
int-semid；/*从semget（）返回值*/
#定义最大计数200
#定义大小为100的N 100/*共享缓冲区*/
无效子进程（无效）；/*子流程原型*/
无效父进程（无效）；/*父进程原型*/
//ftok的事情
char*path=“/tmp”；
int id='S'；
//创建sembuf
//结构sembuf{
//数组中的ushort sem_num；/*信号量索引*/
//短sem_op；/*信号量操作*/
//短sem_flg；/*操作标志*/
//};
int locksem=1；/*用于锁定解锁的二进制信号量：首字母“解锁”：1*/
int-emptysem=100；/*空插槽的计数信号量*/
int fullsem=0；/*已填充插槽的计数信号量*/
结构sembuf oplock；//=（结构sembuf*）malloc（2*sizeof（结构sembuf））；
//静态结构sembuf oplock；
//oplock.sem_num=0；
//oplock.sem_op=-1；
//oplock.sem_flg=sem_UNDO；
结构sembuf opunlock；//=（结构sembuf*）malloc（2*sizeof（结构sembuf））；
//静态结构sembuf opunlock；
//opunlock.sem_num=0；
//opunlock.sem_op=1；
//opunlock.sem_flg=sem_UNDO；
void创建内存（）{
/*制作密钥：*/
如果（（key=ftok（“/tmp”，1））=-1）{
佩罗尔（“ftok”）；
//客户号
出口（1）；
}
/*连接（并可能创建）段：*/
如果（（shmid=shmget（键，15，0644 | IPC_CREAT））=-1）{
佩罗尔（“shmget”）；
出口（1）；
}
/*附加到段以获取指向该段的指针：*/
数据=shmat（shmid，（void*）0,0；
如果（数据==（字符*）（-1））{
佩罗尔（“shmat”）；
出口（1）；
}
}
int main（int argc，char*argv[]）{
pid_t pid；
nsems=1；
//静态结构sembuf oplock；
oplock.sem_num=0；
oplock.sem_op=-1；
oplock.sem_flg=sem_UNDO；
//静态结构sembuf opunlock；
opunlock.sem_num=0；
opunlock.sem_op=1；
opunlock.sem_flg=sem_UNDO；
//创建新的
semflg=IPC_CREAT；
/*获取信号量的唯一密钥*/
如果（（键1=ftok（路径，1））==（键t）-1）{
perror（“IPC错误：ftok”）；退出（1）；
}
/*获取信号量的唯一密钥*/
如果（（键2=ftok（路径，2））==（键t）-1）{
perror（“IPC错误：ftok”）；退出（1）；
}
/*获取信号量的唯一密钥*/
如果（（键3=ftok（路径，3））==（键t）-1）{
perror（“IPC错误：ftok”）；退出（1）；
}
pid=fork（）；
如果（pid==0）{
//***************************************************************************************************************
//
int n=0；
而（n<3）{
locksem=semget（键1，nsems，semflg）；/*打开创建locksem*/
emptysem=semget（键2、nsems、semflg）；
fullsem=semget（键3、nsems、semflg）；
semop（完整SEM和oplock，1）；/*检查填充的插槽*/
semop（locksem和oplock，1）；/*锁共享缓冲区*/
//itx=移除_项（）；
/*从缓冲区中删除项目*/
int i；
对于（i=0；i，这里有一个版本的代码，它实际编译并干净地链接：

#define  _XOPEN_SOURCE (1) // needed by sys/ipc.h
#include <sys/types.h>

#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>

#include <stdlib.h> // exit()
#include <string.h>
#include <strings.h> // bzero())

#include <netinet/in.h>
#include <netdb.h>

#include <netinet/in.h>
#include <netdb.h>
#include <sys/wait.h>
#include <unistd.h>

#include <sys/shm.h>




char buffer[10];
char *data;
int commNo =0;
key_t key;
int shmid;
char *shrmem;
int mode;

void error(char *);


int rem[10];

key_t key; /* key to pass to semget() */
key_t key1; /* key to pass to semget() */
key_t key2; /* key to pass to semget() */
key_t key3; /* key to pass to semget() */
int semflg; /* semflg to pass tosemget() */
int nsems; /* nsems to pass to semget() */
int semid; /* return value from semget() */
#define   MAX_COUNT  200
#define  N  100      /* shared buffer of size 100 */

void creatmemory( void );




//things for ftok
char *path = "/tmp";
int id = 'S';
//create sembuf

  //struct sembuf{
    //            ushort  sem_num;        /* semaphore index in array */
      //          short   sem_op;         /* semaphore operation */
        //        short   sem_flg;        /* operation flags */
        //};



int locksem = 1;     /* binary semaphore for  locking-unlocking: initiall  unlocked : 1 */
int emptysem = 100;  /* counting semaphore for  empty slots */
int fullsem = 0;      /* counting semaphore for  filled slots*/


 struct sembuf oplock;// = (struct sembuf *) malloc(2*sizeof(struct sembuf));
//static struct sembuf oplock;
//oplock.sem_num = 0;
//oplock.sem_op = -1;
//oplock.sem_flg = SEM_UNDO;

struct sembuf opunlock; // = (struct sembuf *) malloc(2*sizeof(struct sembuf));

//static struct sembuf opunlock;
//opunlock.sem_num = 0;
//opunlock.sem_op = 1;
//opunlock.sem_flg = SEM_UNDO;








int main()
{
     pid_t pid;

     nsems = 1;


    //static struct sembuf oplock;
    oplock.sem_num = 0;
    oplock.sem_op = -1;
    oplock.sem_flg = SEM_UNDO;


    //static struct sembuf opunlock;
    opunlock.sem_num = 0;
    opunlock.sem_op = 1;
    opunlock.sem_flg = SEM_UNDO;


    //to create new one
    semflg = IPC_CREAT;


    /* Get unique key for semaphore. */
    if ((key1 =  ftok(path,1)) == (key_t) -1) {
        perror("IPC error: ftok"); exit(1);
    }

    /* Get unique key for semaphore. */
    if ((key2 =  ftok(path,2)) == (key_t) -1) {
        perror("IPC error: ftok"); exit(1);
    }

    /* Get unique key for semaphore. */
    if ((key3 =  ftok(path,3)) == (key_t) -1) {
        perror("IPC error: ftok"); exit(1);
    }


    if( 0 == (pid = fork() ) )
    { // then, child process

        int n =0;
        for(;n<3;n++)
        {

            locksem = semget(key1, nsems, semflg);   /* open-create locksem*/
            emptysem = semget(key2, nsems, semflg);
            fullsem = semget(key3, nsems, semflg);

            semop(fullsem,&oplock,1);  /* check filled slots */
            semop(locksem,&oplock,1);      /* lock shared buffer*/

            // itx= remove_item();
            /* remove an item from buffer */
            int i = 0;
            for (;i<10; i++)
            {
                rem[i] = data[i];
            } // end for

            bzero(buffer,10);
            bzero(data,strlen(data));

            /* detach from the segment: */
            if (shmdt(data) == -1)
            {
                error( "shmdt" );
            } // error() does not return

            // implied else, shmdt successful

            semop(locksem,&opunlock,1);  /* unlock the buffer */
            semop(emptysem,&opunlock,1);  /* increment emptysem*/
            //consume_item(itx);

            int sum = 0;
            for(i =0; i<10; i++)
            {
                sum += rem[i];
            } // end for

            printf("the sum is:%d \n", sum);
        } // end while
    }

    else
    { // else parent process
        creatmemory();

        int n =0;
        for(;n<3;n++)
        {
            locksem = semget(key1, nsems, semflg);   /* open-create locksem*/
            emptysem = semget(key2, nsems, semflg);
            fullsem = semget(key3, nsems, semflg);

            bzero(buffer,10);
            int i;
            for(i =0; i<10; i++)
            {
                buffer[i] = i;
            } // end for

            semop(emptysem,&oplock,1);  /* check empty slots */
            semop(locksem,&oplock,1);      /* lock shared buffer*/

            /* insert item into the buffer */
            strncpy(data, buffer, strlen(buffer));
            printf("done \n");

            semop(locksem,&opunlock,1);  /* unlock the buffer */
            semop(fullsem,&opunlock,1);  /* increment fullsem*/

            sleep(10);
        } // end for
    } // end if

    return(0);
} // end function: main


void creatmemory()
{
    /* make the key: */
    if ((key = ftok("/tmp",1)) == -1)
    {
        error( "ftok" ); // error does not return
    }

    // implied else, ftok successful

    /* connect to (and possibly create) the segment: */
    if ((shmid = shmget(key, 15, 0644| IPC_CREAT)) == -1)
    {
        error( "shmget" ); // error does not return
    }

    // implied else, shmget successful

    /* attach to the segment to get a pointer to it: */
    data = shmat(shmid, (void *)0, 0);

    if (data == (char *)(-1))
    {
        error( "shmat" ); // error does not return
    }

    // implied else, shmat successful
} // end function: creatmemory


void error(char *msg)
{
    perror(msg);
    exit(0);
} // end function: error

#定义XOPEN_SOURCE（1）//sys/ipc.h所需
#包括
#包括
#包括
#包括
#包括//退出（）
#包括
#包括//bzero（））
#包括
#包括
#包括
#包括
#包括
#包括
#包括
字符缓冲区[10]；
字符*数据；
int commNo=0；
钥匙(t)钥匙;；
int shmid；
char*shrmem；
int模式；
无效错误（字符*）；
int-rem[10]；
key\u t key；/*传递给semget（）的key*/
key\u t key1；/*传递给semget（）的key*/
key\u t key2；/*传递给semget（）的键*/
key\u t key3；/*传递给semget（）的键*/
int semflg；/*要传递给semget（）的semflg*/
int nsems；/*要传递给semget（）的nsems*/
int semid；/*来自semget（）的返回值*/
#定义最大计数200
#定义大小为100的N 100/*共享缓冲区*/
无效记忆（void）；
//ftok的事情
char*path=“/tmp”；
int id='S'；
//创建sembuf
//结构sembuf{
//数组中的ushort sem_num；/*信号量索引*/
//短sem_op；/*信号量操作*/
//短sem_flg；/*操作标志*/
//};
int locksem=1；/*用于锁定解锁的二进制信号量：initiall unlocked:1*/
int emptysem=100；/*计算空插槽的信号量*/
int fullsem=0；/*正在计算已填充插槽的信号量*/
struct sembuf oplock；//=（struct sembuf*）malloc（2*sizeof（struct sembuf））；
//静态结构sembuf oplock；
//oplock.sem_num=0；
//oplock.sem_op=-1；
//oplock.sem_flg=sem_UNDO；
struct sembuf opunlock；//=（struct sembuf*）malloc（2*sizeof（struct sembuf））；
//静态结构sembuf opunlock；
//opunlock.sem_num=0；
//opunlock.sem_op=1；
//opunlock.sem_flg=sem_UNDO；
int main（）
{
pid_t pid；
nsems=1；
//静态结构sembuf oplock；
oplock.sem_num=0；
oplock.sem_op=-1；
oplock.sem_flg=sem_UNDO；
//静态结构sembuf opunlock；
opunlock.sem_num=0；
opunlock.sem_op=1；
opunlock.sem_flg=sem_UNDO；
//创建新的
semflg=IPC_CREAT；
/*获取信号量的唯一密钥*/
如果（（键1=ftok（路径，1））==（键t）-1）{
perror（“IPC错误：ftok”