操作系统实验进程通信

《操作系统》实验报告年级、专业、班级 姓名进程间通信实验题目实验时间 2014.11.21 实验地点 A主0410实验成绩 实验性质 □验证性 □设计性 □综合性 教师评价：□算法/实验过程正确； □源程序/实验内容提交 □程序结构/实验步骤合理；□实验结果正确； □语法、语义正确； □报告规范；其他：评价教师签名：一、实验目的1. 了解管道通信的特点，掌握管道通信的使用方法。

2. 了解消息队列通信机制及原理，掌握消息队列相关系统调用的使用方法及功能。

3. 了解Linux系统共享存储区的原理及使用方法。

二、实验项目内容1. 管道通信（1）父进程创建管道和两个子进程p1和p2。

（2）子进程p1打开给定文件（如果没有，则创建文件），并向文件中写数据，写完关闭文件，然后向管道写入一条消息“ok"，目的是通知进程p2可以读取文件内容了。

（3）子进程p2通过管道读取消息，如果消息是“ok”,则打开文件，读取文件内容，并将其输出到屏幕上,关闭文件.2. 消息队列（1）父进程创建消息队列和两个子进程p1和p2。

（2）子进程p1打开给定文件（如果没有，则创建文件），并向文件中写数据，写完关闭文件，然后向消息队列写入一条消息“1",目的是通知进程p2可以读取文件内容了。

（3）子进程p2从消息队列读取消息，如果收到消息,则打开文件，读取文件内容，并将其输出道屏幕上，关闭文件。

3. 共享存储（1）由父进程建立一块共享存储区,并创建两个子进程p1,p2,父进程负责查询存储区状态，以及删除该存储区。

（2）子进程p1链接到该共享存储区，然后向存储区写入数据，写完断开链接。

（3）子进程p2链接到该共享存储区，从存储区读数据，然后断开链接。

注意：为了便于各进程对存储区访问的同步，这里使用信号量方法。

三、实验过程或算法1. 管道通信#include<unistd.h>#include<stdio.h>#include<string.h>#include<stdlib.h>int main() {int pipefd[2];pid_t pid;char buf[100];int n;为0memset(buf, 0, sizeof(buf));//clear bufif(pipe(pipefd) < 0) {perror("pipe");exit(0);}pid = fork();if(pid == 0) { //child process 1close(pipefd[0]);//close read fdchar *msg="Hello,I am a Pipe user.";write(pipefd[1], msg, 50);}else if(pid > 0) {pid = fork();if(pid == 0) { //child process 2close(pipefd[1]);//close write fdread(pipefd[0], buf, sizeof(buf));fprintf(stdout, "read from pipe is:%s\n", buf);}else if(pid > 0) exit(0);}}2.消息队列//发送消息，msqid是队列id，msg是要发送的消息void sendmsg(int msqid,mymesg msg){printf("msqid:%d,msg:%s\n",msqid,msg.mtext);if((msgsnd(msqid, &msg, sizeof(msg.mtext), IPC_NOWAIT)) != 0){//消息发送函数printf("pid_1:send msg error!\n");}else{printf("pid_1:send msg: %s succeed!\n", msg.mtext);}}//接收消息，msqid是队列idint rcvmsg(int msqid){mymesg msg={0};AIT);int msg_len = msgrcv(msqid, &msg, sizeof(msg.mtext), 0, IPC_NOW //接收消息函数if(msg_len < 0){printf("pid_2:receive msg error!\n");return 0;}printf("pid_2:recv msg: %s\n", msg.mtext);return 1;}3.共享存储创建共享存储区 shmid = shmget(IPC_PRIV A TE, SIZE, IPC_CREAT|0600 ) ;//{if ( shmid < 0 )perror("get shm ipc_id error") ;return -1 ;}pid = fork() ;子进程p1if ( pid == 0 ){ //printf("I'm child1 process,my pid is %d.\n",getpid());P操作sem_p(sem_id); //链接到存储区 shmaddr = (char *)shmat( shmid, NULL, 0 ) ;//if ( (int)shmaddr == -1 ){perror("shmat addr error") ;return -1 ;}向存储区写数据strcpy( shmaddr, "Hi,This is share memory!\n") ;//shmdt( shmaddr ) ;//断开链接V操作sem_v(sem_id); //父进程} else if ( pid > 0) {//printf("I'm father process,my pid is %d.\n",getpid());pid = fork();sleep(1);子进程2创建if(pid==0){//printf("I'm child2 process,my pid is %d.\n",getpid());P操作sem_p(sem_id); //读取存储区状态到buf中flag = shmctl( shmid, IPC_STAT, &buf) ;//{if ( flag == -1 )perror("shmctl shm error") ;return -1 ;}printf("shm_segsz =%d bytes\n", buf.shm_segsz ) ;printf("parent pid=%d, shm_cpid = %d \n", getppid(), buf.shm_cpid ) ;printf("chlid pid=%d, shm_lpid = %d \n",pid, buf.shm_lpid ) ;printf("shm_segsz =%d \n", buf.shm_perm.mode );shmaddr = (char *) shmat(shmid, NULL, 0 ) ;链接到存储区，读取其中数据if ( (int)shmaddr == -1 ){//perror("shmat addr error") ;return -1 ;}//打印数据到屏幕printf("%s", shmaddr) ;V操作sem_v(sem_id); //断开链接shmdt( shmaddr) ;//}else{perror("fork error.") ;shmctl(shmid, IPC_RMID, NULL) ;}删除该存储区shmctl(shmid, IPC_RMID, NULL) ;//return 0 ;}四、实验结果及分析和（或）源程序调试过程（包含程序使用方法、程序运行截图），实验过程中遇到的问题分析与心得体会。

《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、进程间通信的几种方法简介（1）消息队列：消息队列是消息的链接表，包括Posix消息队列systemV消息队列。

有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。

（2）共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。

是针对其他通信机制运行效率较低而设计的。

往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。

（3）无名管道（Pipe）及有名管道（named pipe）：有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；无名管道可用于有亲缘关系的进程之间彼此的通信，进行通信时候必须有一定的机制保证对管道写和读的互斥：即在读是要关闭写的端口，而在写的时候也要保证读的一端是关闭的。

2、进程通信函数（1）消息队列有关系统调用函数a.创建消息队列使用msgget()函数：#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>int msgget(key_t key, int flag) ;该函数成功调用返回消息队列标识符。

其中的key是关键字，可以由ftok()函数得到：key=ftok(“.”,’a’);其中”.”可以是任何目录，’a’是任意字符，即所有群组标识。

flag是标识，IPC_CREAT位表示创建，一般由服务器程序创建消息队列时使用。

如果是客户程序，必须打开现存的消息队列，必须不使用IPC_CREAT。

发送和接收的消息都必须使用一个类似msgbuf的结构表示，msgbuf结构定义如下：struct msgbuf{long mtype;char mtext[1];}上面的定义，消息内容只有一个字节，是不实用的，一般我们需要重新定义一个结构：struct amsgbuf{long mtype;char mtext[200];}其中的mtype都是消息类型。

漳州师范学院
实验报告
班级 13网络1班学号1308990337 姓名成绩
理解分析：1.先创建父进程，由父进程分别产生子进程1和子进程
p2，parent。

2.给父进程中断信号，父进程开始终止子进程，signal(SIGINT, SIG_IGN);语句，相当于使子进程忽略键入信号，不会将子进程终止，程序可以正常运行。

于是输出child process by parent!和child process 2 is killed by parent!
理解分析：在该管道通信中，有时是子进程p1，p2往管道中传送数据完后父进程再从管道中读取数据，有时是子进程p1往管道中传送数据后父进程从管道中读取数据，然后子进程p2再往管道中传送数据，父进程再从管道中读取数据。

1)管道通信的概念是什么
管道通信即发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信。

2)同步和互斥的概念是什么，在程序中如何实现的
注：如果填写内容超出表格，自行添加附页。

一、实验目的1. 理解进程通信的概念和作用。

2. 掌握进程通信的常用方法，包括管道、消息队列、信号量等。

3. 通过编程实践，加深对进程通信机制的理解和应用。

二、实验环境操作系统：Linux开发环境：gcc三、实验内容1. 管道通信2. 消息队列通信3. 信号量通信四、实验步骤及分析1. 管道通信（1）实验步骤1）创建一个父进程和一个子进程；2）在父进程中创建一个管道，并将管道的读端和写端分别赋给父进程和子进程；3）在父进程中，通过管道的写端发送数据给子进程；4）在子进程中，通过管道的读端接收父进程发送的数据；5）关闭管道的读端和写端；6）结束进程。

（2）实验分析通过管道通信，实现了父进程和子进程之间的数据传递。

管道是半双工通信，数据只能单向流动。

在本实验中，父进程向子进程发送数据，子进程接收数据。

2. 消息队列通信（1）实验步骤1）创建一个消息队列；2）在父进程中，向消息队列中发送消息；3）在子进程中，从消息队列中接收消息；4）删除消息队列；5）结束进程。

（2）实验分析消息队列是一种进程间通信机制，允许不同进程之间传递消息。

消息队列的创建、发送、接收和删除等操作都是通过系统调用实现的。

在本实验中，父进程向消息队列发送消息，子进程从消息队列接收消息，实现了进程间的消息传递。

3. 信号量通信（1）实验步骤1）创建一个信号量；2）在父进程中，对信号量执行P操作，请求资源；3）在子进程中，对信号量执行V操作，释放资源；4）结束进程。

（2）实验分析信号量是一种用于实现进程同步的机制。

在进程通信中，信号量可以用来协调多个进程对共享资源的访问。

在本实验中，父进程和子进程通过信号量实现了对共享资源的同步访问。

五、实验结果1. 管道通信实验结果：父进程成功向子进程发送数据，子进程成功接收数据。

2. 消息队列通信实验结果：父进程成功向消息队列发送消息，子进程成功从消息队列接收消息。

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()函数删除消息队列。

暨南大学本科实验报告专用纸课程名称《操作系统原理实验》成绩评定实验项目名称进程通信指导教师戴红实验项目编号0806002903 实验项目类型综合型实验地点学生姓名蔡高成学号2007052431学院国际商学院系企业管理专业信息管理与信息系统实验时间年月日下午温度℃湿度一、实验目的学习如何利用管道机制或消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。

提高学生分析问题和解决问题的能力，并学习撰写规范的科学研究报告。

二、实验环境及设备（一）实验室名称：计算机实验室（二）主要仪器设备：PC机、Linux操作系统环境三、实验内容编写一段程序，使用管道来实现父子进程之间的进程通信。

子进程项父进程发送自己的进程表示符，以及某字符串。

父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。

四、实验调试分析1、实验函数说明（1）pipe头文件：#include<unistd.h>定义函数：int pipe(int pipedes[2]);函数说明：pipe()会建立管道,并将文件描述词由参数pipedes 数组返回。

pipedes[0]为管道里的读取端，所以pipe用read调用的pipedes[1]则为管道的写入端。

写进程A pipedes[1]返回值: 若成功则返回零,否则返回-1,错误原因存于errno 中。

错误代码:EMFILE 进程已用完文件描述词最大量ENFILE 系统已无文件描述词可用。

EFAULT 参数pipedes 数组地址不合法。

（2）sprintf函数功能：把格式化的数据写入某个字符串头文件：#include <stdio.h>函数原型：int sprintf( char *buffer, const char *format [, argument] … );返回值：字符串长度（strlen）（3）flock头文件： #include<sys/file.h>定义函数： int flock(int fd,int operation);函数说明： flock()会依参数operation所指定的方式对参数fd所指的文件做各种锁定或解除锁定的动作。

2.编辑结果如下。

3.编译和运行程序。

4. 运行解释结果
父进程创建一个子进程和一个无名管道fd。

父进程wait(0)等待子进程的终止信号，子进程向管道写入信息“This is a message。

”然后终止，父进程收到终止信号后从管道读出信息并显示在屏幕上后结束。

2.编辑结果如下。

3.编译和运行程序。

4. 运行解释结果
父进程先创建一个子进程1，子进程1往管道fd里写入信息，并输出parent的信息，父进程接着有创造了一个子进程2，子进程2也往fd管道fd里写入信息，父进程wait(0)等待两个子进程结束信号，等两个子进程都结束后，输出管道里的信息。

实现了父子进程之间的管道通信。

1.编辑源程序。

2.编辑结果如下。

3.编译和运行程序。

4. 运行解释结果
发送进程将要发送的信息从键盘输入，每输入一行就作为一条信息发送，用“end”作为结
束的信息，存入共享的内存区。

接收进程从信息队列逐个取出信息并显示输出。

1.编辑源程序。

2.编辑结果如下。

3.编译和运行程序。

4. 运行解释结果
发送进程将要发送的信息从键盘输入，每输入一行就作为一条信息发送，用“end”作为结束的信息，存入信息缓冲区。

接收进程从信息队列逐个取出信息并显示输出。

操作系统实验报告(三)进程通信专业：软件工程姓名：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（chan1）系统调用打开一个无名管道, 之后创建一个子进程。

子进程复制父进程的打开文件表。

为了正确通信, 父进程关闭读通道close（chan1[0]）, 子进程关闭写通道close（chan1[1]）。

父进程向管道写, 子进程从管道读。

完成一次通信之后, 父进程分别关闭自己的写/读通信, 管道文件消失。

2.以命名行为参数的管道文件的示例。

(假设有一个可执行程序chcase, 从标准输入设备读字符, 将小写字母转化成大写字母并输出。

主程序使用popen创建管道, 实现蒋某文本文件中的字幕转化成大写字母, 其中的文本文件名作为参数传进来。

)编写的程序如下:运行结果是:结果分析: 通过程序运行结果可知, 先打开文本文件, 如果文本打开失败, 则执行exit（1）, 退出程序, 如果文本通过函数开成功, 则popen创建一个可写管道, 将命令行chcase的输入与管道的输入连接起来, 然后向管道输入数据, 此时命令行就可以通过管道接受文本文件的数据了,在从文件中读出数据时, 独处的内容放在line[]数组中,fpin表示从刚打开的文件里读出。

之后要编写字母大小写转化函数, 来实现小写字母转化成大写字母。

3.创建有名管道。

编写的程序如下:运行结果是:前台运行结果:后台运行结果:结果分析: 此程序是把管道和命令联系起来, read( )的系统调用格式是read(fd,buf,n), 参数定义是int read(fd,buf,n); int fd; char *buf; unsigned n;它的功能是从fd所指示的文件中读出n个字节的数据, 并将它们送至由指针buf所指示的缓冲区中。

本科实验报告专用纸课程名称操作系统原理成绩评定实验项目名称进程间的通信指导教师实验项目编号实验项目类型实验地点学生姓名学号学院系专业实验时间年月日上午～月日上午温度℃湿度一、实验目的和要求1.实验目的：1.学习如何利用管道机制或消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。

提高学生分析问题和解决问题的能力，并学习撰写规范的科学研究报告（论文）。

2.实验要求：了解系统pipe(),msgsnd(),msgrcv()的功能和实现过程。

二、实验原理和主要内容1.实验内容：（1）编写一段程序，使用管道来实现父子进程之间的进程通信。

子进程向父进程发送自己的进程表示符，以及某字符串。

父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。

（2）编写一段程序，使其用消息缓冲队列来实现client和server 进程之间的通信。

2.实验原理：（使用的系统调用命令说明或算法及程序详细设计）3.实验函数说明（1）包含头文件#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>（2）msgsnd()函数int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);//将消息送入消息队列参数：msqid：消息队列的识别码。

msgp：指向消息缓冲区的指针，此位置用来暂时存储发送和接收的消息，是一个用户可定义的通用结构，形态如下struct msgbuf {long mtype; /* 消息类型，必须> 0 */char mtext[1]; /* 消息文本*/};msgsz：消息的大小。

msgtyp：从消息队列内读取的消息形态。

如果值为零，则表示消息队列中的所有消息都会被读取。

msgflg：用来指明核心程序在队列没有数据的情况下所应采取的行动。

进程通信（一）1 ．实验目的学习如何利用管道机制、共享存储区机制进行进程间的通信，并加深对上述通信机制的理解。

2 ．实验内容(1) 了解系统调用pipe()、shmget()、shmat()、shmdt()、shmctl()的功能和实现过程。

(2) 编写一段程序，使其用管道来实现父子进程之间的进程通信。

子进程向父进程发送自己的进程标识符，以及字符串“is sending a message to parent ! ”。

父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。

(3) 编写一段程序，使其用共享存储区来实现父子进程之间的进程通信。

父进程创建一个长度为512 字节的共享内存空间，显示写入该共享内存的数据；子进程将共享内存也附加到自己的地址空间，并向共享内存中写入数据。

3 ．实验步骤(1) 了解系统调用pipe()、shmget()、shmat()、shmdt()、shmctl()的功能和实现过程。

pipe()创建一条管道进行信息传输。

shmget()得到一个共享内存标识符或创建一个共享内存对象并返回共享内存标识符shmat()连接共享内存标识符为shmid的共享内存，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问shmdt()用来断开与共享内存附加点的地址，禁止本进程访问此片共享内存shmctl()共享内存管理，完成对共享内存的控制(2) 编写一段程序，使其用管道来实现父子进程之间的进程通信。

子进程向父进程发送自己的进程标识符，以及字符串“is sending a message to parent ! ”。

父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。

程序代码：#include<stdio.h>#include<stdlib.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<unistd.h>int main(){int pid1,pid2;int fd[2];char out[512],in[512];pipe(fd);pid1=fork();if(pid1==0){sprintf(out,"%d is sending a message to parent!\n",getpid());printf("%s",out);write(fd[1],out,sizeof(out));}else{read(fd[0],in,sizeof(out));printf("%s",in);}return 0;}程序截图：运行结果：(3) 编写一段程序，使其用共享存储区来实现父子进程之间的进程通信。

实验报告实验题目姓名：学号：课程名称：操作系统实验所在学院：信息科学与工程学院专业班级：计算机任课教师：五、实验数据（现象）处理分析信号机制实验建立文件和可执行文件：信号机制实验运行结果：屏幕上无反应，按下^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 支持的信号量机制、管道机制、消息通信机制及共享存储区机制的基本原理和基本概念。

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

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

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

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

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

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

（操作系统原理和linux操作系统相结合的实验）实验二进程的通信一实验目的1 学会使用vi编辑器编辑C语言程序2 学会Linux环境下gcc的使用3 学会调试工具GDB的使用二实验原理1 利用linux提供的进程通信的系统调用设计进程通信程序，加深对进程通信概念的理解。

2 体会进程通信的方法和效果。

三实验环境PC机1台，Windows操作系统和其上的虚拟Linux操作系统。

四实验步骤1．管道通信(1)编写一个程序。

父进程创建一个子进程和一个无名管道fd，由子进程向管道写入信息“This is a message”，然后终止执行；父进程接收到子进程终止信号后从管道中读出并显示信息后结束。

#include<stdio.h>#include<unistd.h>main(){int p1,fd[2];char outpipe[50]; //定义读缓冲区char inpipe[50]="This is a message!"; //定义写缓冲区pipe(fd); //创建无名管道fdwhile((p1=fork())==-1);if (p1==0) //子进程返回{write(fd[1],inpipe,50); //写信息到管道exit(0);}else //父进程返回{wait(0); //等待子进程终止read(fd[0],outpipe,50); //从管道读信息到读缓冲区printf("%s\n",outpipe); //显示读到的信息exit(0);}}(2)父进程创建两个子进程，父子进程之间利用管道进行通信。

要求能显示父进程、子进程各自的信息，体现通信效果。

(源程序pipe_1.c)#include<stdio.h>main(){int I,r,j,k,l,p1,p2,fd[2];char buf[50],s[50];pipe(fd);while((p1=fork())==-1);if(p1==0){lockf(fd[1],1,0);sprintf(buf,"Child process p1 is sending message!\n");printf("Child process p1!\n");write(fd[1],buf,50);lockf(fd[1],0,0);sleep(5);j=getpid();k=getppid();printf("p1 %d is weakup.My parent process id is %d.\n",j,k);exit(0);}else{while((p2=fork())==-1);if(p2==0){lockf(fd[1],1,0);sprintf(buf,"Child process p2 is sending message!\n");printf("Child process p2!\n");write(fd[1],buf,50);lockf(fd[1],0,0);sleep(5);j=getpid();k=getppid();printf("p2 %d is weakup.My parent process id is %d.\n",j,k);exit(0);}else{I=getpid();wait(0);if(r=read(fd[0],s,50)==-1)printf("can’t read pip e.");elseprintf("Parent %d:%s\n",l,s);wait(0);if(r=read(fd[0],s,50)==-1)pr intf("can’t read pipe");elseprintf ( "Parent %d:%s\n",l,s);exit(0);}}}结果：2.共享内存通信。

进程通信实验报告进程通信实验报告概述进程通信是操作系统中非常重要的一个概念，它允许不同的进程之间进行数据的交换和共享。

在本次实验中，我们通过使用不同的进程通信机制，如管道、消息队列和共享内存，来实现进程之间的数据传输和通信。

本报告将详细介绍实验的背景、实验过程、结果分析以及对实验的总结。

实验背景进程通信是操作系统中的一个核心概念，它允许多个进程之间进行数据的交换和共享。

在现代操作系统中，进程通信是实现并发和协作的重要手段。

了解不同的进程通信机制以及它们的优缺点对于深入理解操作系统的原理和实现至关重要。

实验过程在本次实验中，我们使用了三种不同的进程通信机制：管道、消息队列和共享内存。

首先，我们创建了两个进程，一个作为发送方，一个作为接收方。

然后，我们分别使用了管道、消息队列和共享内存来实现进程之间的数据传输和通信。

管道是一种最简单的进程通信机制，它可以在父进程和子进程之间进行单向的通信。

我们通过创建一个管道，并将其连接到父进程和子进程的标准输入和标准输出，实现了父子进程之间的数据传输。

消息队列是一种更为灵活的进程通信机制，它可以实现多个进程之间的双向通信。

我们使用了系统提供的消息队列函数，创建了一个消息队列，并在发送方将消息发送到队列中，接收方则从队列中接收消息。

通过消息队列，我们实现了进程之间的异步通信。

共享内存是一种高效的进程通信机制，它允许多个进程共享同一块内存空间。

我们使用了共享内存函数，创建了一个共享内存区域，并将其映射到两个进程的虚拟地址空间中。

通过共享内存，我们实现了进程之间的数据共享和同步。

结果分析通过实验，我们发现不同的进程通信机制各有优缺点。

管道是最简单的一种机制，但只能实现单向通信，且只能用于具有亲缘关系的进程。

消息队列可以实现多个进程之间的双向通信，但消息的顺序可能会被打乱。

共享内存是最高效的一种机制，但需要额外的同步机制来保证数据的一致性。

总结进程通信是操作系统中非常重要的一个概念，它允许不同的进程之间进行数据的交换和共享。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

进程通信指导老师：夏建一、实验题目进程通信上机实验（消息缓冲通信）二、算法思想1、在进程管理（调度）实验基础上，加入进程通信的功能，采用消息缓冲通信机制进行通信。

2、P1发送数据给P2，P2排序后发送给P3，P3接收数据并输出。

3、要发送的数据内容由操作者实时输入。

三、小组分工：四、算法程序1、缓冲区结构typedef struct node{int id;int size;char text[100];struct node *next;}buftype;2、进程控制块PCBstruct {int id;char status;int waiter1;int priority;char stack[5];int sm;buftype *front;buftype *rear;}pcb[4];3 .发送、接收、排序程序算法流程(1)发送函数 send（）分配缓冲区空间，由P指向接收进程标识符、信息长度存入缓冲区置链接指针为空，将信息正文从发送区复制到正文区队尾指针指向新插入缓冲区队列缓冲区个数计数加1程序：void send(int rec_id,char a[],int n){buftype *p;p=(buftype *)malloc(sizeof(buftype));p->id=rec_id; //接收消息进程idp->size=n; //消息的大小strcpy(p->text,a); //将消息拷贝到节点之中p->next=0;if(pcb[rec_id].sm<=0)//如果消息缓冲队列空..就将p放在链首{pcb[rec_id].front=p;}elsepcb[rec_id].rear->next=p;//如果不空..放在队尾..rear 指针后移一位pcb[rec_id].rear=p;//队尾指针指向新加入的缓冲区 pcb[rec_id].sm++; //接收进程的消息个数+1}(2)接收函数 receive （）调用参数：rec_id 接收进程标识符输出“无消息”提示信息，返回 复制数据到接收区数组b释放缓冲区程序：int receive(int rec_id,char b[]){buftype *p;if(pcb[rec_id].sm<=0){printf("no message!!\n");return 0;}else{p=pcb[rec_id].front;pcb[rec_id].sm--;pcb[rec_id].front=pcb[rec_id].front->next;//取出来后..front指针后移一位strcpy(b,p->text);free(p);if(pcb[rec_id].front==NULL)pcb[rec_id].rear=NULL;return 1;}}(3)排序函数 sort（）调用参数：a[ ] 待排序数组，n 数据个数；程序：void sort(char a[],int n){int i,j;char temp;for(i=0;i<n;i++){for(j=i+1;j<n;j++){if(a[j]<a[i]){temp=a[i];a[i]=a[j];a[j]=temp;}//if}//for}}a 数组 100字符） len P22.修改P1、P2、P3程序Process1（） 在阻塞前插入以下操作代码Process1（） 在阻塞前插入以下操作提示用户输入选择字符b 数组 P3 a 数组 字符）lenP2Process1程序：process1(){char flag;char a[100];int len;if(addr=='m') goto m;i=1;m1=1;a: printf("\n process1 printing m1=%d\n\n",m1);printf("do you want to send data ?(y/n)"); //是否发送消息flag=getchar();if(flag=='y'||flag=='Y'){printf("input data:");scanf("%s",a);len=strlen(a);send(1,a,len); //将消息输送到缓冲队列中printf("\n");}printf("process1 calls p on sem1!\n");if(p(1,1,'m')==0)return (0);m: printf("\n=>process1 i=%d\n\n",i);i=i+5;goto a;}Process2程序：process2(){char flag;char b[100];int len;if(addr=='m') goto m;if(addr=='n') goto n;i=1;a: printf("\n process2 printing m1=%d\n",m1);m2=2*m1;printf("do you want to receive message?(y/n)");//是否接收消息getchar();flag=getchar();if(flag=='y'||flag=='Y'){if(receive(1,b)==0){ //消息队列为空getchar();}else{ //打印接收的消息，并且排序printf("\n%s\n\n",b);len=strlen(b);sort(b,len);printf("\n%s\n\n",b);send(2,b,len);}}printf("process2 call p on sem2\n");if(p(2,2,'m')==0)return (0);m: printf("process2 call v on sem1!\n");if(v(1,2,'n')==0)return (0);n: printf("\n=>process2 i=%d\n\n",i);i=i+10;goto a;}Process3（）在P3调用V 操作唤醒P2前加入以下操作Process3程序：process3(){char c[100];if(addr=='m') goto m;if(addr=='n') goto n;i=1;a: printf("\n=>process3 i=%d\n",i);if(i>=num) goto b;printf("\n process3 printing 2^i=%d\n\n",m2);m1=m2;if(receive(2,c)){printf("==>SORT RESULT:%s\n\n",c);getchar();}else{printf("==>SORT RESULT:\n\n");getchar();}getchar();printf("process3 call v on sem2!\n"); 调用接收函数，接收数据送到接收区c 数组 输出接收区数据if(v(2,3,'m')==0) return (0);m: i++;goto a;b: if(receive(2,c)){printf("==>result:%s\n\n",c);getchar();}else{printf("==>result:\n\n");getchar();}printf("\nprocess3 calls p on sem2\n"); if(p(2,3,'n')==0) return (0);n: ;}四、测试情况、分析下面的是调试正确后的程序结果：（1）发送后立刻接受：（2）接下来三个进程五、收获与体会经过这次的实验，我收获良多，同时也让我明白，动手了，实践了就有希望，就会有希望完成任务。