实验二,进程通信,管道共享内存
《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写入的字符输出。
进程实验-进程间通信(管道、消息、共享内存、软中断)
进程实验3 Linux 进程间通信一、软中断信号的处理，实现同一用户的各进程之间的通信。
●相关的系统调用⏹kill(pid ,sig)：发送信号⏹signal（sig, func）：指定进程对信号sig的处理行为是调用函数func。
●程序清单#include <unistd.h>#include <stdio.h>#include <signal.h>void waiting();void stop();int wait_mark;main(){int p1,p2;while((p1=fork())==-1);if(p1>0){while((p2=fork())==-1);if(p2>0){ printf("parent\n");/*父进程在此完成某个操作、或接收到用户从键盘输入的特殊按键命令后发出下面的信号。
这里省略。
*/kill(p1,16);kill(p2,17);wait(0);wait(0);printf("parent process id killed! \n");exit(0);}else/* p2==0*/{printf("p2\n");wait_mark=1;signal(17,stop);waiting();printf("child process 2 is killed by parent! \n");exit(0);}}else/*p1==0*/{printf("p1\n");wait_mark=1;signal(16,stop);waiting();printf("child process 1 is kelled by parent! \n");exit(0);}}void waiting(){while(wait_mark!=0);}void stop(){wait_mark=0;}●输入并运行此程序，分析程序的运行结果。
操作系统实验报告(进程的管道及消息通信)
printf("\n Ihave wrote:%s",string); write(fd,string,45); string[0]+=1; } else { read(fd,buf,256); printf("\n The context by I have read is :!%s",buf); buf[0]='\0'; } } close(fd); } 运行结果：
char parent[]="A message to pipe'communication.\n";
main() {
int pid,chan1[2]; char buf[100]; pipe(chan1); pid=fork(); if(pid<0) {
printf("to create child error\n"); exit(1); } if(pid>0) { close(chan1[0]); printf("parent process sends a message to child.\n"); write(chan1[1],parent,sizeof(parent)); close(chan1[1]); printf("parent process waits the child to terminate\n"); wait(0); printf("parent process terminate\n"); } else { close(chan1[1]); read(chan1[0],buf,100); printf("The message read by child process from parent is :%s.\n",buf); close(chan1[0]); printf("child process terminates\n"); } } 运行结果：
实验三、进程通信(一) ——管道及共享内存
（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析
实验代码：
#include<stdio.h>
main()
{ int x,fd[2];
char buf[30],s[30];
pipe(fd);
while ((x=fork())==-1);
if (x==0)
}
write(fe[1],s,30);
wait(0);
}
运行结果：
（3）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享内存的情况，对两次的结果进行比较，并分析原因。最后用ipcrm命令删除自己建立的共享存储区。（有关ipcs和ipcrm介绍见后面一页）
addr=shmat(shmid,0,0);/*挂接，并得到共享区首地址*/
printf ("addr 0x%x\n",addr);
pint=(char *)addr;
for (i='a';i<='e';i++) *pint++=i;
pause();/*等待接收进程读*/
}
cleanup()
{
shmctl(shmid,IPC_RMID,0);
（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。运行结束后可以用ctrl+c结束程序1的运行。
（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。要求在父进程中生成一个30字节长的私有共享内存段。接下来，设置一个指向共享内存段的字符指针，将一串大写字母写入到该指针指向的存贮区。调用fork()生成子进程，让子进程显示共享内存段中的内容。接着，将大写字母改成小写，子进程修改共享内存中的内容。之后，子进程将脱接共享内存段并退出。父进程在睡眠5秒后，在此显示共享内存段中的内容（此时已经是小写字母）。
操作系统原理进程通信共享内存
操作系统原理进程通信共享内存操作系统中的进程通信和共享内存是两个相互关联的概念。
进程通信是指不同进程之间进行信息交换的机制，而共享内存则是实现进程通信的一种方法。
在本文中，我们将详细介绍进程通信和共享内存的原理和一些常用的实现方式。
一、进程通信的原理进程通信是操作系统中实现不同进程之间信息传递和协同工作的关键机制。
它可以分为两种基本形式：同步和异步。
1.同步通信：同步通信是指发送进程和接收进程在通信操作期间需要进行协调和同步。
在同步通信中，发送进程必须等待接收进程完成后才能继续执行。
2.异步通信：异步通信是指发送进程和接收进程在通信操作期间相互独立，不需要进行明确的协调和同步。
在异步通信中，发送进程可以在发送消息后立即继续执行其他任务，而不需要等待接收进程。
常见的进程通信机制包括管道、消息队列、信号量和套接字等。
下面将对其中的一种机制进行详细介绍。
1. 管道（Pipe）：管道是一种特殊的文件，用于将一个进程的输出连接到另一个进程的输入。
管道提供了一种单向的、先进先出的数据传输方式。
在管道中，写操作和读操作是同步的，即写操作会一直阻塞直到有进程来读取数据。
很多操作系统提供了管道的实现方式，如在Unix/Linux中可以使用pipe(系统调用创建一个管道。
在创建管道后，相关进程可以通过文件描述符进行读写操作。
二、共享内存的原理共享内存是一种允许两个或多个进程之间共享地址空间的机制。
通过共享内存，进程可以直接读取和修改彼此的数据，从而实现高效的数据共享。
共享内存的实现包括以下步骤：1. 创建共享内存区域：操作系统提供了一些系统调用，如shmget(，用于创建共享内存区域。
创建共享内存区域时需要指定大小和一些其他的控制参数。
2. 连接到共享内存：创建共享内存区域后，进程可以使用shmat(系统调用将共享内存区域连接到自己的地址空间，从而可以直接读取和修改共享内存中的数据。
3.操作共享内存：连接到共享内存后，进程可以像操作普通内存一样对共享内存进行读写操作。
试验二进程通信Linux试验报告
实验报告学号姓名成绩__________实验二进程通信【实验目的和要求】1、了解进程通信的概念及方法；2、了解信号量、管道；3、掌握信号量、管道和命名管道编程方法。
【实验内容】1、利用命名管道实现单机QQ聊天；2、撰写实验报告；【实验原理】1、信号量（semaphore）是为那些访问相同资源的进程以及同一进程不同线程之间提供的一个同步机制。
它不是用于传输数据，而只是简单地协调对共享资源的访问。
信号量包含一个计数器，表示某个资源正在被访问和访问的次数，用来控制多进程对共享数据的访问。
一旦成功拥有了一个信号量，对它所能做的操作只有两种：请求和释放。
当执行释放操作时，系统将该信号值减1（如果小于零，则设置为零）；当执行请求操作时，系统将该信号值加1，如果加1后的值大于设定的最大值，那么系统将会挂起处理进程，直到信号值小于最大值为止。
Tuxedo 用信号量来确保在某一时刻只有一个进程对某一块共享内存进程访问。
信号量配置太低会导致Tuxedo系统应用程序无法启动。
2、管道分为两种：管道和命名管道。
管道是UNIX系统IPC的最古老形式，并且所有的UNIX系统都提供这种通信机制。
可以在有亲缘关系（父子进程或者是兄弟进程之间）进行通信，管道的数据只能单向流动，如果想双向流动，必须创建两个管道。
管道应用的一个重大缺陷就是没有名字，因此只能用于亲缘进程之间的通信。
后来以管道为基础提出命名管道（namedpipe，FIFO）的概念，该限制得到了克服。
FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。
这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间），因此，通过FIFO不相关的进程也能交换数据。
值得注意的是，FIFO严格遵循先进先出(first in first out)规则，对管道及FIFO的读总是从开始处返回数据，对它们的写则是把数据添加到末尾。
进程通信的实验报告
一、实验目的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. 信号量通信实验结果：父进程成功获取资源，子进程成功释放资源。
进程通讯管理实验报告(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操作，实现进程间的同步和互斥。
五、实验结果通过实验，我们成功实现了进程的创建、调度和终止，以及进程间的信息传递和同步管理。
实验三、进程通信一 ——管道及共享内存
操作系统实验报告实验三、进程通信（一）——管道及共享存一、实验目的1）加深对管道通信的了解2）掌握利用管道进行通信的程序设计3）了解共享存通信的程序设计方法4）了解和熟悉Linux支持的共享存储区机制二、实验容任务一、（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析。
（2）编写程序：父进程利用管道将一字符串交给子进程处理。
子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串。
任务二、（1）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享存的情况，对两次的结果进行比较，并分析原因。
最后用ipcrm命令删除自己建立的共享存储区。
（有关ipcs和ipcrm介绍见后面一页）（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。
运行结束后可以用ctrl+c结束程序1的运行。
（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。
要求在父进程中生成一个30字节长的私有共享存段。
接下来，设置一个指向共享存段的字符指针，将一串大写字母写入到该指针指向的存贮区。
调用fork()生成子进程，让子进程显示共享存段中的容。
接着，将大写字母改成小写，子进程修改共享存中的容。
之后，子进程将脱接共享存段并退出。
父进程在睡眠5秒后，在此显示共享存段中的容（此时已经是小写字母）。
三、代码及运行结果分析（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析实验代码：#include<stdio.h>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);}}运行结果：分析：调用pipe(fd);创建一个管道后，接着调用fork()函数产生两个进程，首先开始执行子进程，关闭管道出口，通过管道入口向管道中写入容。
操作系统原理进程通信共享内存
操作系统原理进程通信共享内存进程通信是操作系统中的重要概念，它允许不同的进程之间进行数据的交流和共享。
其中，共享内存是一种高效的进程通信机制，它允许多个进程访问同一块内存区域，从而实现数据的共享和传输。
在本文中，我们将深入探讨进程通信中的共享内存机制，并介绍其原理和实现。
一、共享内存的原理共享内存是一种在多进程环境下进行数据共享的方法，它的核心思想是将一块内存区域映射到多个进程的地址空间中，使得它们可以直接读写该内存区域的数据，而无需通过操作系统的内核进行数据的拷贝。
这种直接的访问方式可以在一定程度上提高数据传输的效率，使得进程之间的通信更加高效。
共享内存的实现通常包括以下几个步骤：1.创建共享内存区域：首先，需要调用操作系统提供的相关函数来创建一个共享内存区域，该区域可以通过一个唯一的标识符来进行识别。
2.映射共享内存区域：创建好共享内存区域后，操作系统将返回该区域的地址信息。
进程可以通过将该地址映射到自己的地址空间中来访问共享内存区域。
3.访问共享内存：一旦获得了共享内存的地址，进程就可以直接对其进行读写操作，就像对普通的内存一样。
多个进程可以同时对共享内存进行读写操作，实现数据的共享和传输。
4.解除映射：完成对共享内存的操作后，进程需要调用相应的函数来解除对该内存区域的映射，以便操作系统回收相关资源。
二、共享内存的优缺点虽然共享内存是高效的进程通信机制，但在实际应用中也存在一些优缺点。
1.优点：（1）高效：由于共享内存是直接映射到进程地址空间中的，所以进程可以直接对其进行读写操作，无需经过内核的拷贝。
这样可以减少数据传输的开销，提高通信的效率。
（2）灵活性：共享内存允许多个进程同时对同一块内存区域进行读写操作，使得进程之间的数据共享更加灵活，可以满足不同进程之间不同的通信需求。
2.缺点：（1）同步问题：由于多个进程可以同时对共享内存进行读写操作，可能会出现数据一致性的问题。
为了避免数据的混乱，需要通过其他方式进行进程间的同步和互斥操作，如信号量等。
操作系统实验---进程通信——共享存储区和信号量
实验报告实验题目姓名：学号：课程名称：操作系统实验所在学院：信息科学与工程学院专业班级：计算机任课教师：实验项目名称进程通信——共享存储区和信号量一、实验目的与要求：1、了解和熟悉共享存储机制2、了解和熟悉信号量机制3、熟悉信号量机制中使用的数据结构和信号量机制的操作以及控制。
4、了解共享主存段机制，学会对共享主存段的系统调用。
二、实验设备及软件：1、PC机一台2、Linux操作系统三、实验方法（原理、流程图）一、共享存储区1、共享存储区机制的概念共享存储区（Share Memory）是 UNIX 系统中通信速度最高的一种通信机制。
该机制可使若干进程共享主存中的某一个区域，且使该区域出现（映射）在多个进程的虚地址空间中。
另一方面，一个进程的虚地址空间中又可连接多个共享存储区，每个共享存储区都有自己的名字。
当进程间欲利用共享存储区进行通信时，必须先在主存中建立一共享存储区，然后将它附接到自己的虚地址空间上。
此后，进程对该区的访问操作，与对其虚地址空间的其它部分的操作完全相同。
进程之间便可通过对共享存储区中数据的读、写来进行直接通信。
图示列出二个进程通过共享一个共享存储区来进行通信的例子。
其中，进程 A 将建立的共享存储区附接到自己的 AA’区域，进程 B 将它附接到自己的 BB’区域。
应当指出，共享存储区机制只为进程提供了用于实现通信的共享存储区和对共享存储区进行操作的手段，然而并未提供对该区进行互斥访问及进程同步的措施。
因而当用户需要使用该机制时，必须自己设置同步和互斥措施才能保证实现正确的通信。
二、涉及的系统调用1、shmget( )创建、获得一个共享存储区。
系统调用格式： shmid=shmget(key,size,flag)参数定义： int shmget(key,size,flag);key_t key;int size,flag;其中，key是共享存储区的名字；size是其大小（以字节计）；flag是用户设置的标志，如IPC_CREAT。
进程控制与进程通信程序实验报告
进程控制与进程通信程序实验报告进程控制与进程通信程序实验报告本次实验主要涉及进程控制和进程通信两个方面。
进程控制是指操作系统对进程的管理和控制，包括创建、撤销、挂起、恢复等操作。
进程通信是指进程之间进行信息交换的过程，包括共享内存、管道、消息队列等方式。
在本次实验中，我们使用了C语言编写了两个程序，一个是父进程程序，一个是子进程程序。
父进程程序通过fork()函数创建子进程，然后通过wait()函数等待子进程结束。
子进程程序则通过exec()函数执行另一个程序。
这个程序是一个简单的计算器程序，可以进行加减乘除运算。
在进程通信方面，我们使用了共享内存的方式进行进程间通信。
共享内存是指多个进程共享同一块内存空间，可以实现进程间的数据共享。
在本次实验中，我们使用了shmget()函数创建共享内存，shmat()函数将共享内存映射到进程的地址空间中，shmdt()函数将共享内存从进程的地址空间中分离，shmctl()函数控制共享内存的状态。
在父进程程序中，我们使用了共享内存来传递两个操作数和操作符。
父进程程序首先创建共享内存，然后将两个操作数和操作符写入共享内存中。
子进程程序通过共享内存读取这些数据，并进行相应的计算。
计算结果再通过共享内存传递回父进程程序，父进程程序读取共享内存中的结果并输出。
本次实验的结果表明，进程控制和进程通信是操作系统中非常重要的概念。
掌握了这些概念，可以更好地理解操作系统的工作原理，也可以更好地编写高效的程序。
同时，共享内存是一种非常实用的进程通信方式，可以在多个进程之间实现数据共享，提高程序的效率。
总之，本次实验让我们更深入地了解了进程控制和进程通信的概念和实现方式。
通过编写程序，我们掌握了fork()、wait()、exec()、shmget()、shmat()、shmdt()、shmctl()等函数的使用方法，也更好地理解了操作系统的工作原理。
计算机操作系统实验二 进程间通信
南京信息工程大学实验（实习）报告实验（实习）名称进程间通信实验（实习）日期 20131130 得分指导教师系计算机系专业计科年级 2011 班次 1 姓名汤建洋学号 20112308018 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”。
linux进程间通信实验心得
linux进程间通信实验心得随着对Linux系统的深入了解，我对进程间通信（IPC）的重要性有了更深刻的认识。
在这次实验中，我通过实际操作，掌握了多种Linux进程间通信的方法，并对它们的特点和应用场景有了更清晰的了解。
实验过程中，我主要接触了三种主要的进程间通信方法：管道（Pipe）、信号（Signal）和共享内存（Shared Memory）。
每种方法都有其独特的特点和使用场景。
管道是最基本的进程间通信方式，它允许父子进程之间进行通信。
通过管道，一个进程可以将数据写入到管道中，而另一个进程可以从管道中读取数据。
我在实验中创建了多个进程，并通过管道实现了它们之间的数据传递。
虽然管道简单易用，但它的通信能力有限，只能用于父子进程或兄弟进程之间的通信。
信号是一种异步的进程间通信方式，一个进程可以向另一个进程发送信号。
接收进程可以根据信号的类型采取不同的行动。
我在实验中通过信号实现了进程间的控制和同步。
虽然信号可以用于任何两个进程之间的通信，但由于它是异步的，使用起来需要小心处理信号的捕获和处理。
共享内存是一种高效的进程间通信方式，它允许多个进程访问同一块内存空间。
通过共享内存，进程可以快速地读写数据，避免了数据在进程间传递的开销。
我在实验中创建了多个进程，让它们共享一块内存区域，并通过读写共享内存实现了数据的快速传递。
共享内存的优点是通信速度快，但需要处理好同步和互斥问题，以避免数据冲突和错误。
通过这次实验，我对Linux进程间通信有了更深入的了解。
在实际应用中，需要根据具体的需求和场景选择合适的进程间通信方法。
同时，我也认识到进程间通信的复杂性和挑战性，需要仔细考虑和处理各种可能的问题。
在未来的学习和工作中，我将继续深入学习Linux系统及其相关技术，不断提高自己的技能和能力。
同时，我也将关注新技术的发展和应用，保持对行业的敏感度和竞争力。
进程共享内存实验报告
一、实验目的1. 理解进程共享内存的概念和原理；2. 掌握在Linux环境下使用共享内存进行进程间通信的方法；3. 通过实验验证共享内存的通信效率和同步机制。
二、实验环境1. 操作系统：Linux2. 编程语言：C3. 开发环境：GCC编译器三、实验原理共享内存（Shared Memory）是Linux系统中实现进程间通信的一种方式。
它允许多个进程共享一块物理内存，使得这些进程可以直接访问这块内存区域，从而实现高效的数据交换。
共享内存的原理如下：1. 操作系统为共享内存分配一块物理内存区域；2. 将这块物理内存映射到各个进程的虚拟地址空间中；3. 进程通过访问虚拟地址空间中的共享内存区域，实现对共享内存的读写操作。
为了确保多个进程对共享内存的访问互不干扰，需要使用同步机制，如互斥锁（Mutex）和信号量（Semaphore）。
四、实验步骤1. 创建共享内存```c#include <sys/ipc.h>#include <sys/shm.h>int main() {key_t key = ftok("shared_memory", 65);int shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT);if (shmid == -1) {perror("shmget");return 1;}return shmid;}```2. 映射共享内存```c#include <sys/mman.h>int main() {int shmid = 12345; // 假设已经获取了共享内存的IDint shared_memory = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);if (shared_memory == MAP_FAILED) {perror("mmap");return 1;}return 0;}```3. 写入数据```c#include <stdio.h>int main() {int shmid = 12345; // 假设已经获取了共享内存的IDint shared_memory = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);if (shared_memory == MAP_FAILED) {perror("mmap");return 1;}shared_memory = 100;printf("Shared memory value: %d\n", shared_memory);return 0;}```4. 读取数据```c#include <stdio.h>int main() {int shmid = 12345; // 假设已经获取了共享内存的IDint shared_memory = mmap(NULL, sizeof(int), PROT_READ, MAP_SHARED, shmid, 0);if (shared_memory == MAP_FAILED) {perror("mmap");return 1;}printf("Shared memory value: %d\n", shared_memory);return 0;}```5. 销毁共享内存```c#include <sys/ipc.h>#include <sys/shm.h>int main() {int shmid = 12345; // 假设已经获取了共享内存的IDif (shmctl(shmid, IPC_RMID, NULL) == -1) {perror("shmctl");return 1;}return 0;}```五、实验结果与分析1. 实验成功创建了共享内存，并通过mmap将其映射到进程的虚拟地址空间；2. 通过读写操作，验证了共享内存的通信效率和同步机制；3. 在多个进程之间使用共享内存进行通信，实现了高效的数据交换。
进程通信实验报告
进程通信实验报告进程通信实验报告概述进程通信是操作系统中非常重要的一个概念，它允许不同的进程之间进行数据的交换和共享。
在本次实验中，我们通过使用不同的进程通信机制，如管道、消息队列和共享内存，来实现进程之间的数据传输和通信。
本报告将详细介绍实验的背景、实验过程、结果分析以及对实验的总结。
实验背景进程通信是操作系统中的一个核心概念，它允许多个进程之间进行数据的交换和共享。
在现代操作系统中，进程通信是实现并发和协作的重要手段。
了解不同的进程通信机制以及它们的优缺点对于深入理解操作系统的原理和实现至关重要。
实验过程在本次实验中，我们使用了三种不同的进程通信机制：管道、消息队列和共享内存。
首先，我们创建了两个进程，一个作为发送方，一个作为接收方。
然后，我们分别使用了管道、消息队列和共享内存来实现进程之间的数据传输和通信。
管道是一种最简单的进程通信机制，它可以在父进程和子进程之间进行单向的通信。
我们通过创建一个管道，并将其连接到父进程和子进程的标准输入和标准输出，实现了父子进程之间的数据传输。
消息队列是一种更为灵活的进程通信机制，它可以实现多个进程之间的双向通信。
我们使用了系统提供的消息队列函数，创建了一个消息队列，并在发送方将消息发送到队列中，接收方则从队列中接收消息。
通过消息队列，我们实现了进程之间的异步通信。
共享内存是一种高效的进程通信机制，它允许多个进程共享同一块内存空间。
我们使用了共享内存函数，创建了一个共享内存区域，并将其映射到两个进程的虚拟地址空间中。
通过共享内存，我们实现了进程之间的数据共享和同步。
结果分析通过实验，我们发现不同的进程通信机制各有优缺点。
管道是最简单的一种机制，但只能实现单向通信，且只能用于具有亲缘关系的进程。
消息队列可以实现多个进程之间的双向通信，但消息的顺序可能会被打乱。
共享内存是最高效的一种机制，但需要额外的同步机制来保证数据的一致性。
总结进程通信是操作系统中非常重要的一个概念，它允许不同的进程之间进行数据的交换和共享。
进程和进程管道通信实验
close(pipe4[0]);
close(pipe1[1]);
close(pipe3[0]);
pause();//暂停，等待进程3唤醒
//每次从管道1的0端读取x
//进行函数运算后，将函数运算结果fx通过管道1的1端写入
do{
read(pipe1[0],&x,sizeof(int));
CPU英特尔酷睿i7四核2.53GHz
主板LENOVO -英特尔HM65 (Cougar Point) [B3]
内存Ramaxel Technology 4G DDR3 SDRAM 1333 MHz双通道
显卡ATI Mobility Radeon HD 6500M
主硬盘希捷500GB
声卡High Definition Audio Controller [B3]
close(pipe2[1]);
close(pipe4[0]);
close(pipe1[1]);
close(pipe3[0]);
//子进程执行结束
printf("child%dread.\n",getpid());
exit(EXIT_SUCCESS);
}
}
}
//父进程执行结束
returnEXIT_SUCCESS;
网卡英特尔WiFi Link 1000 BGN
实验思路
本实验的设置首先要参考到实验一中的协同进程运行。首先创建3个子进程，分别处理f(x)、f(y)、f(x,y)。由于f(x)和f(x,y)、f(y)和f(x,y)之间需要交换数据，参考实验手册可以发现：管道是半双工的，所以需要4个管道。再加上管道默认的同步方式是同步读写，所以可以建立低些的循环，进行运算。
实验二,进程通信,管道共享内存
操作系统实验报告实验二：进程通信（一）——管道及共享内存一、实验目的•了解进程之中相互通信的方式•加深对管道通信的了解•了解共享内存通信的程序设计方法•了解和熟悉Linux支持的共享存储区机制二、实验内容和步骤任务一、（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析。
（2）编写程序：父进程利用管道将一字符串交给子进程处理。
子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串任务二、1）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享内存的情况，对两次的结果进行比较，并分析原因。
最后用ipcrm命令删除自己建立的共享存储区。
（有关ipcs和ipcrm介绍见后面一页）（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。
运行结束后可以用ctrl+c结束程序1的运行。
（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。
要求在父进程中生成一个30字节长的私有共享内存段。
接下来，设置一个指向共享内存段的字符指针，将一串大写字母写入到该指针指向的存贮区。
调用fork()生成子进程，让子进程共享内存段中的内容。
接着，将大写字母改成小写，子进显示程修改共享内存中的内容。
之后，子进程将脱接共享内存段并退出。
父进程在睡眠5秒后，在此显示共享内存段中的内容（此时已经是小写字母）。
三、代码及运行结果分析1.任务1（1）①代码：#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>#include<string.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);}}②截图：③结果和分析：创建一个管道，调用fork（）函数产生两个进程，我的系统优先先执行父进程，比较疑惑，既然这样，管道中并没有数据是如何得出最后结果的，后来百度了一下解释说是因为管道本身是一种同步机制，并且printf执行的时间要比其他程序时间长得多，才会这样。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验报告实验二：进程通信（一）——管道及共享内存一、实验目的•了解进程之中相互通信的方式•加深对管道通信的了解•了解共享内存通信的程序设计方法•了解和熟悉Linux支持的共享存储区机制二、实验内容和步骤任务一、（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析。
（2）编写程序：父进程利用管道将一字符串交给子进程处理。
子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串任务二、1）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享内存的情况，对两次的结果进行比较，并分析原因。
最后用ipcrm命令删除自己建立的共享存储区。
（有关ipcs和ipcrm介绍见后面一页）（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。
运行结束后可以用ctrl+c结束程序1的运行。
（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。
要求在父进程中生成一个30字节长的私有共享内存段。
接下来，设置一个指向共享内存段的字符指针，将一串大写字母写入到该指针指向的存贮区。
调用fork()生成子进程，让子进程共享内存段中的内容。
接着，将大写字母改成小写，子进显示程修改共享内存中的内容。
之后，子进程将脱接共享内存段并退出。
父进程在睡眠5秒后，在此显示共享内存段中的内容（此时已经是小写字母）。
三、代码及运行结果分析1.任务1（1）①代码：#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>#include<string.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);}}②截图：③结果和分析：创建一个管道，调用fork（）函数产生两个进程，我的系统优先先执行父进程，比较疑惑，既然这样，管道中并没有数据是如何得出最后结果的，后来百度了一下解释说是因为管道本身是一种同步机制，并且printf执行的时间要比其他程序时间长得多，才会这样。
然后执行子程序，将数据写入管道，然后父程序打印出来2. 任务1（2）①代码：#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>#include<string.h>#include<stdlib.h>void fanzhuan(char *s){char *p=s+strlen(s)-1;char temp;while(s<p){temp=*p;*p--=*s;*s++=temp;}}int main(){int i,x,fd[2];char buf[20],s[20],m[20];strcpy(buf,"This is an example\n");pipe(fd);write(fd[1],buf,20);while((x=fork())==-1);if(x==0){printf("Child Process!\n");read(fd[0],s,20);//printf("%s\n",s);fanzhuan(s);write(fd[1],s,20);exit(0);}else{wait(NULL);close(fd[1]);printf("Parent Process!\n");read(fd[0],m,20);printf("%s\n",m);}}②截图：3. 任务2（1）①代码：#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include<stdio.h>#include<stdlib.h>int main(){key_t key=105;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);}②截图：③结果和分析：两次运行结束后，第二个共享标识符不一样，然后在每一次的ipcs 查看共享存储区的时候，最后一行也是不一样的。
原因是分配了两次，然后第一次有key值，第二次是没有的。
4. 任务2（2）①代码：程序1：#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include<stdio.h>#include<stdlib.h>#include<signal.h>#include<unistd.h>#define SHMKEY 105#define K 1024int shmid;int main(){int i,*pint;char *addr;extern void* shmat();extern cleanup();for(i=0;i<20;i++)signal(i,cleanup);shmid=shmget(SHMKEY,16*K,0777|IPC_CREAT);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<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include<stdio.h>#include<stdlib.h>#include<signal.h>#include<unistd.h>#define SHMKEY 105#define K 1024int shmid;int main(){int i,*pint;char *addr;extern void *shmat();shmid=shmget(SHMKEY,8*K,0777);addr=shmat(shmid,0,0);pint=(int *)addr;for(i=0;i<256;i++)printf("%d\n",*pint++);}②截图：③结果和分析：程序（1）后台运行的时候，先创建一个共享内存段，然后挂接，得到共享区的地址，并且输出这个地址，然后pint的首地址就是共享区首地址，向共享区里面输入1,2,3,4,5.。
155。
程序（2）执行的时候首先先挂接到这个共享区，然后向从首地址开始遍历，输出其中的内容5. 任务2（3）①代码：#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include<stdlib.h>#include<unistd.h>#include<sys/wait.h>#include<string.h>#include<stdio.h>int main(){key_t key=105;int shmid,p1,i;char *addr,*pint,temp;shmid=shmget(key,30,0644|IPC_CREAT);addr=shmat(shmid,0,0);for(i=0;i<5;i++){*addr='A'+i;addr++;}while((p1=fork())==-1);if(p1==0){shmid=shmget(105,30,0644);printf("success\n");addr=shmat(shmid,0,0);for(i=0;i<5;i++){temp=*addr;*addr=temp+32;addr++;}addr=shmat(shmid,0,0);printf("%s\n",addr);shmdt(addr);}else{sleep(5);addr=shmat(shmid,0,0);printf("%s\n",addr);}//printf("%s\n",addr);shmctl(shmid,IPC_RMID,0);exit(0);}②截图：③结果和分析：首先显示创建一个要求的共享区，然后挂接上去，得到共享区首地址，向共享区中输入一串大写字符串，然后调用fork（），生成一个子程序，先让挂接到共享区，并且获得首地址，然后修改大写字母变成小写字母，然后脱离，最后再次调用父程序，获得首地址，然后输出共享区的内容。