实验2-进程和进程通信(网络)-全

合集下载

《Linux操作系统设计实践》实验二：进程通信

《Linux操作系统设计实践》实验二:进程通信实验目的:进一步了解和熟悉 Linux 支持的多种 IPC 机制,包括信号,管道,消息队列,信号量,共享内存。

实验环境: redhat实验内容:(1)进程间命名管道通信机制的使用:使用命名管道机制编写程序实现两个进程间的发送接收信息。

(2)进程间消息队列通信机制的使用:使用消息队列机制自行编制有一定长度的消息(1k 左右)的发送和接收程序。

(3)进程间共享存储区通信机制的使用:使用共享内存机制编制一个与上述(2)功能相同的程序。

并比较分析与其运行的快慢。

实验代码验证:(1).使用命名管道机制编写程序实现两个进程间的发送接收信息。

#include <stdio.h>#include <stdlib.h>#define FIFO_FILE "MYFIFO"int main(int argc, char *argv[]){FILE *fp;int i;if (argc<=1){printf("usage: %s <pathname>\n",argv[0]); exit(1);}if ((fp = fopen(FIFO_FILE, "w")) == NULL) {printf("open fifo failed. \n");exit(1);}for (i = 1; i < argc; i++){if (fputs(argv[i],fp) == EOF){printf("write fifo error. \n");exit(1);}if (fputs(" ",fp) == EOF){printf("write fifo error. \n"); exit(1);}}fclose(fp);return 0;}#include <stdio.h>#include <stdlib.h>#include <sys/stat.h>#include <unistd.h>#include <linux/stat.h>#define FIFO_FILE "MYFIFO"int main(){FILE *fp;char readbuf[80];if ((fp = fopen(FIFO_FILE, "r")) == NULL) {umask(0);mknod(FIFO_FILE, S_IFIFO | 0666, 0);}else{fclose(fp);}while (1){if ((fp = fopen(FIFO_FILE, "r")) == NULL) {printf("open fifo failed. \n");exit(1);}if (fgets(readbuf, 80, fp) != NULL){printf("Received string :%s \n", readbuf); fclose(fp);}else{if (ferror(fp)){printf("read fifo failed.\n");exit(1);}}}return 0;}实验结果:Server.c将client.c写入的字符输出。

计算机操作系统实验-进程通信(二)

1 ．实验目的学习如何利用消息缓冲队列进行进程间的通信，并加深对消息缓冲队列通信机制的理解。

2 ．实验内容(1) 了解系统调用msgget()、msgsnd()、msgrcv()、msgctl()的功能和实现过程。

(2) 编写一段程序，使其用消息缓冲队列来实现父进程和子进程之间的通信。

父进程先建立一个关键字为MSGKEY(如75)（即#define MSGKEY 75）的消息队列，然后等待接收类型为1的消息；在收到请求消息后，它便显示字符串“serving for client ”和接收到的子进程的进程标识数，表示正在为子进程服务；然后再向子进程发送一应答消息，该消息的类型是该子进程的进程标识数，而正文则是父进程自己的标识数。

子进程则向消息队列发送类型为1的消息(消息的正文为自己的进程标识数)，以取得父进程的服务，并等待父进程发来的应答；然后显示字符串“receive reply from ”和接收到的父进程的标识数。

消息的结构为：struct msgform{long mtype;//消息类型char mtext[1024];//消息正文 };3 ．实验步骤(1) 了解系统调用msgget()、msgsnd()、msgrcv()、msgctl()的功能和实现过程。

msgget（）功能：得到消息队列标识符或创建一个消息队列对象msgctl（）功能：获取和设置消息队列的属性msgsnd （）功能：将消息写入到消息队列msgrcv（）功能：从消息队列读取消息(2) 编写一段程序，使其用消息缓冲队列来实现父进程和子进程之间的通信。

操作系统实验2 进程通信

仲恺农业工程学院实验报告纸
计算机科学与工程（院、系）网络工程专业班组《操作系统》
学号姓名实验日期2011-5-24 教师评定
实验二进程通信
一．实验目的：
通过实验使学生进一步了解进程之间的各种通信方式、基本原理和不同操作系统中具体的实现。

基本能达到下列具体的目标：
1、理解进程消息通信的概念，如何实现两个创建进程之间的数据传递。

2、理解进程共享变量的进程通信。

二．实验内容：
1.选择Window或Linux，并选择该操作系统中一种进程通信的方式。

2.查找该进程通信的API使用方式，设计出一个合适的应用程序。

3.采用java语言实现该应用程序。

三．实验步骤：
这里可以实现两个人在同一局域网的聊天，程序可以自动扫描上线的用户。

如果需要与其中的用户进行交谈，则只需双击用户列表，输入对方IP，便可在下面的输入框内输入信息进行发送。

这个是三个人之间进行交谈，但是只能够实现相互两个人之间进行通信，方式跟上面的差不多。

但是三个人都可以看到发送的信息。

本机上的交谈信息
其他用户上的信息
四．实验心得:
这次的实验一开始是在课上有简单的弄了下，后来跟计算机网络的课程设计题目——聊天软件设计差不多一致，于是便这个当做了课题来进行课程设计，通过实现简单的聊天程序来完成进程间的通信。

这次的实验采用基于Java的程序设计技术，要用到很多Java socket的知识。

刚开始也得从网上找一些代码来看和了解一些新的知识。

操作系统实验进程与进程通信

计算机工程学院实验报告课程名称：操作系统实验班级实验成绩：指导教师：姓名：实验项目名称：进程与进程通信学号：上机实践日期：2009-11-13实验项目编号：实验二组号：上机实践时间：2学时一、目的1、深刻理解进程和线程的概念；2、掌握线程和进程的差别以及与之相适应的通信方式；3、掌握在Linux环境下创建进程： fork()的应用；4、了解用fork()创建进程、以及整个程序的运行过程；5、掌握多进程的程序设计与进程之间通信的方法；6、掌握共享内存、信号灯集实现进程通信的方法；7、理解、掌握Linux下文件系统，以及其安装与卸载过程。

二、实验内容1、在Linux环境下，用fork()创建多个进程，分别运行不同的函数；2、一部分进程代表读者，一部分进程代表写者；用共享内存、信号灯集机制实现各个读者、写者进程之间的通信；3、掌握shmget()、shmat()、shmctl()以及semget()、semctl()、semop()等函数在进程通信中的使用方法；4、用信号灯加PV操作实现进程间的互斥与同步。

三、实验环境1、操作系统：Red Hat Linux四、实验原理1、枚举数据类型，在信号灯集初始化时使用。

该结构在sys/sem.h中没有定义，必须程序设计者自行定义。

其中：semid—已经创建的信号灯集ID，sn—操作的元素的IDunion semun{int val;struct semid_ds *buf;ushort *array;};2、对信号灯集中的某个元素进行P操作。

首先要定义一个sembuf 类型的变量（该类型已经在sys/sem.h中预定义，可以直接引用），然后对该变量的各个元素进行赋值，注意进行P操作，主要是sem_op元素赋值为 -1。

其中：semid—已经创建的信号灯集ID，sn—操作的元素的IDvoid down(int semid,int sn){/* define P operating*/struct sembuf op;op.sem_num=sn;op.sem_op=-1;op.sem_flg=0;semop(semid,&op,1);}3、对信号灯集中的某个元素进行V操作。

进程通讯管理实验报告(3篇)

第1篇一、实验目的1. 理解进程通信的概念和原理；2. 掌握进程通信的常用机制和方法；3. 能够使用进程通信机制实现进程间的数据交换和同步；4. 增强对操作系统进程管理模块的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C3. 开发环境：GCC三、实验内容1. 进程间通信的管道机制2. 进程间通信的信号量机制3. 进程间通信的共享内存机制4. 进程间通信的消息队列机制四、实验步骤1. 管道机制（1）创建管道：使用pipe()函数创建管道，将管道文件描述符存储在两个变量中，分别用于读和写。

（2）创建进程：使用fork()函数创建子进程，实现父子进程间的通信。

（3）管道读写：在父进程中，使用read()函数读取子进程写入的数据；在子进程中，使用write()函数将数据写入管道。

（4）关闭管道：在管道读写结束后，关闭对应的管道文件描述符。

2. 信号量机制（1）创建信号量：使用sem_open()函数创建信号量，并初始化为1。

（2）获取信号量：使用sem_wait()函数获取信号量，实现进程同步。

（3）释放信号量：使用sem_post()函数释放信号量，实现进程同步。

（4）关闭信号量：使用sem_close()函数关闭信号量。

3. 共享内存机制（1）创建共享内存：使用mmap()函数创建共享内存区域，并初始化数据。

（2）映射共享内存：在父进程和子进程中，使用mmap()函数映射共享内存区域。

（3）读写共享内存：在父进程和子进程中，通过指针访问共享内存区域，实现数据交换。

（4）解除映射：在管道读写结束后，使用munmap()函数解除映射。

4. 消息队列机制（1）创建消息队列：使用msgget()函数创建消息队列，并初始化消息队列属性。

（2）发送消息：使用msgsnd()函数向消息队列发送消息。

（3）接收消息：使用msgrcv()函数从消息队列接收消息。

（4）删除消息队列：使用msgctl()函数删除消息队列。

进程控制与进程通信程序实验报告

进程控制与进程通信程序实验报告一、引言进程是计算机系统中最基本的概念之一，是操作系统中最小的资源管理单位。

进程控制与进程通信是操作系统中重要的内容，涉及到进程的创建、调度和终止，以及进程间的信息传递和同步管理。

本实验旨在通过编写进程控制与进程通信程序，加深对操作系统中进程管理和通信机制的理解。

二、实验目的1. 理解进程的概念和特点，掌握进程的创建、调度和终止方法。

2. 掌握进程通信的基本原理和方法，包括共享内存、管道、消息队列和信号量等。

3. 能够编写简单的进程控制和进程通信程序。

三、实验内容1. 进程控制实验：编写一个程序，实现进程的创建、调度和终止。

通过调用系统调用函数，创建多个子进程，并通过进程控制函数实现父子进程的协作与同步。

2. 进程通信实验：编写一个程序，实现进程间的信息传递和同步管理。

通过共享内存、管道、消息队列或信号量等机制，实现不同进程之间的数据交换和共享。

四、实验步骤1. 进程控制实验：（1）创建父进程和子进程：使用fork()函数创建子进程，并通过判断返回值来区分父子进程。

（2）调度子进程：使用wait()函数等待子进程的结束，以实现父子进程的同步。

（3）终止子进程：使用exit()函数终止子进程的运行。

2. 进程通信实验：（1）共享内存：使用shmget()函数创建共享内存段，使用shmat()函数映射共享内存到进程的地址空间，实现共享数据的读写。

（2）管道：使用pipe()函数创建管道，使用fork()函数创建子进程，通过读写管道实现进程间的数据传输。

（3）消息队列：使用msgget()函数创建消息队列，使用msgsnd()函数向消息队列发送消息，使用msgrcv()函数从消息队列接收消息，实现进程间的消息传递。

（4）信号量：使用semget()函数创建信号量，使用semop()函数对信号量进行P操作和V操作，实现进程间的同步和互斥。

五、实验结果通过实验，我们成功实现了进程的创建、调度和终止，以及进程间的信息传递和同步管理。

进程和进程间通信

进程和进程间通信进程是操作系统中的一个基本概念，它代表了一个正在运行的程序实例。

在现代操作系统中，多个进程可以同时运行，并且需要进行相互之间的通信和协调。

进程间通信（Inter-Process Communication，IPC）是指不同进程之间进行数据交换和共享的机制。

一、进程间通信的需求与作用进程间通信的需求主要体现在以下几个方面：1. 数据共享：不同进程可能需要共享数据，以便实现信息的交换和共同处理。

2. 信息传递：进程之间可能需要进行消息的传递，以便进行协调和同步。

3. 资源共享：进程可能需要共享系统资源，如文件、设备等。

进程间通信的作用主要包括：1. 提高系统性能：进程间通信可以使不同进程并发执行，提高系统整体的运行效率。

2. 实现协作：不同进程之间可以交换信息、协调工作，实现更复杂的任务。

3. 实现分布式计算：通过进程间通信，可以将任务分布到不同的进程或计算机上进行并行处理。

二、进程间通信的方式在实际应用中，进程间通信可以通过多种方式来实现：1. 管道（Pipe）：管道是一种半双工的通信方式，可以用于具有亲缘关系的进程之间进行通信。

常见的管道实现有匿名管道和有名管道。

2. 消息队列（Message Queue）：消息队列是一种通过系统内核提供的消息缓冲区进行通信的方式，具有高度灵活性和可靠性。

3. 信号量（Semaphore）：信号量是一种计数器，用于实现进程之间的同步和互斥操作，常用于控制对共享资源的访问。

4. 共享内存（Shared Memory）：共享内存是一种将同一块物理内存映射到多个进程的通信方式，可以实现数据的快速共享。

5. 套接字（Socket）：套接字是一种通信机制，可以用于实现不同计算机之间的进程间通信，常用于网络编程。

以上只是进程间通信的一些常见方式，实际上还有其他方式如信号、文件、RPC（远程过程调用）等。

在选择具体的通信方式时，需要根据实际场景需求进行综合考虑。

实验二进程通信 Linux实验报告

实验报告学号_____ 姓名____ ___ 成绩实验二进程通信【实验目的和要求】1、了解进程通信的概念及方法；2、了解信号量、管道；3、掌握信号量、管道和命名管道编程方法。

【实验内容】1、利用命名管道实现单机QQ聊天；2、撰写实验报告；【实验原理】1、信号量（semaphore）是为那些访问相同资源的进程以及同一进程不同线程之间提供的一个同步机制。

它不是用于传输数据，而只是简单地协调对共享资源的访问。

信号量包含一个计数器，表示某个资源正在被访问和访问的次数，用来控制多进程对共享数据的访问。

一旦成功拥有了一个信号量，对它所能做的操作只有两种：请求和释放。

当执行释放操作时，系统将该信号值减1（如果小于零，则设置为零）；当执行请求操作时，系统将该信号值加1，如果加1后的值大于设定的最大值，那么系统将会挂起处理进程，直到信号值小于最大值为止。

Tuxedo 用信号量来确保在某一时刻只有一个进程对某一块共享内存进程访问。

信号量配置太低会导致Tuxedo系统应用程序无法启动。

2、管道分为两种：管道和命名管道。

管道是UNIX系统IPC的最古老形式，并且所有的UNIX系统都提供这种通信机制。

可以在有亲缘关系（父子进程或者是兄弟进程之间）进行通信，管道的数据只能单向流动，如果想双向流动，必须创建两个管道。

管道应用的一个重大缺陷就是没有名字，因此只能用于亲缘进程之间的通信。

后来以管道为基础提出命名管道（named pipe，FIFO）的概念，该限制得到了克服。

FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。

这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间），因此，通过FIFO不相关的进程也能交换数据。

值得注意的是，FIFO严格遵循先进先出（first in first out）规则，对管道及FIFO的读总是从开始处返回数据，对它们的写则是把数据添加到末尾。

进程通信实验报告

操作系统实验报告(三)进程通信专业：软件工程姓名：XXX班级：XXX学号：XXX指导老师：XXX2013/12/3实验三：进程通信一．实验目的加深对进程通信的理解。

熟悉消息通信机制、共享存储器通信机制，进一步认识其与信号量通信的区别。

二．实验内容1）编程实现基于消息缓冲队列机制的进程通信数据结构和通信原语（创建消息、发送消息、接收消息）；2)最后编写主函数对所做工作进行测试三．实验步骤(1)任务分析：实现进程通信，需要建立创建消息函数、发送消息函数、接收消息函数，需要用到进程中的Send和Receive原语(2)程序设计：a.总体设计：创建两个windows窗体应用程序，分别用于发送消息和接收消息，可以采用C#实现。

b.具体实现①创建应用程序Sendmessage，在windows窗体上放置一个文本框输入要发送的消息，一个按钮控件，单击按钮控件发送消息，编辑ButtonOnclick()事件，来编辑发送消息函数，发送后弹出消息发送成功对话框。

②创建应用程序Receivemessage，在windows窗口上放置一个文本框用于接收消息，放置一个Button按钮，并编辑ButtonOnclick()事件，来编辑接收消息函数，成功后弹出成功接收对话框。

③程序中的发送接收需要用到系统中的函数，将在实验代码中给与提示。

(4)调试与测试实验结果：发送消息：接收消息：四．实验总结进程通信实验主要是通过通信原语机制创建消息发送函数和消息接收函数来模拟实现进程间的通信，在实验过程中，一些通信机制不是太明确，通过在网上查找资料以及和同学们交流，最终完成了进程通信实验，通过这次实验，我对进程间的通信原理多了更深一步的了解，为学习操作系统知识建立了良好的实践基础。

五．附录①发送消息函数源码：using System;using System.Collections.Generic;using ponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Runtime.InteropServices;namespace WindowsFormsApplication1{public partial class Form1 : Form{public Form1(){InitializeComponent();}[DllImport("User32.dll", EntryPoint = "SendMessage")] private static extern int SendMessage(int hWnd,int Msg,int wParam,ref COPYDATASTRUCT lParam);[DllImport("User32.dll", EntryPoint = "FindWindow")] private static extern int FindWindow(string lpClassName, string lpWindowName);public struct COPYDATASTRUCT{public IntPtr dwData;public int cbData;[MarshalAs(UnmanagedType.LPStr)]public string lpData;}const int WM_COPYDATA = 0x004A;private void button1_Click(object sender, EventArgs e){Sent();MessageBox.Show("信息发送成功|", "提示？", MessageBoxButtons.OK);}private void Sent(){int WINDOW_HANDLER = FindWindow(null, @"接受信息");if (WINDOW_HANDLER != 0){byte[] sarr =System.Text.Encoding.Default.GetBytes(this.textBox1.Text);int len = sarr.Length;COPYDATASTRUCT cds;cds.dwData = (IntPtr)100;cds.lpData = this.textBox1.Text;cds.cbData = len + 1;SendMessage(WINDOW_HANDLER, WM_COPYDATA, 0, ref cds); } }}}②接收消息函数源码：using System;using System.Collections.Generic;using ponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Runtime.InteropServices;namespace WindowsFormsApplication2{public partial class Form1 : Form{string message;public Form1(){InitializeComponent();}public struct COPYDATASTRUCT{public IntPtr dwData;public int cbData;[MarshalAs(UnmanagedType.LPStr)]public string lpData;}const int WM_COPYDATA = 0x004A;private void button1_Click(object sender, EventArgs e) {Receive();}private void Receive(){textBox1.Text += "收到信息为"+ message + Environment.NewLine;MessageBox.Show("成功接收!");}protected override void DefWndProc(refSystem.Windows.Forms.Message m){switch (m.Msg){case WM_COPYDATA:COPYDATASTRUCT mystr = new COPYDATASTRUCT();Type mytype = mystr.GetType();mystr = (COPYDATASTRUCT)m.GetLParam(mytype); message = mystr.lpData;break;default:base.DefWndProc(ref m);break;}}}}。

进程之间的通信实验

实验：进程之间的通信管道1．Pipe函数与进程通信下面实验为使用管道进行父子进程间通信。

程序首先判断参数是否合法，因为输入的字符将从父进程通过发送到子进程中。

然后，调用pipe函数创建父子进程用于通信的管道。

使用fork函数创建子进程时，子进程会获得与父进程相同的资源，其中包括文件描述符信息。

因此，调用fork函数须在pipe函数调用前。

当父子进程通过管道进行通信时，files[1]为用于数据写入的文件描述符.因此,在子进程中,要读取管道中的数据可以调用read函数，而读取得文件描述符为files[0]。

对于父进程而言，写入数据需要调用write 函数，要写入的文件描述为files[1]。

#include <stdio.h>#include <unistd.h>int main(int argc,char* argv[]){int f_des[2];int pid;char msg[BUFSIZ];if(argc!=2){printf("Usage: %s message\n",argv[0]);return 1;}if(pipe(f_des)==-1){perror("cannot create the IPC pipe");return 1;}pid=fork();if(pid==-1){perror("cannot create new process");return 1;}else if(pid==0){close(f_des[1]);if(read(f_des[0],msg,BUFSIZ)==-1){perror("child process cannot read data from pipe");return 1;}elseprintf("in child process, receive message: %s\n",msg);_exit(0);}else {close(f_des[0]);if(write(f_des[1],argv[1],strlen(argv[1]))==-1){perror("parent process cannot write data to pipe");return 1;}elseprintf("in parent process, send message: %s\n",argv[1]);wait(NULL);_exit(0);}return 0;}2. Shell管道重订向的实现实现了在SHELL中的两个命令的组合。

进程控制与进程通信程序实验报告

进程控制与进程通信程序实验报告进程控制与进程通信程序实验报告本次实验主要涉及进程控制和进程通信两个方面。

进程控制是指操作系统对进程的管理和控制，包括创建、撤销、挂起、恢复等操作。

进程通信是指进程之间进行信息交换的过程，包括共享内存、管道、消息队列等方式。

在本次实验中，我们使用了C语言编写了两个程序，一个是父进程程序，一个是子进程程序。

父进程程序通过fork()函数创建子进程，然后通过wait()函数等待子进程结束。

子进程程序则通过exec()函数执行另一个程序。

这个程序是一个简单的计算器程序，可以进行加减乘除运算。

在进程通信方面，我们使用了共享内存的方式进行进程间通信。

共享内存是指多个进程共享同一块内存空间，可以实现进程间的数据共享。

在本次实验中，我们使用了shmget()函数创建共享内存，shmat()函数将共享内存映射到进程的地址空间中，shmdt()函数将共享内存从进程的地址空间中分离，shmctl()函数控制共享内存的状态。

在父进程程序中，我们使用了共享内存来传递两个操作数和操作符。

父进程程序首先创建共享内存，然后将两个操作数和操作符写入共享内存中。

子进程程序通过共享内存读取这些数据，并进行相应的计算。

计算结果再通过共享内存传递回父进程程序，父进程程序读取共享内存中的结果并输出。

本次实验的结果表明，进程控制和进程通信是操作系统中非常重要的概念。

掌握了这些概念，可以更好地理解操作系统的工作原理，也可以更好地编写高效的程序。

同时，共享内存是一种非常实用的进程通信方式，可以在多个进程之间实现数据共享，提高程序的效率。

总之，本次实验让我们更深入地了解了进程控制和进程通信的概念和实现方式。

通过编写程序，我们掌握了fork()、wait()、exec()、shmget()、shmat()、shmdt()、shmctl()等函数的使用方法，也更好地理解了操作系统的工作原理。

进程控制与进程通信程序实验报告

进程控制与进程通信程序实验报告1. 背景进程控制与进程通信是操作系统的重要概念之一，它们在现代计算机系统中起到了至关重要的作用。

进程控制是指操作系统对进程的创建、执行、中止和切换等各种操作的管理和控制，进程通信则是指进程之间通过各种方式传递信息和实现协作的机制。

在本次实验中，我们需要编写一个进程控制与进程通信程序。

通过实现进程的创建、执行和中止等基本操作，并通过进程通信机制进行信息传递，实现多个进程之间的协作。

本实验将帮助我们进一步理解和掌握进程控制与进程通信的原理和操作。

2. 分析2.1 实验要求本次实验要求我们编写一个进程控制与进程通信程序，实现以下功能：1.创建一个主进程和多个子进程，并实现进程的执行和切换；2.子进程之间通过进程通信机制传递信息；3.实现多个子进程之间的协作，完成指定的任务。

2.2 系统设计为了满足实验的要求，我们可以按照以下步骤设计我们的系统：1.创建主进程和多个子进程：使用操作系统提供的进程创建函数，创建一个主进程和多个子进程。

主进程将负责协调子进程的执行和协作。

2.进程执行和切换：使用操作系统提供的进程执行和切换函数，实现进程的执行和切换操作。

主进程可以通过改变进程的状态和优先级来控制进程的执行和切换。

3.进程通信机制：使用操作系统提供的进程通信机制，如消息队列、共享内存等，实现子进程之间的信息传递。

可以定义统一的消息格式，并使用相应的函数进行消息的发送和接收。

4.进程协作：根据实验要求，设计子进程之间的协作方式。

可以使用信号量、条件变量等机制来实现多个子进程之间的同步和互斥。

2.3 实验结果实验的结果将是一个能够创建多个子进程，并通过进程通信进行协作的程序。

程序将实现以下功能：1.主进程创建多个子进程，并通过改变进程的状态和优先级来控制进程的执行；2.子进程通过进程通信机制传递信息，完成指定的任务；3.子进程之间通过协作实现同步和互斥，保证任务的正确执行。

3. 实验步骤3.1 创建进程首先，我们需要创建主进程和多个子进程。

实验二进程通信实验

实验二进程通信实验1.实验内容设有二元函数f(x,y) = f(x) + f(y)其中：f(x) = f(x-1) * x (x >1)f(x)=1 (x=1)f(y) = f(y-1) + f(y-2) (y> 2)f(y)=1 (y=1,2)请编程建立3 个并发协作进程，它们分别完成f(x,y)、f(x)、f(y) 2.实验代码（附件中）3．在当前目录中建立Makefile文件5.使用make命令编译连接生成可执行文件pipetest6.编译成功后执行pipetest7实验要求（1）进程协作：系统中一个进程能影响其他进程或被其他进程所影响，那么该进程是协作的。

在该实验中，子进程x和子进程y 需要来自父进程传输的自变量x和y，而父进程的完成需要来自子进程x和子进程y的计算结果f(x)和f(y)，所以父进程和两个子进程是协作的。

协作进程需要一种进程间通信机制来允许进程相互交换数据与信息。

（2）在实验中采用管道通信，管道是一个单向通信信道，如果进程间要进行双向通信，通常需要定义两个管道。

管道通过系统调用read(), write()函数进行读写操作。

管道通信机制的机理：一种半双工的通信机制，两个进程可以通过管道一个在管道一端向管道发送其输出,给另一进程可以在管道的另一端从管道得到其输入；另外，管道只能用来在具有公共祖先的两个进程之间通信。

管道通信遵循先进先出的原理，并且数据只能被读取一次，当此段数据被读取后，马上会从数据中消失，当管道中的数据被读取后，管道为空，一个随后的read()调用将默认的被阻塞，并等待某些数据写入。

通常会先调用pipe()，然后调用fork()，从而创建从父进程到子进程的IPC通道.。

实验二进程间通信

实验二进程间通信1. 实验目的Linux系统的进程通信机构（IPC）允许在任意进程间大批量地交换数据。

本实验的目的是了解和熟悉Linux支持的消息通信机制、共享存储区和管道通信机制。

2. 实验准备阅读Linux系统的msg.c、sem.c和shm.c等源码文件，熟悉Linux的三种通信机制。

3. 实验内容⑴消息的创建、发送和接收。

要求使用系统调用msgget ( )，msgsnd ( )，msgrev ( )及msgctl ( )编制长度为1K的消息的发送和接收程序，运行程序并观察结果，说明控制消息队列系统调用msgctl ( )在此起什么作用。

⑵共享存储区的创建、附接和断接。

要求使用系统调用shmget ( )，shmat ( )，sgmdt ( )，shmctl ( )，编制一个与上述功能相同的程序。

⑶进程的管道通信。

使用系统调用pipe ( )建立一条管道线，两个子进程P1和P2分别向管道各写一句话：Child 1 is sending a message!Child 2 is sending a message!而父进程则从管道中读出来自于两个子进程的信息并显示在屏幕上，要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。

4. 实验指导⑴消息的创建、发送和接收。

<程序设计>为了便于操作和观察结果，用一个程序作为“引子”，先后fork ( )两个子进程SERVER和CLIENT进行通信，SERVER端建立一个KEY为75的消息队列，等待其他进程发来的消息。

当遇到类型为1的消息时，则作为结束信号，取消该队列并退出SERVER。

SERVER每接收到一个消息后显示一句“( server) received”。

CLIENT端使用KEY为75的消息队列，先后发送类型从10到1的消息后退出。

最后的一个消息即是SERVER端需要的结束信号。

CLIENT每发送一条消息后显示一句“（client）sent”。

操作系统实验报告2-进程间通信

信号本质：信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后，功能更加强大，除了基本通知功能外，还可以传递附加信息。进程用kill( )向一个进程或一组进程发送一个信号；当一个进程要进入或退出一个低优先级睡眠状态时，或一个进程即将从核心态返回用户态时，核心都要检查该进程是否已收到软中断
1．了解Linux中的信号，熟悉Linux系统中进程之间软中断通信的基本原理。
2．Linux系统的进程通信机构（IPC）允许在任意进程间大批量地交换数据，学习如何利用消息缓冲队列进行进程间的通信，并加深对消息通信机制的理解。
二、实验环境(实验设备)
Windows 2000 + VMWare +RedHatLinux8
main( )
{
int p1,p2,stdout;
while((p1=fork( ))= =-1); /*创建子进程p1*/
if (p1>0)
{
while((p2=fork( ))= =-1); /*创建子进程p2*/
if(p2>0)
{
wait_mark=1;
signal(SIGINT,stop); /*接收到^c信号，转stop*/
signal(17,stop); /*接收到软中断信号17，转stop*/
waiting( );
lockf(stdout,1,0);
printf("Child process 2 is killed by parent!\n");

操作系统实验---进程通信

实验报告实验题目姓名：学号：课程名称：操作系统实验所在学院：信息科学与工程学院专业班级：计算机任课教师：五、实验数据（现象）处理分析信号机制实验建立文件和可执行文件：信号机制实验运行结果：屏幕上无反应，按下^C 后，显示Parent process is killed!进程的管道通信可执行文件：管道通信实验运行结果：延迟5 秒后显示child 1 process is sending message!再延迟5 秒child 2 process is sending message!附加问题：在不修改程序的情况下要输出期望的结果，可以单独向父进程发送SIGINT 信号，这样即可避免子进程由于收到SIGINT 信号执行默认操作而自我终止，具体实现方法：（该实验中程序名为：demo2）首先让程序在后台运行，命令：./demo2&执行该命令后，会在后台生成3 个进程，使用ps 命令可以查看到它们的PID （相对小的PID 应该为父进程的PID，原因是创建时间相对早）。

然后向后台的父进程发送SIGINT 信号，命令：kill –SIGINT 28664 (其中28664为父进程的PID)运行结果如下所示：进程通信消息机制实验可执行文件：进程通信消息机制实验运行结果1：进程通信消息机制实验运行结果2：六、实验结论通过实验了解和熟悉了LINUX 支持的信号量机制、管道机制、消息通信机制及共享存储区机制的基本原理和基本概念。

对信号和中断有了进一步的理解，能够分辨出两者的区别和相似点。

观察实验现象知道了信号的发送方式和处理方式。

掌握了信号的发送，是指由发送进程把信号送到指定进程的信号域的某一位上。

如果目标进程正在一个可被中断的优先级上睡眠，核心便将它唤醒，发送进程就此结束。

一个程可能在其信号域中有多个位被置位，代表有多种类型的信号到达，但对于一类信号，进程却只能记住其中的某一个。

通过本次实验最终目的还是全面了解进程的各种机制以及处理方法。

实验二进程和进程通信

实验二进程和进程通信实验二进程和进程通信一、实验目的1、通过使用进程和进程通信方面的系统调用的，加深理解有关进程方面的基本概念。

通过实验对进程有进一步的感性认识，掌握系统V的IPC机制。

二、实验内容1、设计一个程序，创建一个子进程，使父子进程合作，协调地完成某一功能。

要求在该程序中还要使用进程的睡眠、进程图象改换、父进程等待子进程终止、信号的设置与传送（包括信号处理程序）、子进程的终止等有关进程的系统调用。

2、分别利用UNIX的消息通信机制、共享内存机制（用信号灯实施进程间的同步和互斥）实现两个进程间的数据通信。

具体的通信数据可从一个文件读出，接收方进程可将收到的数据写入一个新文件，以便能判断数据传送的正确性（对文件操不熟悉的同学可不必通过读写文件，只要键盘输入和输出至屏幕进行比较即可）。

3、编写一个程序，生成若干个线程，通过这些并发线程的合作，完成较复杂的任务。

通过测试程序的运行结果，比较进程和进程、线程和线程之间对外部变量、静态变量和动态变量的共享方式的相同和不同之处。

三、实验代码3.1 父子进程通信#include#includemain(){int pid,status = 1;void func();signal(SIGUSR1,func); /* 预置信号处理程序,将SIGUSR1设置为func函数的功能*/while ((pid=fork( ))==-1);if (pid) { /* 父进程*/printf("It is the parent process.\n");printf("Parent: will send signal.\n");kill(pid,SIGUSR1); /* 发送信号,即发送执行func函数的信息*/ pid = wait(&status); /* 父进程等待子进程终止*/printf("Child process %d,status=%d \n",pid,status);}else { /* 子进程*/sleep (2); /* 等待接受信号*/printf("It is the child process.\n");printf("Child：signal is received.\n");execvp ("pwd",(char*)0); /* 映像改换,显示当前工作区,exevcp不用给出具体路径,(char*)0指向pwd命令*/printf("execl error.\n"); /* 映像改换失败*/exit(2);}printf ("Parent process finish. \n");}void func (){system("date");}3.2 消息通信/* msgcom.h */#include#include#include#include#define MSGKEY 5678struct msgtype{long mtype;int text;};#include "msgcom.h"main(){ /* 请求进程*/struct msgtype buf;int qid,pid;qid=msgget(MSGKEY,IPC_CREAT|0666); /* MSGKEY为约定的消息队列关键字,访问控制权限为0666 */buf.mtype=1; /* 请求进程发送消息标识为1 */buf.text=pid=getpid(); /* 请求进程发送消息内容为进程标识*/ msgsnd(qid,&buf,sizeof(buf.text), IPC_NOWAIT|04000); /* 发送消息正文长度为buf的大小*/msgrcv(qid,&buf,512,pid,MSG_NOERROR); /* 指定接收mtype=pid的信息，即请求进程发送给服务器处理后的信息*/ printf("Request received a massags from server, type is: %d\n",buf.mtype);}#include "msgcom.h"main(){ /* 服务器进程*/struct msgtype buf;int qid;if((qid=msgget(MSGKEY,IPC_CREAT|0666))== -1)return(-1); /* 出错处理*/while(1){msgrcv(qid,&buf,512,1,MSG_NOERROR); /* 接收所有请求进程发送的消息*/printf("Server receive a request from process %d\n",buf.text);buf.mtype=buf.text; /* 将请求进程的标识数作为mtype的值，以便于请求进程识别*/msgsnd(qid,&buf,sizeof(int),IPC_NOW AIT|04000); /* 将消息发送给请求进程*/ }}3.3 共享内存#include#include#include#include#include#define SHMKEY 18001 /* 共享内存关键字*/#define SHMKEY2 18002#define SIZE 1024 /* 共享内存长度*/#define SEMKEY1 19001 /* 信号灯组1关键字*/#define SEMKEY2 19002 /* 信号灯组2关键字*/#define SEMKEY3 19003 /* 信号灯组3关键字*/static void semcall(sid,op)int sid,op;{struct sembuf sb;sb.sem_num = 0; /* 信号灯编号0 */sb.sem_op = op; /* 信号灯操作数加1或减1 */sb.sem_flg = 0; /* 操作标志*/if(semop(sid,&sb,1) == -1)perror("semop"); /* 出错处理*/};int creatsem(key) /* 信号灯组创建及初始化程序*/key_t key;{int sid;union semun { /* 如sem.h中已定义，则省略*/int val;struct semid_ds *buf;ushort *array;} arg;if((sid=semget(key,1,0666|IPC_CREAT))==-1) /* 创建1个关键字为1的信号灯组,访问控制权限为0666 */perror("semget"); /* 出错处理*/arg.val=1; /* 初值为1 */if(semctl(sid,0,SETV AL,arg)==-1) /* 将信号灯组的第一个信号灯的初值置1 */perror("semctl"); /* 出错处理*/return(sid);}void P(sid)int sid;{semcall(sid,-1); /*对关键字为sid信号灯组值减1，相当于wait */}void V(sid)int sid;{semcall(sid,1); /*对关键字为sid信号灯组值加1，相当于signal */}main(){char *segaddr,*segaddr2;int segid,segid2,sid1,sid2,sid3;if((segid=shmget(SHMKEY,SIZE,IPC_CREAT|0666))==-1) /* 创建共享内存段*/perror("shmget"); /* 出错处理*/if((segid2=shmget(SHMKEY2,SIZE,IPC_CREA T|0666))==-1) /* 创建共享内存段2 */perror("shmget"); /* 出错处理*/segaddr=shmat(segid,0,0); /* 将共享内存映射到进程数据空间*/segaddr2=shmat(segid2,0,0); /* 将共享内存2映射到进程数据空间*/sid1=creatsem(SEMKEY1); /* 创建三个信号灯，初值为1 */sid2=creatsem(SEMKEY2);sid3=creatsem(SEMKEY3);P(sid2); /* 置信号灯2值为0，表示缓冲区1空*/P(sid3); /* 置信号灯3值为0，表示缓冲区2空*/if(!fork()){if(!fork()){while(1){ /* 子进程的子进程，接收和输出*/P(sid3);printf("Received from Parent: %s\n",segaddr2);printf("Received from Grandparent: %s\n",segaddr);V(sid1);}}while(1){ /* 子进程，输入和存储*/P(sid2);scanf("%s",segaddr2);V(sid3);}}while(1) { /* 父进程，输入和存储*/P(sid1);scanf("%s",segaddr);V(sid2);}}3.4 线程#include#include#includeint nthreads = 1; /* 线程执行函数，传入参数为线程序号，传出参数为项: (序号＋1) */ void *dowork (void *params){int j = *(int *)params;int term = j+1;*(int *)params = term;printf ("the thread [%d]: term =%d\n",j,term);}void main(int argc,char **argv){int i;pthread_t threads[100];int pthread_data[100];float mean = 0; /* 平均数*/float variance = 0; /* 方差*/if(argc==2)nthreads = atoi (argv[1]); /* 将命令行字符串参数转换为整数*/for (i=0; i<="">pthread_data [i] = i ;pthread_create (&threads[i], NULL, dowork, &pthread_data[i]); /* 创建线程*/ }for (i=0; i<="">pthread_join (threads [i], NULL); /* 等待子线程结束，汇合结果*/mean += (float)pthread_data[i];}mean = mean / nthreads;for(i=0; i<="">variance += (float)(pthread_data[i]-mean)*(pthread_data[i]-mean);}variance = variance / nthreads;printf("The total threads is %d\n",nthreads);printf("The mean = %f\n", mean);printf("The variance = %f\n",variance);}四、运行结果3.1 父子进程通信父进程向子进程发送的消息为函数system(“date”)即显示日期时间。

进程通信实验报告

西安电子科技大学《操作系统原理》实验报告题目：进程通信实验报告班级： 030912姓名：王增祥学号： 03091168实验内容补充说明：一、分析和设计1．理论分析每个Windows进程都是由一个执行体进程块（EPROCESS）表示。

API函数CreatProcess 可以创建进程，采用管道技术可以实现进程间的相互通信。

建立pipe，进程以及其子进程就可以对该管道进程读写共享，管道读写操作利用，write、read、close进行。

父进程利用pipe 发送消息，子进程利用该pipe接收父进程发来的消息；子进程利用管道向父进程发送应答，父进程利用该pipe接受应答。

2．总体设计1、利用CreatProcess函数创建进程。

2、创建管道，实现进程间的通信二、详细实现1、创建界面，采用Botton、列表框等控件创建父子界面如下图：父进程界面：子进程界面：其中父进程各个空间创建类向导如图：子进程创建类向导如图：2.父进程编写（1）创建管道：（2）创建子进程：（3）消息发送（4）消息接受3.子进程编写（1）发送消息（2）读消息三、实验结果点击创建子进程按钮：在创建子进程之后进行进程间的通信如下图四、心得体会1、从试验的角度了解了进程间是怎样利用管道进行通信的，了解了进程间通信的实际过程2、进一步掌握了MFC的初步编程技巧，知道了怎样调试程序。

3进一步了解了，API函数的应用，明白了怎样进行界面编程。

4、进一步熟悉了在进行进程通信的编写过程中的各个细节。

六、附录Process_Father.cpp#include "stdafx.h"#include "Process_Father.h" //包含已编写的Process_Father.h头文件#include "Process_FatherDlg.h" //包含已编写的Process_FatherDlg.h头文件//进行宏定义#ifdef _DEBUG#define new DEBUG_NEW#undef THIS_FILEstatic char THIS_FILE[] = __FILE__;#endif//创建父进程BEGIN_MESSAGE_MAP(CProcess_FatherApp, CWinApp)//{{AFX_MSG_MAP(CProcess_FatherApp)// NOTE - the ClassWizard will add and remove mapping macros here.// DO NOT EDIT what you see in these blocks of generated code!//}}AFX_MSGON_COMMAND(ID_HELP, CWinApp::OnHelp)END_MESSAGE_MAP()// CProcess_FatherApp constructionCProcess_FatherApp::CProcess_FatherApp(){// TODO: add construction code here,// Place all significant initialization in InitInstance}// The one and only CProcess_FatherApp objectCProcess_FatherApp theApp;// CProcess_FatherApp initializationBOOL CProcess_FatherApp::InitInstance(){AfxEnableControlContainer();#ifdef _AFXDLLEnable3dControls(); // Call this when using MFC in a shared DLL #elseEnable3dControlsStatic(); // Call this when linking to MFC statically #endifCProcess_FatherDlg dlg;m_pMainWnd = &dlg;int nResponse = dlg.DoModal();if (nResponse == IDOK){// TODO: Place code here to handle when the dialog is// dismissed with OK}else if (nResponse == IDCANCEL){// TODO: Place code here to handle when the dialog is// dismissed with Cancel}// Since the dialog has been closed, return FALSE so that we exit the// application, rather than start the application's message pump.return FALSE;}Process_FatherDlg.cpp// Process_FatherDlg.cpp : implementation file//#include "stdafx.h"#include "Process_Father.h"#include "Process_FatherDlg.h"#ifdef _DEBUG#define new DEBUG_NEW#undef THIS_FILEstatic char THIS_FILE[] = __FILE__;#endif///////////////////////////////////////////////////////////////////////////// // CAboutDlg dialog used for App Aboutclass CAboutDlg : public CDialog{public:CAboutDlg();// Dialog Data//{{AFX_DATA(CAboutDlg)enum { IDD = IDD_ABOUTBOX };//}}AFX_DATA// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CAboutDlg)protected:virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL// Implementationprotected://{{AFX_MSG(CAboutDlg)//}}AFX_MSGDECLARE_MESSAGE_MAP()};CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD){//{{AFX_DATA_INIT(CAboutDlg)//}}AFX_DATA_INIT}void CAboutDlg::DoDataExchange(CDataExchange* pDX){CDialog::DoDataExchange(pDX);//{{AFX_DATA_MAP(CAboutDlg)//}}AFX_DATA_MAP}BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)//{{AFX_MSG_MAP(CAboutDlg)// No message handlers//}}AFX_MSG_MAPEND_MESSAGE_MAP()///////////////////////////////////////////////////////////////////////////// // CProcess_FatherDlg dialogCProcess_FatherDlg::CProcess_FatherDlg(CWnd* pParent /*=NULL*/) : CDialog(CProcess_FatherDlg::IDD, pParent){//{{AFX_DATA_INIT(CProcess_FatherDlg)//}}AFX_DATA_INIT// Note that LoadIcon does not require a subsequent DestroyIcon in Win32 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);}void CProcess_FatherDlg::DoDataExchange(CDataExchange* pDX){CDialog::DoDataExchange(pDX);//{{AFX_DATA_MAP(CProcess_FatherDlg)DDX_Control(pDX, IDC_BT_CreateChildProcess, m_BT_CreateChildProcess);DDX_Control(pDX, IDC_Send, m_Send);DDX_Control(pDX, IDC_LISTBOX_Record, m_LISTBOX_Record);DDX_Control(pDX, IDC_EDIT_Message, m_EDIT_Message);//}}AFX_DATA_MAP}BEGIN_MESSAGE_MAP(CProcess_FatherDlg, CDialog)//{{AFX_MSG_MAP(CProcess_FatherDlg)ON_WM_SYSCOMMAND()ON_WM_PAINT()ON_WM_QUERYDRAGICON()ON_BN_CLICKED(IDC_BT_CreateChildProcess, OnBTCreateChildProcess)ON_BN_CLICKED(IDC_Send, OnSend)//}}AFX_MSG_MAPON_MESSAGE(WM_CHILD_SEND,OnReceiveMsg)END_MESSAGE_MAP()///////////////////////////////////////////////////////////////////////////// // CProcess_FatherDlg message handlersBOOL CProcess_FatherDlg::OnInitDialog(){CDialog::OnInitDialog();// Add "About..." menu item to system menu.// IDM_ABOUTBOX must be in the system command range.ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);ASSERT(IDM_ABOUTBOX < 0xF000);CMenu* pSysMenu = GetSystemMenu(FALSE);if (pSysMenu != NULL){CString strAboutMenu;strAboutMenu.LoadString(IDS_ABOUTBOX);if (!strAboutMenu.IsEmpty()){pSysMenu->AppendMenu(MF_SEPARATOR);pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);}}// Set the icon for this dialog. The framework does this automatically // when the application's main window is not a dialogSetIcon(m_hIcon, TRUE); // Set big iconSetIcon(m_hIcon, FALSE); // Set small icon// TODO: Add extra initialization herereturn TRUE; // return TRUE unless you set the focus to a control}void CProcess_FatherDlg::OnSysCommand(UINT nID, LPARAM lParam){if ((nID & 0xFFF0) == IDM_ABOUTBOX){CAboutDlg dlgAbout;dlgAbout.DoModal();}else{CDialog::OnSysCommand(nID, lParam);}}// If you add a minimize button to your dialog, you will need the code below // to draw the icon. For MFC applications using the document/view model, // this is automatically done for you by the framework.void CProcess_FatherDlg::OnPaint(){if (IsIconic()){CPaintDC dc(this); // device context for paintingSendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);// Center icon in client rectangleint cxIcon = GetSystemMetrics(SM_CXICON);int cyIcon = GetSystemMetrics(SM_CYICON);CRect rect;GetClientRect(&rect);int x = (rect.Width() - cxIcon + 1) / 2;int y = (rect.Height() - cyIcon + 1) / 2;// Draw the icondc.DrawIcon(x, y, m_hIcon);}else{CDialog::OnPaint();}}// The system calls this to obtain the cursor to display while the user drags // the minimized window.HCURSOR CProcess_FatherDlg::OnQueryDragIcon(){return (HCURSOR) m_hIcon;}void CProcess_FatherDlg::OnBTCreateChildProcess(){//创建管道SECURITY_ATTRIBUTES sa;sa.nLength=sizeof(SECURITY_ATTRIBUTES);sa.lpSecurityDescriptor=NULL;sa.bInheritHandle=TRUE;::CreatePipe(&hPipeRead,&hPipeWrite,&sa,0);::CreatePipe(&hPipeRead2,&hPipeWrite2,&sa,0);//创建子进程STARTUPINFO StartupInfo;memset(&StartupInfo,0,sizeof(STARTUPINFO)) ;StartupInfo.cb=sizeof(STARTUPINFO);StartupInfo.dwFlags=STARTF_USESTDHANDLES;StartupInfo.hStdInput=hPipeRead;StartupInfo.hStdOutput=hPipeWrite;StartupInfo.hStdError=GetStdHandle(STD_ERROR_HANDLE);PROCESS_INFORMATION ProcessInfo;::CreateProcess("Process_Child.exe",NULL,NULL,NULL,TRUE,0,NULL,NULL,&Startu pInfo,&ProcessInfo);m_BT_CreateChildProcess.EnableWindow(FALSE);}void CProcess_FatherDlg::OnSend(){CString str;char ss[20]="Father:";m_EDIT_Message.GetWindowText(str);DWORD dwWritten;if(!WriteFile(hPipeWrite,str,40,&dwWritten,NULL)){MessageBox(TEXT("写错误"),"警告",MB_OK|MB_ICONWARNING);}CString strWinName = "Process_Child";CWnd *pWnd=CWnd::FindWindow(NULL,strWinName);if(pWnd){pWnd->SendMessage(WM_FATHER_SEND,0,0);strcat(ss,str);m_LISTBOX_Record.InsertString(-1,ss);m_EDIT_Message.SetWindowText("");}else{MessageBox("没有发现子进程","错误");}}void CProcess_FatherDlg::OnReceiveMsg(WPARAM wParam,LPARAM lParam){DWORD dwRead;TCHAR s[40];HANDLE hPipeRead2;hPipeRead2=GetStdHandle(STD_INPUT_HANDLE);if(!ReadFile(hPipeRead,s,40,&dwRead,NULL)){MessageBox(TEXT("读错误！"),"警告",MB_OK|MB_ICONWARNING);}char str[60]="Child: ";strcat(str,s);m_LISTBOX_Record.InsertString(-1,str);}Process_Father.h// Process_Father.h : main header file for the PROCESS_FATHER application//#if !defined(AFX_PROCESS_FATHER_H__1F9659A2_2B93_4C1E_89C5_5A88971D3DDA__INCLUD ED_)#define AFX_PROCESS_FATHER_H__1F9659A2_2B93_4C1E_89C5_5A88971D3DDA__INCLUDED_#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000#ifndef __AFXWIN_H__#error include 'stdafx.h' before including this file for PCH#endif#include "resource.h" // main symbols///////////////////////////////////////////////////////////////////////////// // CProcess_FatherApp:// See Process_Father.cpp for the implementation of this class//class CProcess_FatherApp : public CWinApp{public:CProcess_FatherApp();// Overrides// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CProcess_FatherApp)public:virtual BOOL InitInstance();//}}AFX_VIRTUAL// Implementation//{{AFX_MSG(CProcess_FatherApp)// NOTE - the ClassWizard will add and remove member functions here.// DO NOT EDIT what you see in these blocks of generated code !//}}AFX_MSGDECLARE_MESSAGE_MAP()};///////////////////////////////////////////////////////////////////////////////{{AFX_INSERT_LOCATION}}// Microsoft Visual C++ will insert additional declarations immediately before the previous line.#endif// !defined(AFX_PROCESS_FATHER_H__1F9659A2_2B93_4C1E_89C5_5A88971D3DDA__INCLUDE D_)Process_FatherDlg.h// Process_FatherDlg.h : header file//#if !defined(AFX_PROCESS_FATHERDLG_H__69E2942A_7A5F_413F_B4A3_AFB8C1F51DFE__INC LUDED_)#defineAFX_PROCESS_FATHERDLG_H__69E2942A_7A5F_413F_B4A3_AFB8C1F51DFE__INCLUDED_#define WM_FATHER_SEND WM_USER+100#define WM_CHILD_SEND WM_USER+101#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000///////////////////////////////////////////////////////////////////////////// // CProcess_FatherDlg dialogclass CProcess_FatherDlg : public CDialog{// Constructionpublic:CProcess_FatherDlg(CWnd* pParent = NULL); // standard constructor// Dialog Data//{{AFX_DATA(CProcess_FatherDlg)enum { IDD = IDD_PROCESS_FATHER_DIALOG };CButton m_BT_CreateChildProcess;CButton m_Send;CListBox m_LISTBOX_Record;CEdit m_EDIT_Message;//}}AFX_DATA// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CProcess_FatherDlg)protected:virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL// Implementationprotected:HICON m_hIcon;// Generated message map functions//{{AFX_MSG(CProcess_FatherDlg)virtual BOOL OnInitDialog();afx_msg void OnSysCommand(UINT nID, LPARAM lParam);afx_msg void OnPaint();afx_msg HCURSOR OnQueryDragIcon();afx_msg void OnReceiveMsg(WPARAM wParam, LPARAM lParam);afx_msg void OnBTCreateChildProcess();afx_msg void OnSend();//}}AFX_MSGDECLARE_MESSAGE_MAP()private:HANDLE hPipeWrite2;HANDLE hPipeRead2;HANDLE hPipeWrite;HANDLE hPipeRead;};//{{AFX_INSERT_LOCATION}}// Microsoft Visual C++ will insert additional declarations immediately before theprevious line.#endif// !defined(AFX_PROCESS_FATHERDLG_H__69E2942A_7A5F_413F_B4A3_AFB8C1F51DFE__INCL UDED_)子进程代码Process_Child.cpp// Process_Child.cpp : Defines the class behaviors for the application.//#include "stdafx.h"#include "Process_Child.h"#include "Process_ChildDlg.h"#ifdef _DEBUG#define new DEBUG_NEW#undef THIS_FILEstatic char THIS_FILE[] = __FILE__;#endif/////////////////////////////////////////////////////////////////////////////// CProcess_ChildAppBEGIN_MESSAGE_MAP(CProcess_ChildApp, CWinApp)//{{AFX_MSG_MAP(CProcess_ChildApp)// NOTE - the ClassWizard will add and remove mapping macros here.// DO NOT EDIT what you see in these blocks of generated code!//}}AFX_MSGON_COMMAND(ID_HELP, CWinApp::OnHelp)END_MESSAGE_MAP()///////////////////////////////////////////////////////////////////////////// // CProcess_ChildApp constructionCProcess_ChildApp::CProcess_ChildApp(){// TODO: add construction code here,// Place all significant initialization in InitInstance}///////////////////////////////////////////////////////////////////////////// // The one and only CProcess_ChildApp objectCProcess_ChildApp theApp;///////////////////////////////////////////////////////////////////////////// // CProcess_ChildApp initializationBOOL CProcess_ChildApp::InitInstance(){AfxEnableControlContainer();// Standard initialization// If you are not using these features and wish to reduce the size// of your final executable, you should remove from the following// the specific initialization routines you do not need.#ifdef _AFXDLLEnable3dControls(); // Call this when using MFC in a shared DLL #elseEnable3dControlsStatic(); // Call this when linking to MFC statically #endifCProcess_ChildDlg dlg;m_pMainWnd = &dlg;int nResponse = dlg.DoModal();if (nResponse == IDOK){// TODO: Place code here to handle when the dialog is// dismissed with OK}else if (nResponse == IDCANCEL){// TODO: Place code here to handle when the dialog is// dismissed with Cancel}// Since the dialog has been closed, return FALSE so that we exit the // application, rather than start the application's message pump.return FALSE;}Process_ChildDlg.cpp// Process_ChildDlg.cpp : implementation file//#include "stdafx.h"#include "Process_Child.h"#include "Process_ChildDlg.h"#ifdef _DEBUG#define new DEBUG_NEW#undef THIS_FILEstatic char THIS_FILE[] = __FILE__;#endif///////////////////////////////////////////////////////////////////////////// // CAboutDlg dialog used for App Aboutclass CAboutDlg : public CDialog{public:CAboutDlg();// Dialog Data//{{AFX_DATA(CAboutDlg)enum { IDD = IDD_ABOUTBOX };//}}AFX_DATA// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CAboutDlg)protected:virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL// Implementationprotected://{{AFX_MSG(CAboutDlg)//}}AFX_MSGDECLARE_MESSAGE_MAP()};CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD){//{{AFX_DATA_INIT(CAboutDlg)//}}AFX_DATA_INIT}void CAboutDlg::DoDataExchange(CDataExchange* pDX){CDialog::DoDataExchange(pDX);//{{AFX_DATA_MAP(CAboutDlg)//}}AFX_DATA_MAP}BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)//{{AFX_MSG_MAP(CAboutDlg)// No message handlers//}}AFX_MSG_MAPEND_MESSAGE_MAP()///////////////////////////////////////////////////////////////////////////// // CProcess_ChildDlg dialogCProcess_ChildDlg::CProcess_ChildDlg(CWnd* pParent /*=NULL*/): CDialog(CProcess_ChildDlg::IDD, pParent){//{{AFX_DATA_INIT(CProcess_ChildDlg)//}}AFX_DATA_INIT// Note that LoadIcon does not require a subsequent DestroyIcon in Win32 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);}void CProcess_ChildDlg::DoDataExchange(CDataExchange* pDX){CDialog::DoDataExchange(pDX);//{{AFX_DATA_MAP(CProcess_ChildDlg)DDX_Control(pDX, IDC_Send, m_Send);DDX_Control(pDX, IDC_LISTBOX_Record, m_LISTBOX_Record);DDX_Control(pDX, IDC_EDIT_Message, m_EDIT_Message);//}}AFX_DATA_MAP}BEGIN_MESSAGE_MAP(CProcess_ChildDlg, CDialog)//{{AFX_MSG_MAP(CProcess_ChildDlg)ON_WM_SYSCOMMAND()ON_WM_PAINT()ON_WM_QUERYDRAGICON()ON_BN_CLICKED(IDC_Send, OnSend)//}}AFX_MSG_MAPON_MESSAGE(WM_FATHER_SEND,OnReceiveMsg)END_MESSAGE_MAP()/////////////////////////////////////////////////////////////////////////////// CProcess_ChildDlg message handlersBOOL CProcess_ChildDlg::OnInitDialog(){CDialog::OnInitDialog();// Add "About..." menu item to system menu.// IDM_ABOUTBOX must be in the system command range.ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);ASSERT(IDM_ABOUTBOX < 0xF000);CMenu* pSysMenu = GetSystemMenu(FALSE);if (pSysMenu != NULL){CString strAboutMenu;strAboutMenu.LoadString(IDS_ABOUTBOX);if (!strAboutMenu.IsEmpty()){pSysMenu->AppendMenu(MF_SEPARATOR);pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);}// Set the icon for this dialog. The framework does this automatically // when the application's main window is not a dialogSetIcon(m_hIcon, TRUE); // Set big iconSetIcon(m_hIcon, FALSE); // Set small icon// TODO: Add extra initialization herereturn TRUE; // return TRUE unless you set the focus to a control}void CProcess_ChildDlg::OnSysCommand(UINT nID, LPARAM lParam){if ((nID & 0xFFF0) == IDM_ABOUTBOX){CAboutDlg dlgAbout;dlgAbout.DoModal();}else{CDialog::OnSysCommand(nID, lParam);}// If you add a minimize button to your dialog, you will need the code below // to draw the icon. For MFC applications using the document/view model, // this is automatically done for you by the framework.void CProcess_ChildDlg::OnPaint(){if (IsIconic()){CPaintDC dc(this); // device context for paintingSendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);// Center icon in client rectangleint cxIcon = GetSystemMetrics(SM_CXICON);int cyIcon = GetSystemMetrics(SM_CYICON);CRect rect;GetClientRect(&rect);int x = (rect.Width() - cxIcon + 1) / 2;int y = (rect.Height() - cyIcon + 1) / 2;// Draw the icondc.DrawIcon(x, y, m_hIcon);}else{CDialog::OnPaint();}}// The system calls this to obtain the cursor to display while the user drags // the minimized window.HCURSOR CProcess_ChildDlg::OnQueryDragIcon(){return (HCURSOR) m_hIcon;}void CProcess_ChildDlg::OnSend(){char ss[20]="Child:";CString str;m_EDIT_Message.GetWindowText(str);DWORD dwWritten;hPipeWrite=GetStdHandle(STD_OUTPUT_HANDLE);if(!WriteFile(hPipeWrite,str,40,&dwWritten,NULL)) {MessageBox(TEXT("写错误"),"警告",MB_OK|MB_ICONWARNING);}CString strWinName = "Process_Father";CWnd *pWnd=CWnd::FindWindow(NULL,strWinName);if(pWnd){pWnd->SendMessage(WM_CHILD_SEND,0,0);strcat(ss,str);m_LISTBOX_Record.InsertString(-1,ss);m_EDIT_Message.SetWindowText("");}else{MessageBox("没有发现父进程","错误");}void CProcess_ChildDlg::OnReceiveMsg(WPARAM wParam,LPARAM lParam){DWORD dwRead;char s[40];HANDLE hPipeRead;hPipeRead=GetStdHandle(STD_INPUT_HANDLE);if(!ReadFile(hPipeRead,s,40,&dwRead,NULL)){MessageBox(TEXT("读错误！"),"警告",MB_OK|MB_ICONWARNING);}char str[60]="Father: ";strcat(str,s);m_LISTBOX_Record.InsertString(-1,str);}Process_Child.h// Process_Child.h : main header file for the PROCESS_CHILD application//#if !defined(AFX_PROCESS_CHILD_H__7416C60C_DD56_40CC_BD28_3DA310873DE7__INCLUDE#define AFX_PROCESS_CHILD_H__7416C60C_DD56_40CC_BD28_3DA310873DE7__INCLUDED_#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000#ifndef __AFXWIN_H__#error include 'stdafx.h' before including this file for PCH#endif#include "resource.h" // main symbols///////////////////////////////////////////////////////////////////////////// // CProcess_ChildApp:// See Process_Child.cpp for the implementation of this class//class CProcess_ChildApp : public CWinApp{public:CProcess_ChildApp();// Overrides// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CProcess_ChildApp)public:virtual BOOL InitInstance();//}}AFX_VIRTUAL// Implementation//{{AFX_MSG(CProcess_ChildApp)// NOTE - the ClassWizard will add and remove member functions here.// DO NOT EDIT what you see in these blocks of generated code !//}}AFX_MSGDECLARE_MESSAGE_MAP()};///////////////////////////////////////////////////////////////////////////////{{AFX_INSERT_LOCATION}}// Microsoft Visual C++ will insert additional declarations immediately before theprevious line.#endif// !defined(AFX_PROCESS_CHILD_H__7416C60C_DD56_40CC_BD28_3DA310873DE7__INCLUDED _)Process_ChildDlg.h// Process_ChildDlg.h : header file//#if !defined(AFX_PROCESS_CHILDDLG_H__01C41D47_4973_4DCB_84FC_4B7C5A6C584A__INCL UDED_)#define AFX_PROCESS_CHILDDLG_H__01C41D47_4973_4DCB_84FC_4B7C5A6C584A__INCLUDED_ #define WM_FATHER_SEND WM_USER+100#define WM_CHILD_SEND WM_USER+101#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000///////////////////////////////////////////////////////////////////////////// // CProcess_ChildDlg dialogclass CProcess_ChildDlg : public CDialog{// Constructionpublic:CProcess_ChildDlg(CWnd* pParent = NULL); // standard constructor// Dialog Data//{{AFX_DATA(CProcess_ChildDlg)enum { IDD = IDD_PROCESS_CHILD_DIALOG };CButton m_Send;CListBox m_LISTBOX_Record;CEdit m_EDIT_Message;//}}AFX_DATA// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CProcess_ChildDlg)protected:virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL// Implementationprotected:HICON m_hIcon;// Generated message map functions//{{AFX_MSG(CProcess_ChildDlg)virtual BOOL OnInitDialog();afx_msg void OnSysCommand(UINT nID, LPARAM lParam);afx_msg void OnPaint();afx_msg HCURSOR OnQueryDragIcon();afx_msg void OnReceiveMsg(WPARAM wParam, LPARAM lParam);afx_msg void OnSend();//}}AFX_MSGDECLARE_MESSAGE_MAP()private:HANDLE hPipeWrite;};//{{AFX_INSERT_LOCATION}}// Microsoft Visual C++ will insert additional declarations immediately before the previous line.#endif// !defined(AFX_PROCESS_CHILDDLG_H__01C41D47_4973_4DCB_84FC_4B7C5A6C584A__INCLU DED_)。

操作系统实验进程通信

进程通信(实验二)【实验目的】：掌握用邮箱方式进行进程通信的方法，并通过设计实现简单邮箱理解进程通信中的同步问题以及解决该问题的方法。

【实验原理】：邮箱机制类似于日常使用的信箱。

对于用户而言使用起来比较方便，用户只需使用send（）向对方邮箱发邮件receive（）从自己邮箱取邮件，send（）和receive（）的内部操作用户无需关心。

因为邮箱在内存中实现，其空间有大小限制。

其实send（）和receive（）的内部实现主要还是要解决生产者与消费者问题。

【实验内容】：进程通信的邮箱方式由操作系统提供形如send（）和receive（）的系统调用来支持，本实验要求学生首先查找资料了解所选用操作系统平台上用于进程通信的系统调用具体形式，然后使用该系统调用编写程序进行进程间的通信，要求程序运行结果可以直观地体现在界面上。

在此基础上查找所选用操作系统平台上支持信号量机制的系统调用具体形式，运用生产者与消费者模型设计实现一个简单的信箱，该信箱需要有创建、发信、收信、撤销等函数，至少能够支持两个进程互相交换信息，比较自己实现的信箱与操作系统本身提供的信箱，分析两者之间存在的异同。

实验背景介绍进程间通信有如下目的：数据的传输，共享数据，通知事情，资源共享，进程控制。

进程间的通信机制（IPC），就是多进程相互通信，交换信息的方法。

Linux IPC机制包括，信号和管道是其中的两个，还支持传统的UNIX SYSTM-V 的IPC 机制。

信号主要用来通知进程异步事情的发生，最初信号设计的目的是为了处理错误，他们也用来作为最基本的IPC机制。

管道是单向的，先进先出，先入先出，无结构的，固定大小的数据流。

UNIX System V 机制中的三种进程间通信机制，它们是：消息队列：用于进程之间传递分类的格式化数据信号量：用于通信之间的同步控制。

信号量通常与共享存储器方式一起使用。

共享内存：使不同进程通过共享彼此的虚拟空间而达到相互对共享区操作和数据通信。

实验2-进程和进程通信(网络)-全

《Linux操作系统设计实践》实验二：进程通信

计算机操作系统实验-进程通信(二)

操作系统实验2 进程通信

操作系统实验 进程与进程通信

进程通讯管理实验报告(3篇)

进程控制与进程通信程序实验报告

进程和进程间通信

实验二进程通信 Linux实验报告

进程通信实验报告

进程之间的通信实验

进程控制与进程通信程序实验报告

进程控制与进程通信程序实验报告

实验二 进程通信实验

实验二 进程间通信

操作系统实验报告2-进程间通信

操作系统实验---进程通信

实验二进程和进程通信

进程通信实验报告

操作系统实验 进程通信

操作系统实验进程与进程通信

实验二进程通信实验

实验二进程间通信

操作系统实验进程通信