进程间的通信方式：

   1.管道（pipe）及有名管道（named pipe）：

    管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

    有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

    2.信号（signal）：

     信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

   3.消息队列（message queue）：

    消息队列是消息的链接表，它克服了上两种通信方式中信号量有限的缺点，具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息。       

   其基本思想是:根据”生产者-消费者”原理,利用内存中公用消息缓冲区实现进程之间的信息交换.  

   内存中开辟了若干消息缓冲区,用以存放消息.每当一个进程向另一个进程发送消息时,便申请一个消息缓冲区,并把已准备好的消息送到缓冲区,然后把该消息缓冲区插入到接收进程的消息队列中,最后通知接收进程.接收进程收到发送里程发来的通知后,从本进程的消息队列中摘下一消息缓冲区,取出所需的信息,然后把消息缓冲区不定期给系统.系统负责管理公用消息缓冲区以及消息的传递.  
   一个进程可以给若干个进程发送消息,反之,一个进程可以接收不同进程发来的消息.显然,进程中关于消息队列的操作是临界区.当发送进程正往接收进程的消息队列中添加一条消息时,接收进程不能同时从该消息队列中到出消息:反之也一样.  

   4.共享内存（shared memory）：

     可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等。

    这种通信模式需要解决两个问题：第一个问题是怎样提供共享内存；第二个是公共内存的互斥关系则是程序开发人员的责任。   

   5.信号量（semaphore）：

     主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。

   6.套接字（socket）；

     套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

用法：

    1 管道 

　　它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。 
　　1.1 无名管道由pipe（）函数创建： 
　　

  
#include <unistd.h> 

int pipe(int filedis[2])；//参数filedis返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。

//下面的例子示范了如何在父进程和子进程间实现通信。 
#define INPUT 0 
#define OUTPUT 1 
void main() 
{ 
    int file_descriptors[2]; 

    /*定义子进程号 */ 
    pid_t pid; 
    char buf[256]; 
    int returned_count; 

    /*创建无名管道*/ 
    pipe(file_descriptors); 

    /*创建子进程*/ 
    if((pid = fork()) == -1) { 
        printf("Error in fork\n"); 
        exit(1); 
    } 

    /*执行子进程*/ 
    if(pid == 0) { 
        printf("in the spawned (child) process...\n"); 

        /*子进程向父进程写数据，关闭管道的读端*/ 
        close(file_descriptors[INPUT]); 
        write(file_descriptors[OUTPUT], "test data", strlen("test data")); 
        exit(0); 
    }else{ 

        /*执行父进程*/ 
        printf("in the spawning (parent) process...\n"); 

        /*父进程从管道读取子进程写的数据，关闭管道的写端*/ 
        close(file_descriptors[OUTPUT]); 
        returned_count = read(file_descriptors[INPUT], buf, sizeof(buf)); 
        printf("%d bytes of data received from spawned process: %s\n", 
        returned_count, buf); 
    } 
} 

        1.2 有名管道可由两种方式创建

　　　方式一：mkfifo("myfifo","rw"); 
　　　方式二：mknod myfifo p 
　　 生成了有名管道后，就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。

  
/* 进程一：读有名管道*/ 
#include <stdio.h> 
#include <unistd.h> 

void main() 
{ 
    FILE * in_file; 
    int count = 1; 
    char buf[80]; 

    in_file = fopen("mypipe", "r"); 
    if (in_file == NULL) { 
        printf("Error in fdopen.\n"); 
        exit(1); 
    } 

    while ((count = fread(buf, 1, 80, in_file)) > 0) 
        printf("received from pipe: %s\n", buf); 

    fclose(in_file); 
} 

/* 进程二：写有名管道*/ 
#include <stdio.h> 
#include <unistd.h> 

void main() 
{ 
    FILE * out_file; 
    int count = 1; 
    char buf[80]; 

    out_file = fopen("mypipe", "w"); 
    if (out_file == NULL) { 
        printf("Error opening pipe."); 
        exit(1); 
    } 

    sprintf(buf,"this is test data for the named pipe example\n"); 
    fwrite(buf, 1, 80, out_file); 

    fclose(out_file); 
} 

　　 消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，是一个在系统内核中用来保存消息的队列，它在系统内核中是以消息链表的形式出现。消息链表中节点的结构用msg声明。
      事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它，所以，我们对此方式也不再解释，也建议读者忽略这种方式。 

　3 共享内存 
　 　 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行 读写。

       得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是 实际的物理内存，

　　 首先要用的函数是shmget，它获得一个共享存储标识符。 
　　　　 #include <sys/types.h> 
　　　　 #include <sys/ipc.h> 
　　　　 #include <sys/shm.h> 
　　　　

                  int shmget(key_t key, int size, int flag); 

　 　 这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大小的内存用作共享内存。　 
         当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。 

    　　 void *shmat(int shmid, void *addr, int flag); 
　    shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。 

　     使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存 储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。 

　　 4 信号量 
　　 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作： 
　　 （1） 测试控制该资源的信号量。 
　　 （2） 若此信号量的值为正，则允许进行使用该资源。进程将信号量减1。 
　　 （3） 若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大于0，进程被唤醒，转入步骤（1）。 
　　 （4） 当进程不再使用一个信号量控制的资源时，信号量值加1。如果此时有进程正在睡眠等待此信号量，则唤醒此进程。 

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

int semget(key_t key, int nsems, int flag);
 
struct sem {
      short sempid;/* pid of last operaton */
      ushort semval;/* current value */
      ushort semncnt;/* num procs awaiting increase in semval */
      ushort semzcnt;/* num procs awaiting semval = 0 */
}　　 

　      key是前面讲过的IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新 集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。 

　　 semctl函数用来对信号量进行操作。 

　　 int semctl(int semid, int semnum, int cmd, union semun arg); 
　　 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。 
　　 
         semop函数自动执行信号量集合上的操作数组。 

　　 int semop(int semid, struct sembuf semoparray[], size_t nops); 
　　 semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。

  
#include <stdio.h> 
#include <sys/types.h> 
#include <sys/sem.h> 
#include <sys/ipc.h>
 
void main() 
{ 
    key_t unique_key; /* 定义一个IPC关键字*/ 
    int id; 
    struct sembuf lock_it; 
    union semun options; 
    int i; 
    unique_key = ftok(".", 'a'); /* 生成关键字，字符'a'是一个随机种子*/ 
    
    /* 创建一个新的信号量集合*/ 
    id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666); 
    printf("semaphore id=%d\n", id); 
    options.val = 1; /*设置变量值*/ 
    semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/ 
    /*打印出信号量的值*/ 
    i = semctl(id, 0, GETVAL, 0); 
    printf("value of semaphore at index 0 is %d\n", i); 
    /*下面重新设置信号量*/ 
    lock_it.sem_num = 0; /*设置哪个信号量*/ 
    lock_it.sem_op = -1; /*定义操作*/ 
    lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/ 

    if (semop(id, &lock_it, 1) == -1) { 
        printf("can not lock semaphore.\n"); 
        exit(1); 
    } 
    i = semctl(id, 0, GETVAL, 0); 
    printf("value of semaphore at index 0 is %d\n", i); 
    /*清除信号量*/ 
    semctl(id, 0, IPC_RMID, 0); 
} 

    
intopen_semaphore_set(key_t keyval,int numsems)
{
    intsid;

    if(!numsems)
        return(-1);

    if((sid=semget(mykey,numsems,IPC_CREAT|0660))==-1)
    {
        return(-1);
    }

    return(sid);
}

系统调用：semctl();

原型：int semctl(int semid,int semnum,int cmd,union semunarg);

返回值：如果成功，则为一个正数。如果失败，则为-1：errno=EACCESS(权限不够)

1、QT通信机制

为了更好的实现QT的信息交互，在QT系统中创建了较为完善的通信机制。QT的通信可分为QT内部通信和外部通信两大类。对于这两类通信机制及应用场合做如以下分析：

（1）QT内部对象间通信

在图形用户界面编程中，经常需要将一个窗口部件的变化通知给窗口的其它部件使其产生相应的变化。对于这种内部对象间的通信，QT主要采用了信号和槽的机制。这种机制是QT区别于其他GUI工具的核心机制。在大部分的GUI工具中，通常为可能触发的每种行为通过定义回调函数来实现。这种回调函数是一个指向函数的指针，在进行函数回调执行时不能保证所传递的函数参数类型的正确性，因此容易造成进程的崩溃。

（2）QT与外部设备间通信

QT与外部通信主要是将外部发来的消息以事件的方式进行接收处理。外部设备将主要通过socket与QT应用程序进行连接。在此，以输入设备与QT应用程序的通信为例说明QT与外部通信的原理。

在QT的应用程序开始运行时，主程序将通过函数调用来创建并启动qwsServer服务器，然后通过socket建立该服务器与输入硬件设备的连 接。服务器启动后将会打开鼠标与键盘设备，然后将打开的设备文件描述符fd连接到socket上。等到QT应用程序进入主事件循环时，事件处理程序将通过 Linux系统的select函数来检测文件描述符fd的状态变化情况以实现对socket的监听。如果文件描述符fd状态改变，说明设备有数据输入。此 时，事件处理程序将会发出信号使设备输入的数据能及时得到QT应用程序的响应。数据进入服务器内部就会以事件的形式将数据放入事件队列里，等待QT客户应 用程序接收处理。处理结束后再将事件放入请求队列里，通过服务器将事件发送到相应硬件上，完成外部输入设备与QT应用程序的整个通信过程。

2、 QProcess机制分析

QProcess类通常是被用来启动外部程序，并与它们进行通信的。QProcess是把外部进程看成是一个有序的I/O设备，因此可通过 write（）函数实现对进程标准输入的写操作，通过read（），readLine（）和getChar（）函数实现对标准输出的读操作。

（1） QProcess通信机制

QT可以通过QProcess类实现前端程序对外部应用程序的调用。这个过程的实现首先是将前端运行的程序看成是QT的主进程，然后再通过创建主进 程的子进程来调用外部的应用程序。这样QProcess的通信机制就抽象为父子进程之间的通信机制。QProcess在实现父子进程间的通信过程中是运用 Linux系统的无名管道来实现的，因此为了能更加清楚的说明QProcess的通信机制，在此首先介绍关于无名管道实现父子进程间的通信机制。

无名管道是一种只能够在同族父子之间通信，并且在通信过程中，只能从固定的一端写，从另一端读的单向的通信方式。该无名管道是通过调用pipe（）函数而创建的。创建代码如下：

1. #include  <unistd.h>      int  pipe(int  fd[2])  ;    返回：若成功则为0，若出错则为-1 

创建后经参数fd返回两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。经过fork（）函数创建其子进程后，子进程将拥有与父进程相 同的两个文件描述符。如果想要实现父进程向子进程的通信则关闭父进程的读端fd[0]，同时关闭子进程的写端fd[1]。这样就建立了从父进程到子进程的 通信连接。

由于无名管道的单向通信性，所以如果要应用无名管道实现父子进程之间的双向通信则至少需要应用双管道进行通信。QProcess类的通信原理就是利 用多管道实现了父子进程之间的通信。然而对于外部运行的应用程序大都是通过标准输入而读得信息，通过标准输出而发送出信息，因此只通过建立管道并不能完成 内外进程?之间的通信。要解决此问题，就如该模块开始时所说，QProcess是把外部进程看成是一个I/O设备，然后通过对I/O设备的读写来完成内外 进程的通信。

在QProcess中父子进程之间是通过管道连接的，要实现子进程能从标准输入中读得父进程对管道的写操作，同时父进程能从管道中读得子进程对标准 输出或标准容错的写操作，就要在子进程中将管道的读端描述符复制给标准输入端，将另外管道的写端描述符复制给标准输出端和标准容错端，即实现管道端口地址 的重定向。这样子进程对标准输入、标准输出及标准容错的操作就反应到了管道中。

QProcess在正常渠道模式下具体实现共用了五个无名管道进行通信。五个管道的描述符分别用 childpipe[2]，stdinChannelpipe[2]，stdoutChannelpipe[2]，stderrChannelpipe[2] 和deathpipe[2]五个数组来保存。deathpipe指代的管道会用在消亡的子进程与父进程之间。当子进程准备撤销时会发送一个表示该子进程消 亡的字符给父进程来等待父进程进行处理。stdinChannelpipe，stdoutChannelpipe和stderrChannelpipe所 指代的管道分别与标准输入，标准输出和标准容错进行绑定，实现了与外部程序的通信。childpipe指代的管道主要是为父子进程之间的通信而建立的。

如果在管道中有新数据写入，就会通知相应进程去读。另外图2是QProcess在正常渠道模式下的通信原理图，如果是在融合渠道模式下，将没有容错 管道，此时原理图中将没有第一个管道，也就不会有管道描述符。同时，标准容错端和标准输出端将共同挂接到子进程的stdoutChannelpipe的写 端，来实现内外进程的通信。

（2） QProcess应用方式

由于QProcess类实现了对底层通信方式较为完善的封装，因此利用QProcess类将更为方便的实现对外部应用程序的调用。在此，通过在QT界面中调用外部mplayer的例子来简单说明QProcess的应用方式。

1. const  QString  mplayerPath("/mnt/yaffs/mplayer");      

1. const  QString  musicFile("/mnt/yaffs/music/sound.mp3");    

1. QProcess*  mplayerProcess=new  QProcess();  

1. QStringList  args;    

1. args<<"-slave";    

1. args<<"-quiet";    

1. args  <<  "-wid"; 

1. 1. 1. args  <<  "-af volume=10"

1. args<<musicFile;    

1. mplayerProcess->setProcessChannelMode(QProcess::MergedChannels);  

1. 1. mplayerProcess ->start(mplayerPath,args); 
      1. 第一行指明了所要调用的外部应用程序mplayer的位置。
         1. 第二行指明了所要播放的声音文件及目录路径。
            
            1. 第三行创建一个指向类 QProcess的指针。
               1. 第四到第九行指定mplayer参数，具体参数可以查看 maplayer参数介绍 。
                  1. -slave参数表示打开slave模式. 这用来将MPlayer作为其它程序的后端. MPlayer将从他的标准输入读取简单命令行, 而不再截获键盘事件. SLAVE模式协议部分将解释其语法。
                     1. -quiet显示较少的输出和状态信息 。
                        1. 1. -wid可以为mplayer指定输出窗口。
                                 -af volume=10选择输出音量级别为10.这个选项是不可重入的, 所以对每个音频流只能使用一次。
                           

                         第十行为设置进程渠道的模式为融合模 式，即将标准输出和标准容错绑定到同一个管道的写端。
                     第十一行为启动外部应用程序mplayer。内核中管道及通信环境的建立都是在此步中完成的。
                     
                     mplayer在slave模式下运行会自动从标准输入中读取信息并执行。由QProcess的通信原理可知，管道的读端描述符 stdinChannelpipe[0]复制给了标准输入，即标准输入的描述符也为stdinChannelpipe[0]，因此按照标准输入的描述符去 读信息就是到stdinChannelpipe所对应的管道中读取信息。所以如果想在QT的主进程中发送命令使mplayer退出，只需在主程序中向 stdinChannelpipe[1]端写入命令quit就可以，执行语句为myProcess->write（”quit ”）;（此处的 write（）函数为QProcess类的成员函数，具体实现就是向stdinChannelpipe[1]端写入信息）
                     

                     （3）QProcess的发展及分析

                     QProcess类伴随着QT/Embedded的发展逐渐趋于完善。在QTE2及其更前版本中还没有QProcess类，如果想实现与外部应用程 序的通信，必须要自己实现对管道或socket的建立与重定向。到了QTE3版本，就实现了对QProcess类的封装。在QTE3的版本 中，QProcess类的实现是通过应用socket来建立主进程与外部应用程序之间通信的。通信原理与图3所示基本相同，只是将图中的管道描述符改为是 socket的描述符即可。QT主程序在建立成对socket描述符时需要调用Linux系统函数socketpair（）。在生成的成对socket描 述符之间可以实现父子进程之间的双向通信，即无论是socket的0套接口还是1套接口都可进行读写。

                     
                     

                     但为了避免出现通信过程中父子进程对同一个socket的争夺，例如，在子进程还未将父进程发送的信息全部读出时，子进程又要求将自己产生的数据返 回给父进程。如果父子进程双向通信只用一个socket来完成，就会出现父子进程发送的信息混乱情况。因此，对于QProcess的实现仍然必须通过多个 socket来共同完成。

                     由上面的描述可知，尽管socket有双向通信功能，但在实现QProcess过程中只是利用socket实现了单向通信功能。因此既浪费了对资源 的利用又增加了系统的开销。为了解决此问题，QTE4版本将QProcess的通信连接方式由socket改为了只能实现单向通信的无名管道来实现。通信 原理就是以上3.1 QProcess通信机制中所描述的。

                     3、其它通信方式
                     

                     
                     

                     除了上面介绍的无名管道和socket通信方式外，一般操作系统中常用的进程间通信机制也都可以用于QT系统内部不同进程之间的通信，如消息队列、共享内存、信号量、有名管道等机制。其中信号量机制在QT中已经重新进行了封装；有些机制则可以直接通过操作系统的系统调用来实现。另外，如果我们只是想通过管道或socket来实现较简单的外部通信，也可以重新创建管道或socket来实现自己要求的功能。例如，还是在QT主程序中调用外部mplayer。如果我们只是想在QT主程序中控制mplayer，而不要求得到mplayer输出的信息。则可以按照以下方式来实现：
                     

                     1.   const  char*  mplayerPath  =  "/mnt/yaffs/mplayer";       

                     1. const  char*  musicFile  =  "/mnt/yaffs/music/sound.mp3";     

                     1. const  char*  arg[5];     

                     1. arg[0]  =  mplayerPath;     

                     1. arg[1]  =  "-slave";     

                     1. arg[2]  =  "-quiet";    

                     1. arg[3]  =  musicFile;    

                     1. arg[4]  =  NULL;    

                     1. int  fd[2],pid;     

                     1. if(pipe(fd)<0)     

                     1.     printf("creating  pipe  is  error ");     

                     1. else  while((pid=fork())<0);     

                     1. if(pid==0)     

                     1. {     

                     1.     ::close(fd[1]);     

                     1.     ::dup2(fd[0],STDIN_FILENO);    

                     1.     execvp(arg[0],(const*  char*)arg);     

                     1. }     

                     1. else

                     1. {  

                     1.     ::close(fd[0]);

                     1. } 

                     第1到8行与前面QProcess类实现调用mplayer一样，是用来指明mplayer运行时参数的。第10行是创建一个管道。第12行是创建一个子进程。15，20行是关闭父子进程中没用的管道描述符。此时可结合图2.1和图2.2来理解从父进程到子进程通信环境的建立。第16行是把子进程的读端与标准输入绑定，以便mplayer能够接收到父进程发出的命令。17行就是从子进程中调用外部mplayer的实现。此时，程序执行后，mplayer就可以运行起来。如果想在QT主程序中通过发送命令使mplayer退出，就在管道的写端写入命令"quit"就可以。实现语句为write(fd[1], "quit",strlen("quit"));

                     该例子说明了QT通信方式运用的灵活性，可以根据实际情况进行应用。同时该例子的实现方式正是利用了QProcess类实现的机制，因此可以结合这个例子更加深刻的理解QProcess类的实现机制。

0. 相关博客

实现一个模拟的shell_ 一只博客-CSDN博客_操作系统实验模拟shellhttps://blog.csdn.net/qq_42276781/article/details/98521603实现一个管道通信程序_ 一只博客-CSDN博客_实现一个管道通信程序https://blog.csdn.net/qq_42276781/article/details/98523996利用Linux的消息队列通信机制实现两个线程间的通信_ 一只博客-CSDN博客_杭电操作系统实验三https://blog.csdn.net/qq_42276781/article/details/90672038

1. 利用Linux的共享内存通信机制实现两个进程间的通信

       编写程序sender，它创建一个共享内存，然后等待用户通过终端输入一串字符，并将这串字符通过共享内存发送给receiver；最后，它等待receiver的应答，收到应答消息后，将接收到的应答信息显示在终端屏幕上，删除共享内存，结束程序的运行。编写receiver程序，它通过共享内存接收来自sender的消息，将消息显示在终端屏幕上，然后再通过该共享内存向sender发送一个应答消息“over”（老师告知可以省略这步操作），结束程序的运行。选择合适的信号量机制实现两个进程对共享内存的互斥及同步使用。

2. 原代码

无bug，可正常运行

3. 图片识别结果

有bug，无法直接运行，调试改bug过程中可以加深代码理解

test4.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<semaphore.h>
#include<fcntl.h>
#include<sys/shm.h>
sem_t *w;//定义写的信号量 
int main(){
	pid_t pid;
	int  shm_id,x;
	char *shm_addr;
	char *name="writer";
	char buff [256];
	//初始化有名信号量 
	w=sem_open(name,O_CREAT,0666,1);
	
	//以下两行代码用以确保Write的初值为1,因为笔者在调试代码期间,有时Write的初值不为1 
	//如有需要可以使用这两行代码 
	/*sem_getvalue(w,&x);
	if(x==0) sem_post(w);*/
	 
	shm_id=shmget(IPC_PRIVATE,256,0666);
	if(shm_id<0){
		perror("shmget error");
		exit(1);
	}
	pid=fork();//创建子进程 
	if(pid<0){//创建失败 
		perror("fork error");
		exit(1);
	}
	else if(pid==0){//当前运行子进程 
		while(1){
			sem_wait(w);//申请写的权限 
			//把共享内存区对象映射到调用进程的地址空间
			//函数原型void *shmat(int shmid, const void *shmaddr, int shmflg)
			//具体参数含义参见https://baike.baidu.com/item/shmat 
			shm_addr=shmat(shm_id,0,0);
			if(shm_addr==(void *)-1){//映射失败 
				perror("child shmat error");
				sem_post(w);
				exit(1);
			}
			strcpy(buff,shm_addr);//将共享内存中的信息拷贝至buff 
			printf("child receive:%s",buff );
			//断开共享内存连接 
			//函数原型int shmdt(const void *shmaddr)
			//具体参数含义参见https://baike.baidu.com/item/shmat  
			if(shmdt(shm_addr)<0){
				perror("child shmdt");//断开连接失败,返回提示 
				sem_post(w);//释放写的权限 
				exit(1);
			}	
			sem_post(w);
			sleep(2); 
		}
	}
	else while(1){//当前运行父进程 
		sem_wait(w); 
		printf("parent send:");
		shm_addr=shmat(shm_id,(void *)0,0);
		if(shm_addr==(void *)-1){
			perror("parent shmat error"); 
			sem_post(w);
			exit(1);
		}
		fgets(buff,256,stdin);//读取键盘的一行输入到buff 
		if(!strncmp(buff,"exit",4)){
			sem_post(w);
			if (shmctl(shm_id,IPC_RMID,NULL)==-1){
				perror("shmctl :IPC_ RMID");
				sem_post(w);
				exit(1);
			}
			else{
				printf("-------end--------\n");
				sem_post(w);
				exit(0);
			}
		}
		else{
			//将buff写入共享内存 
			strncpy(shm_addr,buff,strlen(buff));
			//断开共享内存的连接 
			if(shmdt(shm_addr)<0){
				perror("parent shmdt");
				sem_post(w);
				exit(1);
			}
		        sem_post(w);
			sleep(3);
		}
	}
	return 0;
}	

4. 代码及实验报告获取

关注公众号，回复“进程管理”即可获取代码和实验报告