实验四 Linux进程互斥
实验、进程的同步与互斥——生产者消费者
实验、进程的同步与互斥——⽣产者消费者1. 1. 实验⽬的两个或两个以上的进程,不能同时进⼊关于同⼀组共享变量的临界区域,否则可能发⽣与时间有关的错误,这种现象被称作进程互斥。
对CPU的速度和数⽬不做出任何假设的前提下，并发进程互斥访问临界资源，是⼀个较好的解决⽅案。
另外，还需要解决异步环境下的进程同步问题。
所谓异步环境是指：相互合作的⼀组并发进程，其中每⼀个进程都以各⾃独⽴的、不可预知的速度向前推进；但它们⼜需要密切合作，以实现⼀个共同的任务，即彼此“知道”相互的存在和作⽤。
实验⽬的：分析进程争⽤资源的现象，学习解决进程同步与互斥的⽅法。
本实验属于设计型实验，实验者可根据⾃⾝情况选⽤合适的开发环境和程序架构。
1. 2. 实验原理信号量的PV操作与处理相关，P表⽰通过的意思，V表⽰释放的意思。
1962年，狄克斯特拉离开数学中⼼进⼊位于荷兰南部的艾恩德霍芬技术⼤学(Eindhoven Technical University)任数学教授。
在这⾥，他参加了X8计算机的开发，设计与实现了具有多道程序运⾏能⼒的操作系统——THE Multiprogramming System。
THE是艾恩德霍芬技术⼤学的荷兰⽂Tchnische Hoogeschool Eindhov –en的词头缩写。
狄克斯特拉在THE这个系统中所提出的⼀系统⽅法和技术奠定了计算机现代操作系统的基础，尤其是关于多层体系结构，顺序进程之间的同步和互斥机制这样⼀些重要的思想和概念都是狄克斯特拉在THE中⾸先提出并为以后的操作系统如UNIX等所采⽤的。
为了在单处理机的情况下确定进程(process)能否占有处理机，狄克斯特拉将每个进程分为“就绪”(ready)、“运⾏”(running)和“阻塞”(blocking)三个⼯作状态。
由于在任⼀时刻最多只有⼀个进程可以使⽤处理机，正占⽤着处理机的进程称为“运⾏”进程。
当某进程已具备了使⽤处理机的条件，⽽当前⼜没有处理机供其使⽤，则使该进程处于“就绪”状态。
进程控制实验报告
一、实验目的本次实验旨在通过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`类型的互斥锁实现进程互斥。
进程的同步与互斥实验报告
进程的同步与互斥实验报告1.实验目的进程（线程）的同步与互斥是操作系统中非常重要的概念，本实验旨在通过实际操作，加深对这些概念的理解和掌握。
通过编写多个进程（线程），并在其间进行同步与互斥操作，验证同步与互斥的实际效果。
2.实验环境本实验在Linux系统下进行，使用C/C++语言编程。
3.实验内容3.1同步在实验中，我们编写了两个进程A和B，这两个进程需要按照特定的顺序执行。
为了实现同步，我们使用信号量机制来确保进程A和B按照正确的顺序执行。
3.2互斥在实验中，我们编写了多个进程C和D，这些进程需要同时对一个共享资源进行访问。
为了实现互斥，我们使用互斥锁机制来确保同一时刻只有一个进程访问共享资源。
4.实验过程4.1同步实验编写进程A和进程B的代码，使用信号量机制实现同步。
进程A先运行，然后通过信号量唤醒进程B，进程B再开始执行。
通过观察进程的运行顺序，验证同步机制是否起作用。
4.2互斥实验编写进程C和进程D的代码，使用互斥锁机制实现互斥。
进程C和进程D同时对一个共享资源进行访问，通过互斥锁来确保同一时刻只有一个进程访问共享资源。
观察进程的输出结果，验证互斥机制是否起作用。
5.实验结果5.1同步实验结果进程A开始执行进程A执行完毕进程B开始执行进程B执行完毕5.2互斥实验结果进程C开始执行进程C访问共享资源进程C执行完毕进程D开始执行进程D访问共享资源进程D执行完毕6.实验分析通过上述结果可以看出，同步实验中进程A和进程B按照正确的顺序执行，证明了同步机制的有效性。
互斥实验中进程C和进程D能够正确地交替访问共享资源，证明了互斥机制的有效性。
7.实验总结通过本次实验，我深刻理解了进程（线程）的同步与互斥，并通过实际操作加深了对这些概念的理解。
同步和互斥是操作系统中非常重要的概念，对于应对资源竞争和提高程序性能具有重要意义。
在实际开发中，我们应该合理使用同步和互斥机制，以确保程序的正确性和并发执行的效率。
信号量机制解决互斥问题实验报告
信号量机制解决互斥问题实验报告一、实验目的本实验旨在通过实际操作，深入理解信号量机制在解决互斥问题中的应用，并掌握其实现原理。
通过实验，我们将观察信号量如何确保对共享资源的互斥访问，从而提高多线程程序的安全性和稳定性。
二、实验环境操作系统：Linux编程语言：C语言开发工具：gcc编译器、终端三、实验原理信号量机制是一种常用的同步原语，用于解决多线程或多进程间的互斥问题。
信号量是一个整数值，通常用于表示资源的数量。
在解决互斥问题时，信号量通过维护一个非负的整数值来确保对共享资源的互斥访问。
四、实验步骤创建两个线程，它们需要访问共享资源。
使用信号量来同步这两个线程，确保它们不会同时访问共享资源。
在访问共享资源之前，线程必须获取信号量。
如果信号量的值为0，线程将被阻塞，直到信号量的值变为正值。
当线程完成对共享资源的访问后，释放信号量，使其值加1。
重复上述步骤，直到完成所有线程的同步操作。
五、实验代码实现以下是一个简单的C语言示例代码，演示了如何使用信号量解决互斥问题：#include <stdio.h>#include <pthread.h>// 定义共享资源数和线程数#define RESOURCE_COUNT 5#define THREAD_COUNT 2// 定义信号量变量pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;int semaphore = RESOURCE_COUNT; // 初始化为可用资源数void *thread_func(void *arg) {int i;for (i = 0; i < RESOURCE_COUNT; i++) {pthread_mutex_lock(&mutex); // 获取互斥锁，保护临界区代码printf("Thread %ld is accessing resource %d\n",pthread_self(), i);semaphore--; // 占用一个资源pthread_mutex_unlock(&mutex); // 释放互斥锁，允许其他线程进入临界区代码sleep(1); // 模拟耗时操作}pthread_exit(NULL);}int main() {pthread_t threads[THREAD_COUNT];int i;for (i = 0; i < THREAD_COUNT; i++) {pthread_create(&threads[i], NULL, thread_func, NULL); // 创建线程并执行函数thread_func()}for (i = 0; i < THREAD_COUNT; i++) {pthread_join(threads[i], NULL); // 等待所有线程执行完毕}return 0;}六、实验结果与分析通过运行上述代码，我们可以观察到以下实验结果：在多线程环境下，当一个线程正在访问共享资源时，其他线程将被阻塞，直到资源被释放。
进程管理实验报告分析(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. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。
实验四同步与互斥Linux实验报告
实验四同步与互斥【实验目的和要求】1、掌握进程（线程）的同步与互斥。
2、掌握生产者消费者问题的实现方法。
3、掌握多线程编程方法。
【实验内容】实现生产者消费者问题1、有一个仓库，生产者负责生产产品，并放入仓库，消费者会从仓库中拿走产品(消费)。
2、仓库中每次只能入一个(生产者或消费者)。
3、仓库中可存放产品的数量最多10个,当仓库放满时，生产者不能再放入产品。
4、当仓库空时，消费者不能从中取出产品。
5、生产、消费速度不同。
【实验原理】1、信号量mutex提供对缓冲池访问的互斥要求并初始化为1，信号量empty和full分别用来表示空缓冲项和满缓冲项的个数，信号量empty初始化为n，信号量full初始化为0。
2、定义如下结构及数据：定义缓冲区内的数据类型：typedef int buffer_item;缓冲区：buffer_item buffer[BUFFER_SIZE];对缓冲区操作的变量：int in,out;信号量mutex提供了对缓冲池访问的互斥要求：pthread_mutex_t mutex;信号量empty和full分别表示空缓冲顶和满缓冲顶的个数：sem_t empty,full; 可以设定生产者的生产速度及消费者的消费速度：int pro_speed,con_speed;对缓冲区操作的自增函数：#define inc(k) if(k < BUFFER_SIZE) k = k+1;else k=03、并定义了如下实现问题的函数模块：将生产的产品放入缓冲区： int insert_item(buffer_item item)从缓冲区内移走一个产品： int remove_item(buffer_item *item)生产者进程：void *producer(void *param)消费者进程：void *consumer(void *param)生产者结构进程消费者结构进程【程序代码】//sx.c#include<stdio.h>#include<stdlib.h>#include<pthread.h>#include<semaphore.h>#include<time.h>#define inc(k) if(k<BUFFER_SIZE) k=k+1;else k=0#define BUFFER_SIZE 10//缓冲区的大小typedef int buffer_item;//定义缓冲区内的数据类型buffer_item buffer[BUFFER_SIZE];//缓冲区int in,out;//对缓冲区操作的变量pthread_mutex_t mutex;//信号量mutex提供了对缓冲池访问的互斥要求sem_t empty,full;//信号量empty和full分别表示空缓冲顶和满缓冲顶的个数int pro_speed,con_speed;//可以设定生产者的生产速度及消费者的消费速度int insert_item(buffer_item item){//将生产的产品放入缓冲区buffer[in]=item;printf("******insert缓冲池第%d号******\n",in);inc(in);}int remove_item(buffer_item *item){//从缓冲区内移走一个产品*item = buffer[out];printf("******remove缓冲池第%d号******\n",out);inc(out);}void *producer(void *param){//生产者进程buffer_item item;int num = 0;while(1){sleep(rand()%(16-pro_speed));printf("\n******第%d次生产******\n",++num);printf("******等待empty信号******\n");sem_wait(&empty);printf("******等待解锁******\n");pthread_mutex_lock(&mutex);printf("******上锁，准备生产******\n");item = rand()%1000+1;printf("******生产产品%d*******\n",item);insert_item(item);printf("*******解锁******\n");printf("******第%d次生产结束*******\n\n",num); pthread_mutex_unlock(&mutex);sem_post(&full);}}void *consumer(void *param){//消费者进程buffer_item item;int num = 0;while(1){sleep(rand()%(16-con_speed));printf("\n******第%d次消费*****\n",++num); printf("******等待full信号******\n");sem_wait(&full);printf("******等待解锁******\n");pthread_mutex_lock(&mutex);printf("******上锁，准备消费******\n"); remove_item(&item);pthread_mutex_unlock(&mutex);sem_post(&empty);printf("******消费产品%d*******\n",item);printf("*******解锁******\n");printf("******第%d次消费结束*******\n\n",num); }}int main()//主函数{pthread_t tid1,tid2;pthread_attr_t attr1,attr2;srand(time(NULL));pthread_mutex_init(&mutex,NULL);//初始化sem_init(&empty,0,BUFFER_SIZE);sem_init(&full,0,0);in=0;out=0;printf("***********************\n");printf("********开始！***********\n");printf("***********************\n");printf("生产者速度(1-15):\n");scanf("%d",&pro_speed);printf("消费者速度(1-15):\n");scanf("%d",&con_speed);pthread_attr_init(&attr1);pthread_create(&tid1,&attr1,producer,NULL);pthread_attr_init(&attr2);pthread_create(&tid2,&attr2,consumer,NULL);sleep(100);printf("*******程序over*******\n");return 0;}【实验步骤】编写程序代码gedit sx.c,再对代码进行编译gcc sx.c –o sx –lpthread，编译无错误，进行运行./sx，根据提示要求进行填写生产者和消费速度，观察消费者和生产者进程。
进程的管理实验报告
一、实验目的1. 理解进程的基本概念和进程状态转换过程。
2. 掌握进程创建、进程同步和进程通信的方法。
3. 了解进程调度算法的基本原理和实现方法。
4. 通过实验加深对进程管理的理解，提高操作系统实践能力。
二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 开发工具：GCC三、实验内容1. 进程创建与状态转换（1）使用fork()函数创建一个子进程，并观察父进程和子进程的进程ID。
（2）使用exec()函数替换子进程的映像，实现进程的创建。
（3）观察进程状态转换过程，如创建、运行、阻塞、就绪、终止等。
2. 进程同步（1）使用互斥锁（mutex）实现进程的互斥访问共享资源。
（2）使用信号量（semaphore）实现进程的同步，如生产者-消费者问题。
（3）观察进程同步的效果，确保进程安全执行。
3. 进程通信（1）使用管道（pipe）实现进程间的单向通信。
（2）使用消息队列（message queue）实现进程间的双向通信。
（3）使用共享内存（shared memory）实现进程间的快速通信。
（4）观察进程通信的效果，确保数据正确传递。
（1）实现基于优先级的进程调度算法，如先来先服务（FCFS）和最高优先级优先（HPF）。
（2）实现基于时间片的轮转调度算法（RR）。
（3）观察进程调度算法的效果，分析不同算法的优缺点。
四、实验步骤1. 编写程序实现进程创建与状态转换，使用fork()和exec()函数。
2. 编写程序实现进程同步，使用互斥锁和信号量。
3. 编写程序实现进程通信，使用管道、消息队列和共享内存。
4. 编写程序实现进程调度，使用优先级调度和时间片轮转调度。
5. 编译并运行程序，观察实验结果，分析实验现象。
五、实验结果与分析1. 进程创建与状态转换通过实验，我们成功创建了父进程和子进程，并观察到进程ID的变化。
在进程创建过程中，父进程的进程ID与子进程的进程ID不同，说明子进程是独立于父进程的实体。
操作系统实验报告——进程同步与互斥
操作系统实验报告——进程同步与互斥一、实验内容本实验主要内容是通过编写程序来实现进程的同步与互斥。
具体来说，是通过使用信号量来实现不同进程之间的同步和互斥。
我们将编写两个进程，一个进程负责打印奇数，另一个进程负责打印偶数，两个进程交替打印，要求打印的数字从1开始，直到100结束。
二、实验原理进程的同步是指多个进程之间按照一定的顺序执行，进程之间互相等待的关系。
而进程的互斥是指多个进程竞争同一个资源，需要通过其中一种方式来避免同时访问共享资源，以免造成数据错乱。
在本实验中，我们使用信号量来实现进程的同步与互斥。
信号量是一个计数器，用于表示一些共享资源的可用数量。
进程在访问共享资源时，需要先对信号量进行操作，当信号量大于0时，表示资源可用，进程可以访问；当信号量等于0时，表示资源不可用，进程需要等待。
进程同步的实现可以通过信号量的P操作与V操作来完成。
P操作用于申请资源，当资源可用时，将计数器减一，并进入临界区；V操作用于释放资源，当资源使用完毕时，将计数器加一，使等待资源的进程能够申请。
进程互斥的实现可以通过信号量的P操作与V操作结合临界区来完成。
当多个进程需要访问共享资源时，需要先进行P操作，进入临界区，访问完毕后进行V操作，离开临界区。
三、实验步骤1.首先，我们需要创建两个进程，一个进程负责打印奇数，另一个进程负责打印偶数。
2. 然后，我们创建一个共享变量count，用来记录打印的数字。
3. 接着，我们创建两个信号量odd和even，用来控制进程的同步与互斥。
odd信号量初始值为1，表示打印奇数的进程可以访问；even信号量初始值为0，表示打印偶数的进程需要等待。
4.编写奇数打印进程的代码，首先进行P操作，判断奇数信号量是否大于0，如果大于0，表示可以打印奇数。
5. 如果可以打印奇数，将count加一，并输出当前的奇数，然后进行V操作，释放偶数打印进程的等待。
6.同样的，编写偶数打印进程的代码，首先进行P操作，判断偶数信号量是否大于0，如果大于0，表示可以打印偶数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四 Linux进程互斥一、实验目的熟悉Linux下信号量机制，能够使用信号量实现在并发进程间的互斥和同步。
二、实验题目使用共享存储区机制，使多个并发进程分别模拟生产者－消费者模式同步关系、临界资源的互斥访问关系，使用信号量机制实现相应的同步和互斥。
三、背景材料（一）需要用到的系统调用实验可能需要用到的主要系统调用和库函数在下面列出，详细的使用方法说明通过“man 2 系统调用名”或者“man 3 函数名”命令获取。
fork() 创建一个子进程，通过返回值区分是在父进程还是子进程中执行；wait() 等待子进程执行完成；shmget() 建立一个共享存储区；shmctl() 操纵一个共享存储区；s hmat() 把一个共享存储区附接到进程内存空间；shmdt() 把一个已经附接的共享存储区从进程内存空间断开；semget() 建立一个信号量集；semctl() 操纵一个信号量集，包括赋初值；semop() 对信号量集进行wait和signal操作；signal() 设置对信号的处理方式或处理过程。
（二）模拟生产者－消费者的示例程序本示例主要体现进程间的直接制约关系，由于使用共享存储区，也存在间接制约关系。
进程分为服务进程和客户进程，服务进程只有一个，作为消费者，在每次客户进程改变共享存储区内容时显示其数值。
各客户进程作为生产者，如果共享存储区内容已经显示（被消费），可以接收用户从键盘输入的整数，放在共享存储区。
编译后执行，第一个进程实例将作为服务进程，提示：ACT CONSUMER!!! To end, try Ctrl+C or use kill.服务进程一直循环执行，直到用户按Ctrl+C终止执行，或使用kill命令杀死服务进程。
其他进程实例作为客户进程，提示：Act as producer. To end, input 0 when prompted.客户进程一直循环执行，直到用户输入0。
示例程序代码如下：#include <sys/types.h>#include <unistd.h>#include <signal.h>#include <stdio.h>#include <string.h>#include <sys/ipc.h>#include <sys/shm.h>#include <sys/sem.h>#define MY_S HM KEY 10071500 // need to change#define MY_S EM KEY 10071500 // need to changevoid sigend(int);int shmid, semid;int main(void){int *shmptr, semval, local;struct sembuf semopbuf;/*这个函数成功时返回共享内存的ID，失败时返回-1。
*/if((shmid=shmget(MY_SHMKEY, sizeof(int), IPC_CREA T|IPC_EXCL|0666)) < 0){ /* shared memory exists, act as client */shmid=shmget(MY_SHMKEY, sizeof(int), 0666);//建立一个信号量集函数执行成功，则返回信号量集的标识符（一个大于等于0的整数），失败，则返回–1semid=semget(MY_SEMKEY, 2, 0666);//返回共享内存的起始地址。
失败时返回-1。
允许本进程使用这块共享内存shmptr=(int *)shmat(shmid, 0, 0);printf("Act as producer. To end, input 0 when prompted.\n\n");printf("Input a number:\n");scanf("%d", &local);while( local ){semopbuf.sem_num=0;semopbuf.sem_op=-1;semopbuf.sem_flg=SEM_UNDO;semop(semid, &semopbuf, 1); /* P(S1)对信号量集进行wait和signal操作；*/*shmptr = local;semopbuf.sem_num=1;// 正数：释放相应的资源数，将sem_op的值加到信号量的值上semopbuf.sem_op=1;//执行释放的资源semopbuf.sem_flg=SEM_UNDO;semop(semid, &semopbuf, 1); /* V(S2) */printf("Input a number:\n");scanf("%d", &local);}}else /* acts as server */{//建立一个信号量集；//参数nsems表示创建的信号量集中的信号量的个数，该参数只在创建信号量集时有效。
semid=semget(MY_SEMKEY, 2, IPC_CREA T|0666);shmptr=(int *)shmat(shmid, 0, 0);semval=1;//操纵一个信号量集，包括赋初值；SETVAL设置信号量集中的一个单独的信号量的值 semctl(semid, 0, SETV AL, semval); /* set S1=1第二个参数是信号量数目*/semval=0;semctl(semid, 1, SETV AL, semval); /* set S2=0 *///对信号的处理方式或处理过程signal(SIGINT, sigend);由Interrupt Key产生，通常是CTRL+C或者DELETE。
发送给所有ForeGround Group的进程按下CTRL+C产生SIGINTsignal(SIGTERM, sigend);请求中止进程，kill命令缺省发送printf("ACT CONSUMER!!! To end, try Ctrl+C or use kill.\n\n");while(1){semopbuf.sem_num=1;semopbuf.sem_op=-1;semopbuf.sem_flg=SEM_UNDO;semop(semid, &semopbuf, 1); /* P(S2) */printf("Shared memory set to %d\n", *shmptr);semopbuf.sem_num=0;semopbuf.sem_op=1;semopbuf.sem_flg=SEM_UNDO;semop(semid, &semopbuf, 1); /* V(S1) */}}}void sigend(int sig){shmctl(shmid, IPC_RMID, 0);semctl(semid, IPC_RMID, 0);exit(0);}（三）模拟临界资源访问的示例程序本示例的临界资源是一个建立在共享存储区的栈，由服务进程建立并初始化。
初始状态下共享栈满，里面顺序放置一系列正整数（自栈顶向下：1,2,3...），代表空闲块号。
客户进程利用共享栈进行数据块的分配和释放，以得到、归还一个块号代表，并不进行任何后续操作。
程序中getblock过程从共享栈中弹出一个块号（分配），relblock过程把一个已分配块号压入共享栈（释放）。
为简单起见，已分配块号在本地也使用栈结构保存，因而每次释放的是最后分配的块号。
编译后执行，第一个进程实例将作为服务进程，提示：NO OTHER OPERA TION but press Ctrl+C or use kill to end.服务进程完成初始化后将进入睡眠状态，直到用户按Ctrl+C终止执行，或使用kill命令杀死服务进程。
其他进程实例作为客户进程，进入后首先有命令帮助提示，然后显示命令提示符“?> ”，在命令提示下可以使用的命令包括：help 显示可用命令list 列出所有已分配块号get 分配一个新块rel 释放最后分配块号end 退出程序示例程序的代码如下：#include <sys/types.h>#include <unistd.h>#include <signal.h>#include <stdio.h>#include <string.h>#include <sys/ipc.h>#include <sys/shm.h>#define MY_SHMKEY 10071800 // need to change#define MAX_BLOCK 1024#define MAX_CMD 8struct shmbuf {int top;int stack[MAX_BLOCK];} *shmptr, local;char cmdbuf[MAX_CMD];int shmid, semid;void sigend(int);void relblock(void);int getblock(void);void showhelp(void);void showlist(void);void getcmdline(void);int main(void){if((shmid=shmget(MY_SHMKEY, sizeof(struct shmbuf), IPC_CREA T|IPC_EXCL|0666)) < 0){ /* shared memory exists, act as client */shmid=shmget(MY_SHMKEY, sizeof(struct shmbuf), 0666);shmptr=(struct shmbuf *)shmat(shmid, 0, 0);local.top=-1;showhelp();getcmdline();while(strcmp(cmdbuf,"end\n")){if(!strcmp(cmdbuf,"get\n"))getblock();else if(!strcmp(cmdbuf,"rel\n"))relblock();else if(!strcmp(cmdbuf,"list\n"))showlist();else if(!strcmp(cmdbuf,"help\n"))showhelp();getcmdline();}}else /* acts as server */{int i;shmptr=(struct shmbuf *)shmat(shmid, 0, 0);signal(SIGINT, sigend);signal(SIGTERM, sigend);printf("NO OTHER OPERA TION but press Ctrl+C or use kill to end.\n"); shmptr->top=MAX_BLOCK-1;for(i=0; i<MAX_BLOCK; i++)shmptr->stack[i]=MAX_BLOCK-i;sleep(1000000); /* cause sleep forever. */}}void sigend(int sig){shmctl(shmid, IPC_RMID, 0);semctl(semid, IPC_RMID, 0);exit(0);}void relblock(void){if(local.top<0){printf("No block to release!");return;}shmptr->top++;shmptr->stack[shmptr->top]=local.stack[local.top--];}int getblock(void){if(shmptr->top<0){printf("No free block to get!");return;}local.stack[++local.top]=shmptr->stack[shmptr->top];shmptr->top--;}void showhelp(void){printf("\navailable COMMAND:\n\n");printf("help\tlist this help\n");printf("list\tlist all gotten block number\n");printf("get\tget a new block\n");printf("rel\trelease the last gotten block\n");printf("end\texit this program\n");}void showlist(void){int i;printf("List all gotten block number:\n");for(i=0; i<=local.top; i++)printf("%d\t", local.stack[i]);}void getcmdline(void){printf("\n?> ");fgets(cmdbuf, MAX_CMD-1, stdin);}四、实验内容本实验要求内容如下：1、模拟生产者－消费者实现相应的示例程序功能，记录执行结果；改造该程序，取消所有的同步机制，记录执行结果，看是否能观察到程序出现错误情况；进一步改造程序，使错误情况易于观察到；记录执行情况并进行分析。