操作系统进程同步与互斥实验报告
进程(线程)同步和互斥实验报告
进程(线程)同步和互斥实验报告操作系统实验报告课程名称操作系统实验名称进程（线程）的同步与互斥成绩学生姓名作业君专业软件工程班级、学号同组者姓名无实验日期2021一、实验题目: : 进程（线程）的同步与互斥二、实验目的：自行编制模拟程序，通过形象化的状态显示，加深理解进程的概念、进程之间的状态转换及其所带来的 PCB 内容、组织的变化，理解进程与其 PCB 间的一一对应关系。
1．掌握基本的同步与互斥算法，理解生产者消费者模型。
2．学习使用 Windows 中基本的同步对象，掌握相关 API 的使用方法。
3．了解 Windows 中多线程的并发执行机制，实现进程的同步与互斥三、实验内容与要求：1．实验内容以生产者/消费者模型为依据，在 Windows 环境下创建一个控制台进程，在该进程中创建 n 个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。
2．实验要求学习并理解生产者/消费者模型及其同步/互斥规则；学习了解 Windows 同步对象及其特性；熟悉实验环境，掌握相关 API 的使用方法；设计程序，实现生产者/消费者进程(线程)的同步与互斥；四、算法描述（含数据结构定义）或流程图#include <Windows.h> #include <iostream> #include<stdio.h> #include <math.h> #include <stdlib.h> #include <time.h> using namespace std;#define MA__THREAD_NUM 64//最大线程数 #define INTE_PER_SEC 1000//延迟时间的毫秒值 const int SIZE_OF_BUFFER = 10;//缓冲区长度 int ProductID = 0;//产品号 int ConsumeID = 0;//将被消耗的产品号 int in = 0;//产品进缓冲区时的缓冲区下标 int out = 0;//产品出缓冲区时的缓冲区下标 bool running = true;//判断程序能否继续执行的逻辑值 intg_buffer[SIZE_OF_BUFFER];//缓冲区是个循环队列 HANDLE g_hMute_;//公有信号量，用于线程间的互斥 HANDLEg_hFullSemaphore;//生产者的私有信号量，当缓冲区满时迫使生产者等待HANDLE g_hEmptySemaphore;//消费者的私有信号量，当缓冲区空时迫使消费者等待//定义一个结构体用于存储线程的信息 struct ThreadInfo {int serial;//线程号char entity;//线程类别(生产者或消费者)double delay;//等待时间double persist; //操作时间 };//生产者 void Producer(void_p) {//定义变量用于存储当前线程的信息DWORD m_delay;DWORD m_persist;int m_serial;//从参数中获得信息m_serial = ((ThreadInfo_)(p))->serial;m_delay = (DWORD)(((ThreadInfo_)(p))->delay _INTE_PER_SEC);m_persist = (DWORD)(((ThreadInfo_)(p))->persist _INTE_PER_SEC);while (running){//P 操作cout << “生产者线程” << m_serial << “ 请求生产.” << endl;WaitForSingleObject(g_hEmptySemaphore, INFINITE);cout << “生产者线程” << m_serial << “ 请求独占缓冲区.” << endl;WaitForSingleObject(g_hMute_, INFINITE);Sleep(m_delay);//延迟等待//生产一个产品cout << “生产者线程”<< m_serial << “ 生产” << ++ProductID << “ 号产品成功.” << endl;cout << “生产者线程” << m_serial << “ 请求将产品” << ProductID << “ 投入缓冲区.” << endl;//把新生产的产品放入缓冲区g_buffer[in] = ProductID;in = (in +1)%SIZE_OF_BUFFER;Sleep(m_persist);//操作等待cout << “生产者线程” << m_serial << “ 将产品” << ProductID << “ 投入缓冲区中成功.” << endl;//输出缓冲区当前的状态cout << “____________________________” << endl<< “\n 当前缓冲区情况如图(■代表已有产品，□代表没有产品):” << endl;for (int i = 0;i < SIZE_OF_BUFFER;++i){if (g_buffer[i] != 0)cout << “■”;elsecout << “□”;}cout << “\n\n____________________________\n” << endl;//V 操作ReleaseMute_(g_hMute_);ReleaseSemaphore(g_hFullSemaphore, 1, NULL);} }//消费者 void Consumer(void_p) {DWORD m_delay;DWORD m_persist;int m_serial;//从参数中获得信息m_serial = ((ThreadInfo_)(p))->serial;m_delay = (DWORD)(((ThreadInfo_)(p))->delay _INTE_PER_SEC);m_persist = (DWORD)(((ThreadInfo_)(p))->persist _INTE_PER_SEC);while (running){//P 操作cout << “消费者线程” << m_serial << “ 请求消费.” << endl;WaitForSingleObject(g_hFullSemaphore, INFINITE);cout << “消费者线程” << m_serial << “ 请求独占缓冲区.” << endl;WaitForSingleObject(g_hMute_,INFINITE);Sleep(m_delay); //延迟等待//从缓冲区中取出一个产品cout << “消费者线程” << m_serial << “ 请求取出一个产品.” << endl;ConsumeID = g_buffer[out];g_buffer[out] = 0;out = (out + 1) % SIZE_OF_BUFFER;cout << “消费者线程” << m_serial << “ 取出产品” << ConsumeID << “ 成功.” << endl;//消耗一个产品cout << “消费者线程” << m_serial << “ 开始消费消费产品” << ConsumeID << “.” << endl;Sleep(m_persist);cout << “消费者线程” << m_serial << “ 消费产品” << ConsumeID << “ 成功.” << endl;//输出缓冲区当前的状态cout << “____________________________” << endl<< “\n 当前缓冲区情况如图:” << endl;for (int i = 0;i < SIZE_OF_BUFFER;++i){if (g_buffer[i] != 0)cout << “■”;elsecout << “□”;}cout << “\n\n____________________________\n” << endl;//V 操作ReleaseMute_(g_hMute_);ReleaseSemaphore(g_hEmptySemaphore, 1, NULL);} }void prod_cons {//创建互斥信号量g_hMute_ = CreateMute_(NULL, FALSE, NULL);//创建同步信号量g_hEmptySemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER, SIZE_OF_BUFFER, NULL);g_hFullSemaphore = CreateSemaphore(NULL, 0,SIZE_OF_BUFFER, NULL);srand((unsigned)time(NULL));//以时间函数为种子const unsigned short THREADS_COUNT = rand % 5 + 5; //总的线程数(随机生成)//线程对象的数组HANDLE hThreads[MA__THREAD_NUM];ThreadInfo thread_info[MA__THREAD_NUM];DWORD thread_ID; //线程 IDint num = 0;//临时变量，用于循环语句cout << “系统开始模拟，并自动生成模拟数据...” << endl;system(“pause”); //暂停确认开始执行cout << “线程总数：” << THREADS_COUNT << endl;//循环随机生成各个线程的信息while (num != THREADS_COUNT){thread_info[num].serial = num + 1;if (rand % 2 == 1)thread_info[num].entity = "P";elsethread_info[num].entity = "C";thread_info[num].delay = rand % 5 + 1;thread_info[num].persist = rand % 6 + 2;num++;}cout << “\n 系统生成数据结束，模拟数据如下:” << endl<< “线程号线程类别延迟时间操作时间” << endl;for (int _ = 0;_ < THREADS_COUNT;_++)cout << “” << thread_info[_].serial << “\t”<< “” << thread_info[_].entity << “\t”<< “” << thread_info[_].delay << “\t\t”<< “” << thread_info[_].persist << endl;cout << “\n\n==================生产者-消费者开始==================\n” << endl;//创建线程for (int i = 0;i < THREADS_COUNT;i++){//创建生产者线程if (thread_info[i].entity == "P")hThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)(Producer), ;thread_info[i], 0, ;thread_ID);//创建消费者线程elsehThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)(Consumer), ;thread_info[i], 0, ;thread_ID);}while (running){if (getchar){//按回车后终止程序运行running = false;}}cout << “系统模拟结束...” << endl; } int main {cout << “\n==================生产者-消费者模拟==================\n” << endl;prod_cons; }五、实验过程1、记录生产者和消费者的同步执行过程。
进程的同步与互斥实验报告
进程的同步与互斥实验报告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.实验总结通过本次实验，我深刻理解了进程（线程）的同步与互斥，并通过实际操作加深了对这些概念的理解。
同步和互斥是操作系统中非常重要的概念，对于应对资源竞争和提高程序性能具有重要意义。
在实际开发中，我们应该合理使用同步和互斥机制，以确保程序的正确性和并发执行的效率。
哈工大威海计算机操作系统原理实验报告1
计算机操作系统原理实验报告专业： 110420x学号： 1104202xx姓名： xxx哈尔滨工业大学（威海）实验一进程同步和互斥一、实验目的1．掌握临界资源、临界区概念及并发进程互斥、同步访问原理。
2．学会使用高级语言进行多线程编程的方法。
3．掌握利用VC++或Java语言线程库实现线程的互斥、条件竞争，并编码实现P、V操作，利用P、V操作实现两个并发线程对有界临界区的同步访问。
4．通过该实验，学生可在源代码级完成进程同步互斥方案的分析、功能设计、编程实现，控制进程间的同步、互斥关系。
二、实验要求1．知识基础：学生应在完成进程和线程及调度等章节的学习后进行。
2．开发环境与工具：硬件平台——个人计算机。
软件平台-Windows操作系统，VC++语言或Java语言开发环境。
3．运用高级语言VC++或Java语言线程库及多线程编程技术进行设计实现。
三、实验内容1．实现临界资源、临界区、进程或线程的定义与创建。
2．利用两个并发运行的进程，实现互斥算法和有界缓冲区同步算法。
四、程序流程图1.2.生产者消费者问题生产者：消费者：五、实验结果1.互斥问题2.生产者消费者问题六、结果分析有上述程序运行结果可知，此次试验已经基本达到了实验要求，在互斥问题中，由于采用了“模拟一个竞争条件——全局变量”来建立互斥，所以不会明显的条件来判断2个线程是否正确、独立的运行，所以，在运行时间上加以限制，让2个线程在有序运行时只能持续15秒。
在生产者消费者问题中，生产者与消费者的最大上限为10，并且生产者只能生产“同一种物品”，而消费者也只能购买“同一种物品”。
操作系统实验进程同步与互斥
操作系统实验进程同步与互斥操作系统实验进程同步与互斥实验目的1.掌握进程同步和互斥原理，理解生产者-消费者模型；2.学习Windows2000/xp中的多线程并发执行机制；3.学习使用Windows SDK解决读者－写者问题。
试验内容1依据生产者－消费者模型，在Windows 2000/xp环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥，分析、熟悉生产者消费者问题仿真的原理和实现技术。
（见附件2）试验内容2参考实验内容1和附件2伪码，编程解决读者－写者问题的程序。
（具体要求和读写者问题原始伪码内容见附件1）相关知识Windows 2000/XP的线程控制CreateThread完成线程创建，在调用进程的地址空间上创建一个线程，以执行指定的函数；它的返回值为所创建线程的句柄。
ExitThread用于结束当前线程。
SuspendThread可挂起指定的线程。
ResumeThread可激活指定线程，它的对应操作是递减指定线程的挂起计数，当挂起计数减为0时，线程恢复执行。
Windows 2000/XP的进程互斥和同步在Windows 2000/XP中提供了临界区、互斥对象、信号量对象同步对象和相应的系统调用，用于进程和线程同步。
临界区对象(Critical Section)只能用于在同一进程内使用的临界区，同一进程内各线程对它的访问是互斥进行的。
相关API包括：InitializeCriticalSection对临界区对象进行初始化；EnterCriticalSection等待占用临界区的使用权，得到使用权时返回；TryEnterCriticalSection非等待方式申请临界区的使用权；申请失败时，返回0；LeaveCriticalSection释放临界区的使用权；DeleteCriticalSection释放与临界区对象相关的所有系统资源。
互斥对象(Mutex)互斥对象相当于互斥信号量，在一个时刻只能被一个线程使用。
南昌大学操作系统实验报告二编程模拟进程间的同步和互斥
#dｅfineSＥM_ID 25０//信号量
#ｄefiｎe "/tmp/seｍ_aaａ＂
＃dｅｆinｅDELAY 4000000
vｏidupdate_ sem_set_iｄ，ｃhａr *,int number){
ﻩsｔｒuｃtｓembｕfsem_op;
#ｉnclude<stｄｉo.h＞//标准输入输出头文件
＃iｎcｌuｄe<stdlib.ｈ>//staｎｄarｄlibrarｙ标准库头文件
＃inｃlude<uｎistd.ｈ>//ＰOSIX标准定义的uniｘ类系统定义符号常量的头文件,包含了许多UNIX系统服务的函数原型，例如rｅad函数、ｗｒite函数和getpid函数。
｝
（二)生产者消费者问题
生产者消费者问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
for（ｉ=0;i<3;i++){
updatｅ_,);
for(j＝0;j<4000００0;j++)；
}
}
ｉnt main（inｔaｒｇc,chａr **argv）
{
ｉnｔｓeｍ_sｅt_iｄ; //信号量集的IＤ
ﻩunioｎseｍun sem_val; //信号量的数值，用于ｓeｍctl(）
ﻩinｔchild_pid;
FILE*建立一个文件指针
实验四同步与互斥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，根据提示要求进行填写生产者和消费速度，观察消费者和生产者进程。
2.实验：进程的同步和互斥
《操作系统实验》
实验一：进程的同步和互斥
黄伯虎
实验内容
生产者消费者问题实现
描述：
假设存在两类进程：生产者，消费者。
它们共享n个缓冲区。
生产者行为：生产产品(每次生产1个)，并将产品放入空缓冲区，循环往复，永不停息；
消费者行为：将产品从缓冲区中取出，进行消费(每次消费1个)，循环往复，永不停息。
规定：缓冲区满，生产者不能放产品；缓冲区空，消费者不能取产品
要求
基本要求
实现当n=1，生产者、消费者各为1个时，同步和互斥过程
扩展要求(可选)
实现当n=c(整常数)，生产者、消费者有多个(>1)时，同步和互斥过程平台和工具(原则不限，推荐如下)
Win32平台
VC++6.0
结果显示
字符界面，能说明问题即可
最终成果形式
提交实验报告1份(格式参见附件A)
报告提交时限：下一次实验开始前
提交形式：email
提交的邮件主题请按照如下格式书写：“学号+姓名+实验名称.rar/.doc”
如“030811300+张三+进程同步与互斥.rar/.doc”提交地址：
13班：xdos1@
14,31班：xdos2@。
操作系统实验报告——进程同步与互斥
操作系统实验报告——进程同步与互斥一、实验内容本实验主要内容是通过编写程序来实现进程的同步与互斥。
具体来说，是通过使用信号量来实现不同进程之间的同步和互斥。
我们将编写两个进程，一个进程负责打印奇数，另一个进程负责打印偶数，两个进程交替打印，要求打印的数字从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，表示可以打印偶数。
实验四同步与互斥Linux实验报告材料
实验四同步与互斥Linux实验报告材料一、实验目的本次实验旨在深入理解和掌握Linux 操作系统中的同步与互斥机制。
通过实际的编程和操作，观察不同进程或线程之间的协作与竞争情况，从而更好地理解操作系统如何有效地管理资源和避免冲突。
二、实验环境本次实验使用的是 Linux 操作系统，具体版本为_____。
开发工具为_____，编译器为_____。
三、实验内容（一）信号量的使用信号量是一种用于实现进程或线程同步与互斥的重要机制。
在实验中，我们创建了一个简单的信号量示例，通过对信号量的操作来控制对共享资源的访问。
首先，定义了一个信号量，并初始化其值。
然后，创建了多个进程或线程，它们在访问共享资源之前需要先获取信号量，访问完成后释放信号量。
通过这种方式，确保了在同一时刻只有一个进程或线程能够访问共享资源，避免了数据的不一致性和冲突。
（二）互斥锁的应用互斥锁是另一种常见的同步机制，用于保证在任何时刻只有一个线程能够访问被保护的代码段或资源。
在实验中，我们创建了一个互斥锁，并在需要保护的关键代码段前加锁，执行完相关操作后解锁。
这样，即使多个线程同时尝试进入关键代码段，也只有一个线程能够成功获取锁，其他线程将被阻塞，直到持有锁的线程释放锁。
（三）条件变量的实践条件变量通常与互斥锁一起使用，用于实现线程之间的等待和通知机制。
我们创建了一个条件变量，并结合互斥锁实现了线程之间的通信。
当某个条件满足时，通过通知条件变量来唤醒等待的线程，使其继续执行后续操作。
四、实验步骤（一）准备工作1、安装所需的开发工具和编译器，并确保环境变量配置正确。
2、熟悉相关的 API 函数和库函数的使用方法。
（二）编写代码1、根据实验要求，分别编写使用信号量、互斥锁和条件变量的代码示例。
2、确保代码的逻辑清晰，注释完整，便于理解和调试。
（三）编译和运行1、使用编译器对编写的代码进行编译，检查是否存在语法错误。
2、运行编译后的程序，观察输出结果，分析程序的执行流程和同步效果。
操作系统实验报告步骤
一、实验目的1. 理解进程同步与互斥的基本概念。
2. 掌握进程同步与互斥的常用方法。
3. 通过实验加深对操作系统进程管理的理解。
二、实验环境1. 操作系统：Windows 102. 开发工具：Visual Studio 20193. 编程语言：C++三、实验内容1. 实现进程同步与互斥的基本方法。
2. 利用互斥锁实现进程同步。
3. 利用信号量实现进程同步。
四、实验步骤1. 创建项目（1）打开Visual Studio 2019，创建一个名为“进程同步与互斥实验”的控制台项目。
（2）在项目文件夹中创建一个名为“main.cpp”的源文件。
2. 实现进程同步与互斥的基本方法（1）定义两个全局变量，分别表示互斥锁和信号量。
```cpp#include <iostream>#include <thread>#include <mutex>#include <semaphore.h>std::mutex mtx;sem_t semaphore;void process1() {// 获取互斥锁mtx.lock();std::cout << "进程1正在执行" << std::endl; // 释放互斥锁mtx.unlock();}void process2() {// 等待信号量sem_wait(&semaphore);std::cout << "进程2正在执行" << std::endl; // 释放信号量sem_post(&semaphore);}```（2）在主函数中创建线程，并调用相应的函数。
```cppint main() {// 初始化互斥锁和信号量mtx.lock();sem_init(&semaphore, 0, 1);// 创建线程std::thread t1(process1);std::thread t2(process2);// 等待线程结束t1.join();t2.join();// 销毁信号量sem_destroy(&semaphore);return 0;}```3. 运行程序（1）编译并运行程序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
//b 正在访问临界资源!
printf("a=0,c=0\n");
//a,c 不能进入自己的临界区，需等待 b 释放临界资源！
printf(“临界资源正在被进程 b 访问,进程 a,c 必须等待.\n”);
}
5.编译链接所编写的程序,在编译正确的情况下执行程序.
6.记录程序执行的结果(如下图所示).
注意:初始状态为:临界资源处于空闲状
20 10 年 12 月 16 日
【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见）
1.进程 a,b,c 分别访问临界资源时程序执行的结果如下.
(a)
(b)
(c)
2.该程序初始化 N 为临界资源，根据输入 a,b,c,的值是否等于 N 来判断进程分别是否进入自己的临界区。当 a=N 表明进程 a 正在访问临界资源。此时程序执行的输出为：a=1,b=c=0 表示进程 b,c 不能进入自己的临界区。 3.该程序能较好地体现程序并发执行时的一种制约关系-互斥，但不能较好的反映进程的同步关系，所以该算 法有待改进，用以同时实现进程的同步和互斥。 4.该程序的输入变量具有限制,若输入除 0 和 1 的数据,则将视为 0 处理.改进的方法为修改 if 语句中的条件为:1， 即只要输入为非零，则有效。即逻辑表达式的值为真。(在逻辑数学里非零则表示为真!) 5.为了能较好的实现进程的同步，可以另外设一个标志量，标志临界资源是否正被访问，当 a,b,c 中的其一访 问临界资源时，其余 2 个将进行自我阻塞，当该进程执行完毕后，须将被阻塞的进程唤醒。
【实验内容】 在 Windows XP 或 Windows 2000 等操作系统环境下，使用 VC、VB、Delphi、java 或 C 等编程语言，
采用进程（线程）同步和互斥的技术编写程序实现生产者-消费者问题（或哲学家进餐问题、读者-写者 问题）或自己设计一个简单程序模拟进程（线程）同步和互斥在实际中的应用。
{
printf("a=%d\n",a);
//a 正在访问临界资源！
printf("b=0,c=0\n");
//b,c 不能进入自己的临界区，需等待 a 释放临界资源!
printf(“临界资源正在被进程 a 访问,进程 b,c 必须等待.\n”);
}
else if(b==N)
{
printf("b=%d\n",b);
【备注】
指导教师签名： 20 年 月 日
学生实验报告
姓名：
年级专业班级
学号
成绩
课程名称
操作系统
实验名称
实验 1 进程的同步与互斥
实验类型
验证 设计 综合 创新
【实验目的、要求】 1.通过编写程序实现进程同步和互斥，使学生掌握有关进程（线程）同步与互斥的原理以及解决进
程（线程）同步和互斥的算法，从而进一步巩固进程（线程）同步和互斥等有关的内容。 2.了解 Windows2000/XP 中多线程的并发执行机制、线程间的同步和互斥。3.掌握多道程序设计的基本理论、方 法和技术，培养学生多道程序设计的能力。
N
输出 0,0,1
输出 0,0,0
பைடு நூலகம்
3.启动计算机，运行 C 编程软件. 4.程序关键代码.
结束
#define N 1 printf("请输入三个进程:\n"); loop:scanf("%d %d %d",&a,&b,&c); if(a==N)
//N 定义为临界资源! //初始状态为：临界资源处于空闲状态! //输入的进程名为:a,b,c!进程名输入的先后代表进程的访问顺序！ //判断进程 a 是否占据临界资源!若 a==N,表明 a 访问临界资源！
【实验环境】（含主要设计设备、器材、软件等）
计算机 C 语言编程软件
【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）
1.认真分析生产者-消费者经典进程同步互斥问题，对算法构思.
2.算法的流程图表示如下：
开始
Y
N
a=1?
输出 1,0,0
Y
N
b=1?
输出 0,1,0
Y c=1?