实验题目

： 进程通信实验

实验学时：

12 实验日期： 2019.5.2-2019.5.23

实验目的：

通过 Linux 系统中管道通信机制，加深对于进程通信概念的理解，观察和体验 并发进程间的通信和协作的效果 ，练习利用无名管道进行进程通信的编程和调试 技术。

硬件环境

： window

软件环境：

VWareUbuntu16.04

实验步骤与内容

1） 实验说明

：管道pipe 是进程间通信最基本的一种机制,两个进程可以通过管道一个在管道 一端向管道发送其输出,给另一进程可以在管道的另一端从管道得到其输入.管道以 半双工方式工作,即它的数据流是单方向的.因此使用一个管道一般的规则是读管道 数据的进程关闭管道写入端,而写管道进程关闭其读出端.

2） 实验思路流程图

实现实验目标采取三个进程，两套pipe来实现。子进程1， 通过pipe11和pipe12管道收到x的值，计算fx，再通过管道将计算后fx的值发给父进程。子进程2，计算fy的值，通过管道收到y的值并通过计算将fy发送给父进程。
父进程通过管道发送输入的x，y的值，并通过管道接收fx，fy的值。

代码流程

：

遇到的问题

：再fx，fy在哪里初始化概念不清，一开始fx，fy的输出都是0；
后来将fx，fy的初始化就放在分别各自的进程中。

结论分析与体会

： 1） 结果

：我分别使用x=3 y=5 ,x=5 y=3两组数据测试，均能输出测试答案

运行结果如上图所示，中间打印信息方便查看个进程内部的执行次序。

根据示例实验程序和独立实验程序观察和记录的调试和运行的信息，说明它们 反映出操作系统教材中讲解的进程协作和进程通信概念的哪些特征和功能？

1． 管道通信时消息传递的一种方式，所谓管道，是值用与练几个一个读进程和写进程来实现他们之间通信的一个共享文件
2． 管道机制必须提供以下三个方面的协调能力，互斥，同步和确定对方存在
3． 管道是单方向通信，要实现双方通信，必须实现两个管道。

在真实 的操作系统中它是怎样实现和反映出教材中进程通信概念的。你对于进程协作和进 程通信的概念和实现有哪些新的理解和认识？

1. 管道机制为进程之间的协作和消息传递提供一种很好的方法
2. 管道是半双工通信，给另一进程可以在管道的另一端从管道得到其输入.管道以 半双工方式工作,即它的数据流是单方向的.因此使用一个管道一般的规则是读管道 数据的进程关闭管道写入端,而写管道进程关闭其读出端。

管道机制的机理是什么？

1. 管道pipe 是进程间通信最基本的一种机制,两个进程可以通过管道一个在管道 一端向管道发送其输出,给另一进程可以在管道的另一端从管道得到其输入.管道以 半双工方式工作,即它的数据流是单方向的.因此使用一个管道一般的规则是读管道 数据的进程关闭管道写入端,而写管道进程关闭其读出端. 所谓管道，是值用与练几个一个读进程和写进程来实现他们之间通信的一个共享文件

怎样利用管 道完成进程间的协作和通信？

1. 两个进程可以通过管道一个在管道 一端向管道发送其输出,给另一进程可以在管道的另一端从管道得到其输入.管道以 半双工方式工作,即它的数据流是单方向的.因此使用一个管道一般的规则是读管道 数据的进程关闭管道写入端,而写管道进程关闭其读出端.

所有见解仅代表个人观点，不确保正确。望谅解，一起学习进步

理论知识

Linux——Linux C语言编程基础知识

Linux——进程通信

一、实验目的

(1) 熟悉并掌握管道机制，并实现进程间通信

(2) 熟悉并掌握共享内存机制，并实现进程间通信

二、实验内容

任务一：

（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析。

（2）编写程序：父进程利用管道将一字符串交给子进程处理。子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串。

任务二：

（1）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享内存的情况，对两次的结果进行比较，并分析原因。最后用ipcrm命令删除自己建立的共享存储区。

1、ipcs命令的作用:用于查看系统中共享存储区，消息队列和信号量的情况。如下图：

[x02620101@localhost x02620101]$ ipcs

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes     nattch  status
0x0000000f 262145     x02620101 644        1000       0
0x00000000 294914     x02620101 644        20         0

------ Semaphore Arrays --------
key        semid      owner      perms      nsems

------ Message Queues --------
key        msqid      owner    perms      used-bytes   messages

2、ipcrm命令的作用：用于删除系统中存在的共享存储区，消息队列等。如：

ipcrm  -M key 表示根据关键字删除共享存储区

ipcrm -m id表示根据标识符删除共享存储区

ipcrm -Q key表示根据关键字删除消息队列

ipcrm -q id表示根据标识符删除消息队列

（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。运行结束后可以用ctrl+c结束程序1的运行。

注：把&加在一个命令的最后，可以把这个命令放到后台执行 ,如gftp &,

（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。要求在父进程中生成一个30字节长的私有共享内存段。接下来，设置一个指向共享内存段的字符指针，将一串大写字母写入到该指针指向的存贮区。调用fork()生成子进程，让子进程显示共享内存段中的内容。接着，将大写字母改成小写，子进程修改共享内存中的内容。之后，子进程将脱接共享内存段并退出。父进程在睡眠5秒后，在此显示共享内存段中的内容（此时已经是小写字母）。

注：

需要包含头文件:

#include <sys/wait.h>

举例:

sleep(1);   休眠一秒

三、代码及运行结果分析

任务一：

（1）

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
        int x,fd[2];
        char buf[30],s[30];
        pipe(fd);
        while ((x=fork())==-1);
        if (x==0)
        {
                close(fd[0]);
                printf("Child Process!\n");
                strcpy(buf,"This is an example\n");
                write(fd[1],buf,30);
                exit(0);
                                           }
        else{
                close(fd[1]);
                printf("Parent Process!\n");
                read(fd[0],s,30);
                printf("%s\n",s);
        }
        return 0;
}

分析： 

调用pipe(fd);创建一个管道后，接着调用fork()函数产生两个进程，首先开始执行子进程，关闭管道出口，通过管道入口向管道中写入内容。父进程中，管道入口关闭，通过管道出口端从管道中读取之前写入内容，最后输出出来。

（2）

#include<stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
int main(){
        int x,count,left,right,temp,fd[2],fe[2];
        char c,buf[30],s[30];
        pipe(fd);
        pipe(fe);
        printf("please input a line of char:\n");
        scanf("%s",buf);
        while((x=fork())==-1);
        if(x==0){
                close(fd[0]);
                close(fe[1]);
                printf("Child Process!\n");
                write(fd[1],buf,30);
                read(fe[0],buf,30);
                printf("%s\n",buf);
                exit(0);
        }else{
                close(fd[1]);
                close(fe[0]);
                count=0;
                do{
                        read(fd[0],&c,1);
                        s[count++]=c;
                }while(c!='\0');
                printf("Parent Process!\n");
                printf("%s\n",s);count-=2;
                for(left=0,right=count;left<=count/2;left++,right--){
                        temp=s[left];
                        s[left]=s[right];
                        s[right]=temp;
                }
                write(fe[1],s,30);
                wait(0);
        }
}

任务二：

（1）

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main(){
        key_t key=200; /*在实际实验过程中，为了避免每个同学建立的共享存储区关键字一样而相互干扰，关键字请用学号末3位*/
        int shmid_1,shmid_2;
        if ((shmid_1=shmget(key,1000,0644|IPC_CREAT))==-1){
                perror("shmget shmid_1");exit(1);
        }
        printf("First shared memory identifier is %d\n",shmid_1);
        if ((shmid_2=shmget(IPC_PRIVATE,20,0644))==-1){
                perror("shmget shmid_2");exit(2);
        }
        printf("Second shared memory identifier is %d\n",shmid_2);
        exit(0);
        return 0;
}

分析： 

成功，返回共享内存段的标识符，内核中用于唯一的标识一个对象。对存在于内核存贮空间中的每个共享内存段，内核均为其维护着一个数据结构shmid_ds。 失败，返回－1，设置errno。 

①第一个参数key（键值）用来创建IPC标识符，shmget()返回的标识符与key值一一对应，不同的key值返回不同的标识符。 

②第二个参数size，决定了共享内存段的大小（若访问已存在的内存段，该参数可设为0）。有最大字节数的限制 

③第三个参数shmflag，用于设置访问权限及标识创建条件。 

对两次的结果进行比较：

两次运行结束后的 第二个共享标识符是不一样的。在用ipcs查看时，共享内存段中的关键字，共享内存标识符，访问权限，字节等都是不一样的。

（2）

程序1：

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define SHMKEY 200  /*在实际实验过程中，为了避免每个同学建立的共享存储区关键字一样而相互干扰，关键字请用学号末3位*/
#define K  1024
int shmid;
int main (){
        int i,*pint;
        char *addr;
        //extern int shmat();
        extern cleanup();
        for(i=0;i<20;i++) signal(i,cleanup);
        shmid=shmget(SHMKEY,16*K,0777|IPC_CREAT); /*建立16K共享区SHMKEY */
        addr=shmat(shmid,0,0);/*挂接，并得到共享区首地址 */
        printf ("addr 0x%x\n",addr);
        pint=(int *)addr;
        for (i=0;i<256;i++) *pint++=i;
        pause();/*等待接收进程读 */
}
cleanup()
{
        shmctl(shmid,IPC_RMID,0);
        exit(0);
}

程序2： 

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define SHMKEY 200  /*在实际实验过程中，为了避免每个同学建立的共享存储区关键字一样而相互干扰，关键字请用学号末3位*/
#define K  1024
int shmid;
int main ()
{
        int i,*pint;
        char *addr;
        //extern char * shmat ();
        shmid=shmget(SHMKEY,8*K,0777);/*取共享区SHMKEY的id */
        addr=shmat(shmid,0,0);/*连接共享区*/
        pint=(int *)addr;
        for (i=0;i<256;i++)
                printf("%d\n",*pint++);/*打印共享区中的内容*/
}

分析： 

首先系统通过调用shmctl对预定义的shmid指向的内存段进行删除操作，防止冲突，接着系统调用shmget创建一个16*1024字节的共享内存段，成功返回共享内存段的标识符给shmid，系统再次调用shmat连接内存段，返回该共享内存段连接到调用进程地址空间上的地址addr。

程序1后台运行时，该程序开始执行，系统调用shmget创建一个8*1024字节的共享内存段，再通过调用shmat挂接内存段，由系统选择挂接地址，最终输出转换后的挂接地址。最后输出前255的内容。共享存储区机制只为通信进程提供了访问共享存储区的操作条件，而对通信的同步控制则要依靠信号量机制等才能完成。

（3）

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define SHMKEY 200
#define K 1024
int shmid_1,shmid_2;
int main ()
{
        int x,y,i,*pint;
        char *addr_1,*addr_2;
        char words[26]={'A','B','C','D','E','F','G','H','I','J',
        'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','X'};
        shmid_1=shmget(SHMKEY,30*K,0777|IPC_CREAT); /*建立16K共享区SHMKEY */
        addr_1=shmat(shmid_1,0,0);/*挂接，并得到共享区首地址*/
        pint=(int *)addr_1;
        printf ("addr_1 0x%x\n",addr_1);
        for (i=0;i<26;i++) {
                *pint=words[i];
                pint++;
        }
        while((x=fork())==-1);
        if(x==0){
                shmid_2=shmget(SHMKEY,30*K,0777|IPC_CREAT); /*建立16K共享区SHMKEY */
                addr_2=shmat(shmid_2,0,0);/*挂接，并得到共享区首地址*/
                pint=(int *)addr_2;
                for(i=0;i<26;i++){
                        printf("%c ",*pint);
                        *pint=*pint+32;
                        pint++;
                        if(i==25)printf("\n");
                }
                y=shmdt(addr_2);
                exit(0);
        }else{
                sleep(5);
                pint=(int *)addr_1;
                for(i=0;i<26;i++){
                        printf("%c ",*pint);
                        pint++;
                        if(i==25)printf("\n");
                }
        }
}

四、实验心得

通过本次实验了解了管道进程间通信形式，掌握利用管道进行进程通信的程序设计，管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道； 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统。数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。基本达到了本次实验的要求。另外，对于共享内存通信的工作机制也有了一定的了解，掌握线程与进程在组成成分上的差别，以及与其相适应的通讯方式和应用目标。知道了操纵共享内存共有shmget()、shmat()、shmdt()、shmctl()4个系统调用。ipcs命令的作用:用于查看系统中共享存储区，消息队列和信号量的情况，ipcrm命令的作用:用于删除系统中存在的共享存储区，消息队列。也让我对管道及共享区的作用和用法，以及对操作系统中各进程之间的通信和协同作用等方面有了更深的了解。总之，本次实验自己收获了很多。

参考文章

实验三、进程通信(一) ——管道及共享内存

实验三、 操作系统（OS）--进程通信（管道及共享内存）

实验三 进程通信(一)

linux c 休眠函数sleep usleep

Linux后台进程管理以及ctrl+z（挂起）、ctrl+c（中断）、ctrl+\（退出）和ctrl+d（EOF）的区别

一、实验时间

2021年4月22日，星期四，第8周

二、实验内容

通过Linux 系统中管道通信机制，加深对于进程通信概念的理解，观察和体验并发进程间的通信和协作的效果 ，练习利用无名管道进行进程通信的编程和调试技术。

管道pipe是进程间通信最基本的一种机制,两个进程可以通过管道一个在管道一端向管道发送其输出，给另一进程可以在管道的另一端从管道得到其输入。管道以半双工方式工作,即它的数据流是单方向的。因此使用一个管道一般的规则是读管道数据的进程关闭管道写入端,而写管道进程关闭其读出端。

关键：利用pipe系统调用

三、示例实验

这个是实验指导书上的示例实验，关键要理解以下几点

1. pipe系统调用的使用和声明
2. 如何使用read方法和write方法读取和向发送另一个进程发送消息
3. 注意close方法的使用，在发送消息或读取消息的时候管道的另一个端口需要关闭

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
    int pid; //进程号
    int pipe1[2]; //存放第一个无名管道标号
    int pipe2[2]; //存放第二个无名管道标号
    int x; // 存放要传递的整数
    //使用pipe()系统调用建立两个无名管道。建立不成功程序退出，执行终止
    if(pipe(pipe1) < 0)
    {
        perror("pipe not create");
        exit(EXIT_FAILURE);
    }
    if(pipe(pipe2) < 0)
    {
        perror("pipe not create");
        exit(EXIT_FAILURE);
    }
    //使用fork()系统调用建立子进程,建立不成功程序退出，执行终止
    if((pid=fork()) <0)
    {
        perror("process not create");
        exit(EXIT_FAILURE);
    }
    //子进程号等于0 表示子进程在执行
    else if(pid == 0)
    {
        //子进程负责从管道1的0端读,管道2的1端写
        //所以关掉管道1的1端和管道2的0端。
        close(pipe1[1]);
        close(pipe2[0]);
        //每次循环从管道1 的0 端读一个整数放入变量X 中,
        //并对X 加1后写入管道2的1端，直到X大于10
        do
        {
            read(pipe1[0],&x,sizeof(int));
            printf("child %d read: %d\n",getpid(),x++);
            write(pipe2[1],&x,sizeof(int));
        }while( x<=9 );
        //读写完成后,关闭管道
        close(pipe1[0]);
        close(pipe2[1]);
        //子进程执行结束
        exit(EXIT_SUCCESS);
    }
    //子进程号大于0 表示父进程在执行
    else
    {
        //父进程负责从管道2的0端读,管道1的1端写，
        //所以关掉管道1 的0 端和管道2 的1端。
        close(pipe1[0]);
        close(pipe2[1]);
        x=1;
        //每次循环向管道1 的1 端写入变量X 的值,并从
        //管道2的0 端读一整数写入X 再对X加1，直到X 大于10
        do
        {
            write(pipe1[1],&x,sizeof(int));
            read(pipe2[0],&x,sizeof(int));
            printf("parent %d read: %d\n",getpid(),x++);
        }while(x<=9);
        //读写完成后,关闭管道
        close(pipe1[1]);
        close(pipe2[0]);
    }
    //父进程执行结束
    return EXIT_SUCCESS;
}

输出结果

在做本次实验之前最好理解清楚这个示例实验，里面具体的方法要求掌握

四、本次实验

实验内容

在这次实验的过程中我遇到了几个比较坑的地方，困扰了不少时间

1. 这次实验中遇到了父进程创建两个子进程的问题，一开始的时候我没有调控好，在创建进程的时候遇到了很多问题，比如父进程已经执行完了，第二个子进程还在执行，后来在参考了别人的代码之后发现在判断if(pid == 0),else的时候要注意，两个进程不能并列判断
2. 关于read方法和write的注意事项：起初我采用从管道的0端写，1端读，结果读出来的结果是随机数，很奇怪。后来我改成了从0端读，1端读，问题就顺利解决了

以下是这次实验的代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
//f(x)
int fx(int x)
{
    if(x <= 0)
    {
        printf("the number you input is wrong!");
        return 0;
    }
    else if(x == 1)
    {
        return 1;
    }
    else if(x > 1)
    {
        return fx(x-1) * x;
    }
}
//f(y)
int fy(int y)
{
    if(y <= 0)
    {
        printf("the number you input is wrong!");
        return 0;
    }
    else if(y == 1 || y == 2)
    {
        return 1;
    }
    else if(y > 2)
    {
        return fy(y-1) + fy(y-2);
    }
}
//f(x,y)
int fxy(int fx, int fy)
{
    return fx + fy;
}
int main()
{
    /*
        建立三个进程，一个进程负责计算f(x)的值，一个负责计算f(y)的值，另一个负责计算f(x,y)的值
        f(x),f(y)的值通过管道传输
    */
    //建立两个管道
    int pipe1[2];
    int pipe2[2];
    //两个子进程的进程号
    int pid1;
    int pid2;
    //数值x和y
    int x;
    int y;
    //从键盘输入x和y
    printf("please input number x: ");
    scanf("%d",&x);
    printf("\n");
    printf("please input number y: ");
    scanf("%d",&y);
    printf("\n");
    //保存f(x)和f(y)的变量
    int temp1,temp2;
    //使用pipe()系统调用建立两个无名管道。建立不成功程序退出，执行终止
    if(pipe(pipe1) < 0)
    {
        perror("pipe not create");
        exit(EXIT_FAILURE);
    }
    if(pipe(pipe2) < 0)
    {
        perror("pipe not create");
        exit(EXIT_FAILURE);
    }
    pid1 = fork();
    //使用fork()系统调用建立子进程,建立不成功程序退出，执行终止
    if(pid1 <0)
    {
        perror("process not create");
        exit(EXIT_FAILURE);
    }
    //第一个子进程，pipe1[1]用来写
    if(pid1 == 0)
    {
        //关掉pipe1[0]端
        close(pipe1[0]);
        //计算f(x)
        temp1 = fx(x);
        printf("pid1 f(x) = %d\n",temp1);
        //发送消息
        write(pipe1[1],&temp1,sizeof(int));
        //发送完成后关闭管道
        close(pipe1[1]);
    }
    else
    {
        close(pipe1[1]);
        //读从管道1获得的数值
        read(pipe1[0],&temp1,sizeof(int));
        close(pipe1[0]);
        pid2 = fork();
        //使用fork()系统调用建立子进程,建立不成功程序退出，执行终止
        if(pid2 <0)
        {
            perror("process not create");
            exit(EXIT_FAILURE);
        }
        //第二个子进程，pipe2[1]用来写
        if(pid2 == 0)
        {
            //关掉pipe2[0]端
            close(pipe2[0]);
            //计算f(y)
            temp2 = fy(y);
            printf("pid2 f(y) = %d\n",temp2);
            //发送消息
            write(pipe2[1],&temp2,sizeof(int));
            close(pipe2[1]);
        }
        //父进程
        else
        {
            wait(NULL);
            close(pipe2[1]);
            //接受第二个子进程从管道里发来的信息
            read(pipe2[0],&temp2,sizeof(int));
            int result = fxy(temp1,temp2);
            printf("f(x) = %d\n",temp1);
            printf("f(y) = %d\n",temp2);
            printf("f(x,y) = %d\n",result);
            //读完成后关闭管道
            close(pipe2[1]);
            //父进程执行结束
            return EXIT_SUCCESS;
        }
    }
}

输入x=1，y=2的输出结果

输入x=5，y=5的输出结果