精华内容
下载资源
问答
  • 操作系统 进程通信实验
    千次阅读
    2017-12-05 16:57:54

    1)用一个程序作为“引子”,先后fork()两个进程,SERVER和CLIENT,进行通信。

    (2)SERVER端建立一个Key为75的消息队列,等待其他进程发来的消息。当遇到类型为1的消息,则作为结束信号,取消该队列,并退出SERVER。SERVER每接受到一个消息后显示一句“(Server)received”,然后发送一个返回消息给CLIENT端,显示一句“(Server)sent”。

    (3)CLIENT端使用key为75的消息队列,先后发送类型从10到1的消息,然后退出。最后一个消息,即是SERVER端需要的结束信号。CLIENT每发送一条消息后显示一句“(Client)sent”,等接受SERVER端的返回消息后,显示一句“(Client)received”,再在发送下一条消息。

    (4)父进程在SERVER和CLIENT都退出后结束。

    源代码:

    #include<stdio.h>

    #include<sys/msg.h>

    #include<sys/ipc.h>

    #include<sys/types.h>

     

    #define msgkey 75

     

    struct msgform

    {

    long msgtype;

    char msgtext[1000];

    }msg;

     

    int msgqid,i;

    void cilent(){

    int i;

    msgqid=msgget(msgkey,0777);

    for(i=10;i>=1;i--){

    if(

    msg.msgtype=i;

    printf("(cilent)send\n");

    msgsnd(msgqid,&msg,1000,0);

    }

    exit(0);

    }

     

    void server(){

    msgqid=msgget(msgkey,0777|IPC_CREAT);

    do{

    msgrcv(msgqid,&msg,1000,0,0);

    printf("(server) received\n");

    msgsnd(msgqid,&msg,sizeof(int),0);

    }while(msg.msgtype!=1);

     

    msgctl(msgqid,IPC_RMID,0);

    exit(0);

    }

     

    main(){

    while((i=fork())==-1);

    if(!i) server();

    while((i=fork())==-1);

    if(!i) cilent();

    wait(0);

    wait(0);

     

    }

     

    更多相关内容
  • 通过对进程通信同步/互斥问题的编程实现,加深理解信号量和 P、V 操作的原理; 对 Windows 或 Linux 涉及的几种互斥、同步机制有更进一步的了解;熟悉 Windows 或 Linux 中定义的与互斥、同步有关的函数。
  • 操作系统进程通信实验

    千次阅读 2019-07-22 19:38:43
    进程通信实验 实验学时: 12 实验日期: 2019.5.2-2019.5.23 实验目的: 通过 Linux 系统中管道通信机制,加深对于进程通信概念的理解,观察和体验 并发进程间的通信和协作的效果 ,练习利用无名管道进行进程通信...

    实验题目

    : 进程通信实验

    实验学时:

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

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

    展开全文
  • 编写一段程序,实现进程的管道通信。 使用系统调用pipe( )建立一条管道,创建两个子进程P1和P2。让P1和P2分别向管道各写一句话: child process P1 is sending messages! child process P2 is sending messages! 父...
  • 计算机操作系统实验-进程通信(一)
  • 操作系统实验 基于管道的进程通信实验
  • 操作系统课程实验报告 实习题目 进程间基于消息队列的通信 指导教 学生姓名 学 号 日 期 实现工具 C 语言 实现环境 Linux 系统 实验目的 系统了解linux 系统的通信机构IPC 掌握IPC 中消息通信机 制理解消息通信的...
  • Linux——进程通信 一、实验目的 (1) 熟悉并掌握管道机制,并实现进程间通信 (2) 熟悉并掌握共享内存机制,并实现进程间通信 二、实验内容 任务一: (1)阅读以上父子进程利用管道进行通信的例子(例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)的区别

     

    展开全文
  • 通过Linux 系统中管道通信机制,加深对于进程通信概念的理解,观察和体验并发进程间的通信和协作的效果 ,练习利用无名管道进行进程通信的编程和调试技术。 管道pipe是进程间通信最基本的一种机制,两个进程可以通过...

    一、实验时间

    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的输出结果
    在这里插入图片描述

    展开全文
  • 操作系统实验模板,实验环境是linux,实验内容是进程间的软中断通信
  • 5、了解什么是信号,利用信号量机制熟悉进程间软中断通信的基本原理, 6、熟悉消息传送的机理 ,共享存储机制 。 二、 实验环境 Ubuntu 20.10,gcc编译器 三、 实验内容 编写一段程序,使用系统调用fork( )创建两...
  • 操作系统实验——进程通信 参考资料 https://www.cnblogs.com/52php/p/5862114.html https://www.cnblogs.com/52php/p/5861372.html 1.实验要求 1、进程通信 编写一段程序,实现进程的管道通信。 使用系统调用 ...
  • 实验报告详细描述了进程通信的实现原理,使用管道以及信号实现进出那个间通信,附有源代码实现。
  • (1) 阅读以上父子进程利用管道进行通信的例子(例1),写出程序的运行结果并分析。 (2) 编写程序:父进程利用管道将一字符串交给子进程处理。子进程读字符串,将里面的字符反向后再交给父进程,父进程最后读取并打印...
  • 修改对话框标题 删除默认控件 使用控件 自动弹出
  • 福州大学Linux 操作系统设计实践报告之进程通信,进程间通信之命名管道,进程间的通信之消息队列
  • 实验四 进程通信实验 一、实验目的 1、了解什么是信号。 2、熟悉LINUX系统进程之间软中断通信的基本原理。 3、理解进程的同步关系。 4、了解什么是管道。 5、熟悉UNIX/LINUX支持的管道通信方式。 二、...
  • 操作系统实验完整报告 在Linux系统中使用系统调用fork()创建两个子进程,使用系统调用pipe()建立一个管道,两个子进程分别向管道各写一句话: Child process 1 is sending a message! Child process 2 is sending a...
  • 苏州大学操作系统原理实验实验报告第二个实验。 使用内存共享的方式进行进程通信,真正的实现通信,而非单个进程的伪通信。 使用MFC的窗口模式实现的。
  • 实验四:进程通信(二) 实验目的: 学习如何利用消息缓冲队列进行进程间的通信,并加深对消息缓冲队列通信机制的理解。 实验内容: (1) 了解系统调用msgget()、msgsnd()、msgrcv()、msgctl()的功能和实现过程。 (2) ...
  • 进程之间通讯实验报告,包含 1.(1)进程的创建 2.(2)进程控制 3.(3)进程间信号通信 4.(4)进程的管道通信 编写程序,创建两个子进程。当此程序运行时,系统中有一个父进程和两个子进程。父进程在屏幕上显示...
  • 学习如何利用管道机制或消息缓冲队列进行进程间的通信
  • 操作系统实验四:Linux下进程管道通信 任务1:使用Pipe创建管道,创建一个子进程,子进程向父进程发送消息“I am your son!”,父进程接收到子进程的消息后,显示在屏幕上,并向子进程发送“I am your father!”。子...
  • 要求在该程序中还要使用进程的睡眠、进程图象改换、父进程等待子进程终止、信号的设置与传送(包括信号处理程序)、子进程的终止等有关进程系统调用。 分别利用UNIX的消息通信机制、共享内存机制(用信号灯实施...
  • 文章目录操作系统实验三、进程通信一、实验目的二、实验内容三、设计原理(或方案)及相关算法四、结果分析五、源代码 操作系统实验三、进程通信 一、实验目的 ​ 1、了解和熟悉Linux支持的消息通信机制、管道道通信...
  • 计算机操作系统实验-进程通信(二)
  • 程的创建实验、进程的控制实验、进程互斥实验、守护进程实验、 信号机制实验、进程的管道通信实验、消息的发送与接收实验、 共享存储区通信
  • 运行进程管理及进程通信(一)中给出的例子,查看自己运行的结果,并进行分析。  程序1 #include "stdio.h" main() { int i,j,k; if (i=fork()) { j=wait(); printf("Parent Process!\n"); printf("i=%d,j=%d,k=%...
  • 杀死运行进程以及进程之间通信等功能。 PCB结构通常包括以下信息:进程名,进程优先数,轮转时间片,进程所占用的CPU时间,进程的状态,当前队列指针等。可根据实验的不同,PCB结构的内容可以作适当的增删。
  • 操作系统实验--进程通信

    千次阅读 2020-09-27 21:00:28
    学生独立设计并实现消息传递系统进程间交换数据的任务。 三、实验原理和设计思路 在Linux系统下用signal()函数进行进程间通信,pipe()函数创建管道进行数据传送。 四、源代码 1.软中断通信 #include<unistd.h>...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,437
精华内容 16,974
关键字:

操作系统进程通信实验

友情链接: 101400040_exe.zip