实验五 进程间通信(二)
进程控制实验报告
一、实验目的本次实验旨在通过Linux操作系统的实践操作，加深对进程控制概念的理解。
通过学习进程的创建、调度、同步、通信等基本操作，掌握进程控制的基本方法，并了解进程间通信的机制。
二、实验环境1. 硬件环境：Intel(R) Core(TM) i5-3210M CPU2.50GHz，4.00GB内存。
2. 软件环境：64位Linux操作系统。
三、实验内容1. 进程的创建与终止2. 进程的调度与优先级3. 进程同步与互斥4. 进程间通信四、实验步骤1. 进程的创建与终止（1）使用`fork()`函数创建子进程，通过比较返回值判断创建是否成功。
```cpid_t pid = fork();if (pid < 0) {perror("fork failed");exit(1);}```（2）使用`exit()`函数终止进程。
```cexit(0);```2. 进程的调度与优先级（1）使用`nice()`函数调整进程优先级。
```cnice(10); // 降低进程优先级```（2）使用`priority_seta()`函数设置进程优先级。
```cstruct sched_param param;param.sched_priority = 10;if (sched_setscheduler(pid, SCHED_RR, ¶m) == -1) { perror("sched_setscheduler failed");exit(1);}```3. 进程同步与互斥（1）使用`semaphore_t`类型的信号量实现进程同步。
```csemaphore_t sem;sem_init(&sem, 0, 1);sem_wait(&sem);// 执行临界区代码sem_post(&sem);sem_destroy(&sem);```（2）使用`mutex_t`类型的互斥锁实现进程互斥。
操作系统实验二实验报告
操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术，包括进程的创建、执行、同步和通信。
通过实际编程和实验操作，提高对操作系统原理的认识，培养解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程环境为 Visual Studio 2019。
三、实验内容及步骤（一）进程创建实验1、首先，创建一个新的 C+＋项目。
2、在项目中，使用 Windows API 函数`CreateProcess`来创建一个新的进程。
3、为新进程指定可执行文件的路径、命令行参数、进程属性等。
4、编写代码来等待新进程的结束，并获取其退出代码。
（二）进程同步实验1、设计一个生产者消费者问题的模型。
2、使用信号量来实现生产者和消费者进程之间的同步。
3、生产者进程不断生成数据并放入共享缓冲区，当缓冲区已满时等待。
4、消费者进程从共享缓冲区中取出数据进行处理，当缓冲区为空时等待。
（三）进程通信实验1、选择使用管道来实现进程之间的通信。
2、创建一个匿名管道，父进程和子进程分别读写管道的两端。
3、父进程向管道写入数据，子进程从管道读取数据并进行处理。
四、实验结果及分析（一）进程创建实验结果成功创建了新的进程，并能够获取到其退出代码。
通过观察进程的创建和执行过程，加深了对进程概念的理解。
（二）进程同步实验结果通过使用信号量，生产者和消费者进程能够正确地进行同步，避免了缓冲区的溢出和数据的丢失。
分析结果表明，信号量机制有效地解决了进程之间的资源竞争和协调问题。
（三）进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。
数据能够准确地在进程之间传递，验证了管道通信的有效性。
五、遇到的问题及解决方法（一）在进程创建实验中，遇到了参数设置不正确导致进程创建失败的问题。
通过仔细查阅文档和调试，最终正确设置了参数，成功创建了进程。
（二）在进程同步实验中，出现了信号量使用不当导致死锁的情况。
操作系统实验报告
篇一：操作系统实验报告完全版《计算机操作系统》实验报告班级：姓名：学号：实验一进程控制与描述一、实验目的通过对windows 2000编程，进一步熟悉操作系统的基本概念，较好地理解windows 2000的结构。
通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解windows 2000中进程的“一生”。
二、实验环境硬件环境：计算机一台，局域网环境；软件环境：windows 2000 professional、visual c++6.0企业版。
三、实验内容和步骤第一部分:程序1-1windows 2000 的gui 应用程序windows 2000 professional下的gui应用程序，使用visual c++编译器创建一个gui应用程序，代码中包括了winmain()方法，该方法gui类型的应用程序的标准入口点。
:: messagebox( null, “hello, windows 2000” , “greetings”,mb_ok) ;/* hinstance */ , /* hprevinstance */, /* lpcmdline */, /* ncmdshow */ )return(0) ; }在程序1-1的gui应用程序中，首先需要windows.h头文件，以便获得传送给winmain() 和messagebox() api函数的数据类型定义。
接着的pragma指令指示编译器/连接器找到user32.lib库文件并将其与产生的exe文件连接起来。
这样就可以运行简单的命令行命令cl msgbox.cpp来创建这一应用程序，如果没有pragma指令，则messagebox() api函数就成为未定义的了。
这一指令是visual studio c++ 编译器特有的。
接下来是winmain() 方法。
其中有四个由实际的低级入口点传递来的参数。
操作系统实验报告6
操作系统实验报告6一、实验目的本次操作系统实验的主要目的是深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关技术，通过实际操作和观察，增强对操作系统工作原理的理解，并提高解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，实验工具包括 Visual Studio 2019 等。
三、实验内容（一）进程管理实验1、创建多个进程，并观察它们的运行状态和资源占用情况。
通过编写简单的C+＋程序，使用Windows API 函数创建多个进程。
在程序中，设置不同的进程优先级和执行时间，观察操作系统如何调度这些进程，以及它们对 CPU 使用率和内存的影响。
2、进程间通信实现了进程间的管道通信和消息传递。
通过创建管道，让两个进程能够相互交换数据。
同时，还使用了 Windows 的消息机制，使进程之间能够发送和接收特定的消息。
（二）内存管理实验1、内存分配与释放使用 C+＋的动态内存分配函数（如｀malloc` 和｀free`），在程序运行时动态申请和释放内存。
观察内存使用情况，了解内存碎片的产生和处理。
2、虚拟内存管理研究了 Windows 操作系统的虚拟内存机制，通过查看系统的性能监视器，观察虚拟内存的使用情况，包括页面文件的大小和读写次数。
（三）文件系统实验1、文件操作进行了文件的创建、读取、写入、删除等基本操作。
通过编写程序，对不同类型的文件（如文本文件、二进制文件）进行处理，了解文件系统的工作原理。
2、目录操作实现了目录的创建、删除、遍历等功能。
了解了目录结构在文件系统中的组织方式和管理方法。
四、实验步骤（一）进程管理实验步骤1、打开 Visual Studio 2019，创建一个新的 C+＋控制台项目。
2、在项目中编写代码，使用｀CreateProcess` 函数创建多个进程，并设置它们的优先级和执行时间。
3、编译并运行程序，通过任务管理器观察进程的运行状态和资源占用情况。
实验四 进程间通信实验(一)
实验四进程间通信实验（一）实验目的：1.通过基础实验，基本掌握共享内存的程序设计。
2.通过编写程序，使读者掌握消息队列的设计方法。
实验内容：1.共享内存程序设计：创建两个进程，在A进程中创建一个共享内存，并向其写入数据，通过B进程从共享内存中读出数据。
2.消息队列程序设计：创建一个消息队列，如何使用消息队列进行两个进程（发送端和接受端）之间的通信，包括消息队列的创建、消息发送与读取、消息队列的撤销和删除等多种操作。
实验过程：（一）共享内存程序设计❝函数说明：共享内存的实现分为两个步骤，第一步是创建共享内存，这里用到的函数是shmget()，也就是从内存中获得一段共享内存区域。
第二步映射共享内存，也就是把这段创建的共享内存映射到具体的进程空间中，这里使用的函数是shmat()。
到这里，就可以使用这段共享内存了，也就是可以使用不带缓冲的I/O读写命令对其进行操作。
除此之外，当然还有撤销映射的操作，其函数为shmdt()。
❝共享内存的用法：使用共享内存进行进程间通信一般要经历下面几个步骤：[1]分配：进程通过调用shmget来分配一个共享内存块。
[2]映射：要让一个进程获取对一块共享内存的访问，这个进程必须先调用shmat映射共享内存。
[3]脱离与释放：当进程结束使用共享内存时，使用shmdt使共享内存脱离进程。
当不再需要共享内存时，使用shmctl（sid，IPC_RMID，0）删除它。
实验步骤及代码：1）自己建立文件夹，然后分别编辑shm_com.h、shm1.c、shm2.c./*shm_com.h*/#define TEXT_SZ 2048struct shared_use_st{int written_by_you;char some_text[TEXT_SZ];};--------------------------------------------------------------------------------------------------------------------功能描述：本程序申请和分配共享内存，然后轮询并读取共享内存中的数据，直至读到“end”/*shm1.c*/#include<unistd.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include "shm_com.h"int main(void){int running=1;void *shared_memory=(void *)0;struct shared_use_st *shared_stuff;int shmid;/*创建共享内存*/shmid=shmget((key_t) 1234,sizeof(struct shared_use_st),0666|IPC_CREAT);if(shmid==-1){fprintf(stderr,"shmget failed\n");exit(EXIT_FAILURE);}/*映射共享内存*/shared_memory=shmat(shmid,(void *)0,0);if(shared_memory==(void *)-1){fprintf(stderr,"shmat failed\n");exit(EXIT_FAILURE);}printf("Memory attached at %X\n",(int)shared_memory);/*让结构体指针指向这块共享内存*/shared_stuff=(struct shared_use_st *)shared_memory;/*控制读写顺序*/shared_stuff->written_by_you=0;/*循环地从共享内存中读数据，直到读到“end”为止*/while(running){if(shared_stuff->written_by_you){printf("You wrote:%s",shared_stuff->some_text);/*读进程睡眠1秒，同时会导致写进程睡眠1秒，做到先读后写*/sleep(1);shared_stuff->written_by_you=0;if(strncmp(shared_stuff->some_text,"end",3)==0){running=0;//结束循环}}}/*删除共享内存*/if(shmdt(shared_memory)==-1){fprintf(stderr,"shmdt failed\n");exit(EXIT_FAILURE);}exit(EXIT_SUCCESS);}----------------------------------------------------------------------------------------------------------------功能描述：本程序申请了上一段程序相同的共享内存，然后循环地向共享内存中写数据，直至写入“end”/*shm2.c*/#include<unistd.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include "shm_com.h"int main(void){int running=1;void *shared_memory=(void *)0;struct shared_use_st *shared_stuff;char buffer[BUFSIZ];int shmid;/*创建共享内存*/shmid=shmget((key_t) 1234,sizeof(struct shared_use_st),0666|IPC_CREAT);if(shmid==-1){fprintf(stderr,"shmget failed\n");exit(EXIT_FAILURE);}/*映射共享内存*/shared_memory=shmat(shmid,(void *)0,0);if(shared_memory==(void *)-1){fprintf(stderr,"shmat failed\n");exit(EXIT_FAILURE);}printf("Memory attached at %X\n",(int)shared_memory); /*让结构体指针指向这块共享内存*/shared_stuff=(struct shared_use_st *)shared_memory;/*循环地向共享内存中写入数据，直到写入的为“end”为止*/ while(running){while(shared_stuff->written_by_you==1){sleep(1); //等到读进程读完之后再写printf("waiting for client...\n");}printf("ENter some text:");fgets(buffer,BUFSIZ,stdin);strncpy(shared_stuff->some_text,buffer,TEXT_SZ);shared_stuff->written_by_you=1;if(strncmp(buffer,"end",3)==0){running=0; //结束循环}}/*删除共享内存*/if(shmdt(shared_memory)==-1){fprintf(stderr,"shmdt failed\n");exit(EXIT_FAILURE);}exit(EXIT_SUCCESS);}2）使用gcc shm1.c –o shm1和gcc shm2.c –o shm2 分别编译shm1.c和shm2.c3）在一个终端运行shm1，在另一个终端运行shm2。
电大操作系统实验报告3_ 进程管理实验
电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一，本次实验的目的是通过实际操作和观察，深入理解进程的概念、状态转换、进程调度以及进程间的通信机制，掌握操作系统中进程管理的基本原理和方法，提高对操作系统的整体认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C 语言，开发工具为 Visual Studio 2019。
三、实验内容及步骤（一）进程的创建与终止1、编写一个 C 程序，使用系统调用创建一个子进程。
2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。
3、子进程执行一段简单的计算任务，父进程等待子进程结束后输出结束信息。
以下是实现上述功能的 C 程序代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>include ＜unistdh>int main(）｛pid_t pid;pid ＝ fork(）；if （pid ＜ 0) ｛printf(＂创建子进程失败\n"）；return 1;｝ else if （pid ＝＝ 0) ｛printf(＂子进程：我的进程 ID 是％d，父进程 ID 是％d\n"，getpid(）， getppid(））；int result ＝ 2 ＋ 3;printf(＂子进程计算结果：2 ＋ 3 ＝％d\n"， result)；exit(0)；｝ else ｛printf(＂父进程：我的进程 ID 是％d，子进程 ID 是％d\n"，getpid(）， pid)；wait(NULL)；printf(＂子进程已结束\n"）；｝return 0;｝｀｀｀编译并运行上述程序，可以观察到父进程和子进程的输出信息，验证了进程的创建和终止过程。
（二）进程的状态转换1、编写一个 C 程序，创建一个子进程，子进程进入睡眠状态一段时间，然后被唤醒并输出状态转换信息。
实验五：进程间通信
实验五：进程间通信实验五：进程间通信●实验目的：学会进程间通信方式：无名管道，有名管道，信号，共享内存●实验要求：（一）在父进程中创建一无名管道，并创建子进程来读该管道，父进程来写该管道（二）在进程中为SIGBUS注册处理函数，并向该进程发送SIGBUS信号（三）创建一共享内存，实现放进程间通信●实验器材：软件：安装了Linux的vmware虚拟机硬件：PC机一台●实验步骤：（一）无名管道的使用1、编写实验代码pipe_rw.c#include#include#include#include#include#includeint main(){int pipe_fd[2];pid_t pid;char buf_r[100];char* p_wbuf;int r_num;memset(buf_r,0,sizeof(buf_r));/*创建管道*/if(pipe(pipe_fd)<0){printf("pipe create error\n");return -1;}/*创建子进程*/if((pid=fork())==0) //子进程执行代码{//1、子进程先关闭了管道的写端//2、让父进程先运行，这样父进程先写子进程才有内容读//3、读取管道的读端，并输出数据//4、关闭管道的读端，并退出}else if(pid>0) //父进程执行代码{//1、父进程先关闭了管道的读端//2、向管道写入字符串数据//3、关闭写端，并等待子进程结束后退出}return 0;}2、编译应用程序pipe_rw.c3、运行应用程序子进程先睡两秒让父进程先运行，父进程分两次写入“hello”和“pipe”，然后阻塞等待子进程退出，子进程醒来后读出管道里的内容并打印到屏幕上再退出，父进程捕获到子进程退出后也退出4、由于fork函数让子进程完整地拷贝了父进程的整个地址空间，所以父子进程都有管道的读端和写端。
进程管理实验报告分析(3篇)
第1篇一、实验背景进程管理是操作系统中的一个重要组成部分，它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。
为了加深对进程管理的理解，我们进行了一系列实验，以下是对实验的分析和总结。
二、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。
2. 进一步认识并发执行的实质。
3. 分析进程争用资源的现象，学习解决进程互斥的方法。
4. 了解Linux系统中进程通信的基本原理。
三、实验内容1. 使用系统调用fork()创建两个子进程，父进程和子进程分别显示不同的字符。
2. 修改程序，使每个进程循环显示一句话。
3. 使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号，实现进程的终止。
4. 分析利用软中断通信实现进程同步的机理。
四、实验结果与分析1. 实验一：父进程和子进程分别显示不同的字符在实验一中，我们使用fork()创建了一个父进程和两个子进程。
在父进程中，我们打印了字符'a'，而在两个子进程中，我们分别打印了字符'b'和字符'c'。
实验结果显示，父进程和子进程的打印顺序是不确定的，这是因为进程的并发执行。
2. 实验二：每个进程循环显示一句话在实验二中，我们修改了程序，使每个进程循环显示一句话。
实验结果显示，父进程和子进程的打印顺序仍然是随机的。
这是因为并发执行的进程可能会同时占用CPU，导致打印顺序的不确定性。
3. 实验三：使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号在实验三中，我们使用signal()捕捉键盘中断信号（按c键），然后通过kill()向两个子进程发送信号，实现进程的终止。
实验结果显示，当按下c键时，两个子进程被终止，而父进程继续执行。
这表明signal()和kill()在进程控制方面具有重要作用。
4. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
湖北工业大学工程技术学院实验报告课程名称：操作系统实验内容：实验五进程间通信（二）学院：工程技术学院专业班级：11gb软件2班教师：贺红艳成绩：一、实验目的1、掌握linux系统中进程通信的基本原理。
2、学会使用linux系统中关于进程通信的一些系统调用。
3、掌握信号与共享存储区的使用方法。
二、相关知识背景：(一)信号1、信号的基本概念每个信号都对应一个正整数常量(称为signal number,即信号编号。
定义在系统头文件<signal.h>中)，代表同一用户的诸进程之间传送事先约定的信息的类型，用于通知某进程发生了某异常事件。
每个进程在运行时，都要通过信号机制来检查是否有信号到达。
若有，便中断正在执行的程序，转向与该信号相对应的处理程序，以完成对该事件的处理；处理结束后再返回到原来的断点继续执行。
实质上，信号机制是对中断机制的一种模拟，故在早期的UNIX版本中又把它称为软中断。
⑴信号与中断的相似点：①采用了相同的异步通信方式；②当检测出有信号或中断请求时，都暂停正在执行的程序而转去执行相应的处理程序；③都在处理完毕后返回到原来的断点；④对信号或中断都可进行屏蔽。
⑵信号与中断的区别：①中断有优先级，而信号没有优先级，所有的信号都是平等的；②信号处理程序是在用户态下运行的，而中断处理程序是在核心态下运行；③中断响应是及时的，而信号响应通常都有较大的时间延迟。
⑶信号机制具有以下三方面的功能：①发送信号。
发送信号的程序用系统调用kill( )实现；②预置对信号的处理方式。
接收信号的程序用signal( )来实现对处理方式的预置；③收受信号的进程按事先的规定完成对相应事件的处理。
2、信号的发送信号的发送，是指由发送进程把信号送到指定进程的信号域的某一位上。
如果目标进程正在一个可被中断的优先级上睡眠，核心便将它唤醒，发送进程就此结束。
一个进程可能在其信号域中有多个位被置位，代表有多种类型的信号到达，但对于一类信号，进程却只能记住其中的某一个。
进程用kill( )向一个进程或一组进程发送一个信号。
3．对信号的处理当一个进程要进入或退出一个低优先级睡眠状态时，或一个进程即将从核心态返回用户态时，核心都要检查该进程是否已收到软中断。
当进程处于核心态时，即使收到软中断也不予理睬；只有当它返回到用户态后，才处理软中断信号。
对软中断信号的处理分三种情况进行：①如果进程收到的软中断是一个已决定要忽略的信号（function=1），进程不做任何处理便立即返回；②进程收到软中断后便退出（function=0）；③执行用户设置的软中断处理程序。
4、所涉及的中断调用（1）kill( )系统调用格式int kill(pid,sig)参数定义int pid,sig;其中，pid是一个或一组进程的标识符，参数sig是要发送的软中断信号。
（1）pid>0时，核心将信号发送给进程pid。
（2）pid=0时，核心将信号发送给与发送进程同组的所有进程。
（3）pid=-1时，核心将信号发送给所有用户标识符真正等于发送进程的有效用户标识号的进程。
（2）signal( )预置对信号的处理方式，允许调用进程控制软中断信号。
系统调用格式signal(sig,function)头文件为#include <signal.h>参数定义signal(sig,function)int sig;void (*func) ( )signal() 会依参数sig指定的信号编号来设置该信号的处理函数。
当指定信号到达时就会跳转到参数function指定的函数执行。
其中sig用于指定信号的类型，sig为0则表示没有收到任何信号，余者如下表：function：该进程中的一个函数地址，在核心返回用户态时，它以软中断信号的序号作为参数调用该函数。
function 的解释如下：（1）function=1(SIG_IGN)时，进程对sig类信号不予理睬，亦即屏蔽了该类信号；（2）function=0(SIG_DFL)时，缺省值，进程在收到sig信号后应终止自己；（3）function为非0，非1类整数时，function的值即作为信号处理程序的指针。
（二）消息队列机制消息队列机制中提供了4个系统调用。
1、msgget 用于创建和指定一个消息队列。
格式为：msgqid=msgget(key,msgflg);key是消息关键字msgflg 是消息的标志。
2、msgsnd 消息发送格式为：msgsnd(msgqid,msgp,msgsz,msgflg);msgqid 消息队列描述符msgp 指向消息队列的指针msgsz 数组的大小msgflg消息发送同步标识3、msgrcv 接收消息格式为：msgrcv(msgqid,msgp,msgsz,msgtyp,msgflg)msgtyp 用户接收消息的类型4、msgctl 查询或设置消息描述符的状态。
格式为：msgctl(msgqid,cmd,buf);cmd 规定命令的类型：IPC—STAT 返回指定IPC工具的状态信息IPC—SET 指明可以改变IPC工具的所有者、组名和模式IPC—RMID 表示删除msgqid所对应的消息队列表项。
（三）共享内存区域共享内存区域是被多个进程共享的一部分物理内存。
如果多个进程都把该内存区域映射到自己的虚拟地址空间，则这些进程就都可以直接访问该共享内存区域，从而可以通过该区域进行通信。
共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。
这块共享虚拟内存的页面，出现在每一个共享该页面的进程的页表中。
但是它不需要在所有进程的虚拟内存中都有相同的虚拟地址。
图共享内存映射图以下是使用共享内存机制进行进程间通信的基本操作：需要包含的头文件：#include <sys/types.h>#include <sys/ipc.h>#include <sys/shm.h>1、创建共享内存：int shmget(key_t key,int size,int shmflg);参数说明：key:用来表示新建或者已经存在的共享内存去的关键字。
size：创建共享内存的大小。
shmflg：可以指定的特殊标志。
IPC_CREATE,IPC_EXCL以及低九位的权限。
eg：int shmid;shmid=shmget(IPC_PRIVATE,4096,IPC_CREAT|IPC_EXCL|0660);if(shmid==-1)perror("shmget()");2、连接共享内存char *shmat(int shmid,char *shmaddr,int shmflg);参数说明shmid：共享内存的关键字shmaddr：指定共享内存出现在进程内存地址的什么位置，通常我们让内核自己决定一个合适的地址位置，用的时候设为0。
shmflg：制定特殊的标志位。
eg：int shmid;char *shmp;shmp=shmat(shmid,0,0);if(shmp==(char *)(-1))perror("shmat()\n");3、使用共享内存在使用共享内存是需要注意的是，为防止内存访问冲突，我们一般与信号量结合使用。
4、分离共享内存：当程序不再需要共享内后，我们需要将共享内存分离以便对其进行释放，分离共享内存的函数原形如下：int shmdt(char *shmaddr);5、释放共享内存int shmctl(int shmid,int cmd,struct shmid_ds *buf);二、实验步骤1、利用Linux的软件中断信号，编写一段C语言程序完成：显示数字1-100，在程序运行中如果捕获到一个SIGINT信号，则转去执行输出“You enter CTRL+C”。
程序如下：#include<stdio.h>#include<signal.h>void func(int signo);main(){signal(SIGINT,func);int i;for(i=0;i<100;i++){printf("%d\n",i);sleep(1);}}void func(int signo){printf("You enter Ctrl+C\n");}5-2 server.c#include<sys/types.h>#include<sys/ipc.h>#include<sys/msg.h>#include<stdio.h>#include<unistd.h>#define MSGKEY 75 //定义一个消息关键字struct msgform //定义一个消息{int mtype; //消息类型char mtext[1024]; //消息正文}msg;int msgqid; //定义消息描述符void cleanup() //定义函数删除消息队列{msgctl(msgqid,IPC_RMID,0);//设置消息队列的状态，IPC_RMID 表示删除消息队列。
exit(0);}main(){int pid;signal(2,cleanup); //收到软件中断信号，转向cleanup函数处理msgqid=msgget(MSGKEY,0777|IPC_CREAT); //创建消息队列，server与client的MSGKEY必须相同。
printf("server:pid=%d\n",getpid()); //打印出服务端的进程号for(;;) //进入死循环，按ctrl+c退出。
{msgrcv(msgqid,&msg,1024,1,0); //接收消息client或消息类型为1的消息。
printf("server:receive from pid %s\n",msg.mtext);}}2、使用消息队列机制实现进程间的通信。
使用系统调用msgget (), msgsnd (), msgrev (), 及msgctl () 编制一长度为1k的消息的发送和接收程序。
程序如下：server.c#include<sys/types.h>#include<sys/ipc.h>#include<sys/msg.h>#include<stdio.h>#include<unistd.h>#define MSGKEY 75 //定义一个消息关键字struct msgform //定义一个消息{int mtype; //消息类型char mtext[1024]; //消息正文}msg;int msgqid; //定义消息描述符void cleanup() //定义函数删除消息队列{msgctl(msgqid,IPC_RMID,0);//设置消息队列的状态，IPC_RMID 表示删除消息队列。