实验2进程同步与死锁

操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。

本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。

二、实验环境本次实验使用的操作系统为 Windows 10 专业版，开发工具为Visual Studio 2019，编程语言为 C 和 C+＋。

实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。

三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新的进程，并在完成任务后终止进程。

在实验中，我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。

通过观察进程的创建和终止过程，深入理解了进程的生命周期和状态转换。

2、进程同步与互斥为了实现进程之间的同步与互斥，我们使用了信号量、互斥量等同步对象。

通过编写多线程程序，模拟了多个进程对共享资源的访问，实现了对共享资源的互斥访问和同步操作。

在实验中，我们深刻体会到了进程同步与互斥的重要性，以及不正确的同步操作可能导致的死锁等问题。

（二）内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。

通过实验，了解了内存分配的不同方式（如堆分配、栈分配等）以及内存释放的时机和方法，掌握了内存管理的基本原理和操作技巧。

2、内存分页与分段通过编程模拟内存的分页和分段管理机制，了解了内存分页和分段的基本原理和实现方法。

在实验中，我们实现了简单的内存分页和分段算法，对内存的地址转换和页面置换等过程有了更深入的理解。

（三）文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。

进程间同步的几种方法进程间同步是指两个或多个进程之间进行协调，以确保它们能够正确地执行。

这是多任务操作系统中的重要问题，因为进程之间共享资源，包括内存、文件和网络连接等。

进程同步的关键是确保一组进程在处理共享资源时，能够避免发生竞态条件（Race Condition）和死锁（Deadlock）。

竞态条件指多个进程同时访问共享资源，导致不正确的结果。

死锁指多个进程互相等待，导致它们都无法继续执行。

1. 互斥锁互斥锁是最常见的同步方法之一，它被用来保护共享资源，确保同一时刻只有一个进程可以访问它。

当一个进程获取了锁，其他进程必须等待，直到锁被释放。

在 POSIX 系统中，互斥锁可以通过 pthread_mutex_t 数据类型实现。

我们可以使用pthread_mutex_init() 函数初始化锁，使用 pthread_mutex_lock() 函数获取锁，使用pthread_mutex_unlock() 函数释放锁。

下面是一个例子，展示了如何使用互斥锁同步两个进程对共享变量的访问：```c#include <pthread.h>#include <stdio.h>int count = 0;pthread_mutex_t lock;void *increment(void *arg) {for (int i = 0; i < 1000000; i++) {pthread_mutex_lock(&lock); // 获取锁count++;pthread_mutex_unlock(&lock); // 释放锁}return NULL;}在上面的例子中，我们创建了两个线程，它们分别对共享变量 count 进行了一百万次的递增操作。

我们使用了互斥锁来保护 count 变量，确保同一时刻只有一个线程可以访问它。

2. 信号量3. 条件变量条件变量可以被用来支持更高级的同步机制，如互斥锁和信号量。

一、实验目的1. 理解进程同步的概念和原理；2. 掌握进程同步的基本方法和机制；3. 学会使用信号量实现进程同步；4. 通过实验验证进程同步机制的有效性。

二、实验原理1. 进程同步：在多道程序设计中，进程的执行是并发的，但某些情况下需要保证多个进程按照一定的顺序执行，以避免出现数据不一致、死锁等问题。

进程同步是指通过某种机制，协调多个进程的执行顺序，保证它们能够正确、有效地共享资源。

2. 信号量：信号量是一种特殊的变量，用于实现进程同步。

信号量具有两个原子操作：P操作（wait）和V操作（signal）。

P操作用于申请资源，V操作用于释放资源。

3. 互斥锁：互斥锁是一种常见的进程同步机制，用于保证临界资源的互斥访问。

当一个进程进入临界区时，它会尝试获取互斥锁，如果锁已被其他进程获取，则该进程进入等待状态；当进程退出临界区时，它会释放互斥锁。

三、实验内容1. 实验环境：Linux操作系统，C语言编程环境。

2. 实验工具：gcc编译器、gdb调试器。

3. 实验步骤：（1）创建一个互斥锁，用于保护临界资源。

（2）编写两个进程，分别模拟对临界资源的访问。

（3）在进程访问临界资源前，使用P操作尝试获取互斥锁。

（4）在进程访问临界资源后，使用V操作释放互斥锁。

（5）编译并运行程序，观察进程执行情况。

四、实验结果与分析1. 实验结果：（1）在互斥锁的保护下，两个进程能够按照预期顺序访问临界资源。

（2）当其中一个进程正在访问临界资源时，另一个进程会进入等待状态。

（3）当进程访问临界资源完成后，它会释放互斥锁，允许其他进程访问。

2. 实验分析：（1）互斥锁能够有效地保护临界资源，避免数据不一致问题。

（2）信号量P操作和V操作保证了进程的同步，避免了死锁现象。

（3）通过实验验证了进程同步机制的有效性。

五、实验总结本次实验通过使用信号量和互斥锁，实现了进程同步。

实验结果表明，信号量和互斥锁能够有效地保证进程按照预期顺序执行，避免数据不一致和死锁等问题。

进程死锁实验报告了解进程死锁的发生原因，学习死锁的检测与解除算法，掌握避免死锁的方法。

实验原理：1. 进程死锁的定义：当两个或多个进程由于竞争系统资源而陷入无限等待的状态时，称为进程死锁。

进程死锁是指在多道程序环境下，若干个进程因为互相竞争系统资源（如打印机、磁带机等）而陷入无限等待的状态。

2. 进程死锁的必要条件：a. 互斥条件：每个资源要么已经分配给了一个进程，要么就是可用的；b. 占有且等待：已经得到了一部分资源的进程可以再请求新的资源；c. 不可抢占：已经分配给一个进程的资源不能强制性地被抢占，只能由占有它的进程显示地释放；d. 循环等待：若干进程之间形成一种头尾相连的循环等待资源的关系。

3. 进程死锁的检测与解除算法：a. 死锁的检测：常用的算法有资源分配图算法和银行家算法。

资源分配图算法将整个系统抽象成一个有向图，利用图的环路检测算法来判断是否有环路存在，若有，则表示系统发生死锁；银行家算法用于系统对进程请求资源的安全性进行检查，防止发生死锁。

b. 死锁的解除：常用的算法有剥夺算法和撤销算法。

剥夺算法将部分资源剥夺掉，以满足其他进程的需求，从而解除死锁；撤销算法将某些进程回滚到某个安全状态，丢弃它们已经分配到的资源，从而解除死锁。

实验过程：1. 实验环境：使用Java编程语言进行模拟实验。

2. 实验步骤：a. 创建3个进程和4个资源，并初始化资源的可用数量。

b. 在每个进程中，模拟进程对资源的请求和释放动作。

c. 模拟死锁的情景，使得进程陷入死锁状态。

d. 根据资源分配图算法进行死锁检测。

e. 根据剥夺算法或撤销算法进行死锁的解除。

f. 重复进行b~e步骤，直到所有进程执行完毕，死锁状态解除。

实验结果：经过多次运行实验，可以观察到进程死锁的发生情况以及死锁的解除过程。

根据资源分配图算法，可以准确地检测出死锁的发生，并根据剥夺算法或撤销算法进行死锁的解除。

通过实验，验证了进程死锁的必要条件，并理解了死锁的检测与解除算法。

进程同步问题总结进程同步问题主要涉及到并发进程之间的协作和同步，以实现多进程的协同工作。

以下是进程同步问题的主要总结：1.进程同步的概念：进程同步是一种协调多个进程运行顺序的机制。

它使得进程能够在正确的时间点上，按照一定的顺序进行交互和协作。

2.进程同步的必要性：在多进程环境中，如果不同进程的执行顺序不协调，就可能导致数据不一致、竞争条件等问题。

进程同步可以解决这些问题，保证多进程环境下的正确性和可靠性。

3.进程同步的主要方法：a) 信号量（Semaphore）：信号量是一种计数器，用于控制多个进程对共享资源的访问。

信号量的值表示当前可用的共享资源数量。

通过设置信号量的初始值和使用P、V操作（或称为wait和post操作），可以实现进程的同步和互斥。

b) 互斥锁（Mutex）：互斥锁是一种同步机制，用于防止多个进程同时访问共享资源。

当一个进程获得锁时，其他进程将被阻塞，直到锁被释放。

c) 条件变量（Condition）：条件变量用于实现进程间的条件等待。

当一个进程需要等待某个条件成立时，它会使用条件变量的wait操作阻塞自己。

当另一个进程改变了条件并通知等待的进程时，被阻塞的进程将被唤醒。

d) 事件（Event）：事件是一种同步机制，用于通知其他进程某个事件已经发生。

事件通常分为信号事件和广播事件。

信号事件只通知一个进程，而广播事件通知所有等待该事件的进程。

4.死锁问题：在进程同步过程中，如果多个进程互相等待对方释放资源，就会产生死锁问题。

避免死锁的方法包括：避免循环等待、按顺序申请资源、设置超时时间等。

5.进程同步的应用：进程同步广泛应用于操作系统、并发程序设计、网络通信等领域。

例如，在操作系统中，进程同步可以用于实现进程调度、任务管理、文件系统等重要功能。

在并发程序设计中，进程同步可以用于实现多线程的协同工作、数据访问控制等功能。

在网络通信中，进程同步可以用于实现数据传输、远程过程调用等功能。

一、实验目的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不同，说明子进程是独立于父进程的实体。

0711操作系统进程调度和进程同步实验要求实验内容：用线程模拟进程，实现进程调度和进程同步。

在任意操作系统中，用c、c++或者java 编写程序。

并且完成相应的实验报告。

实验要求：实验一：进程调度⑴ 主线程，创建子线程，保存子线程的虚拟PCB（参见恐龙书P74）、要求运行多少时间（可随机产生）、已经等待多少时间（初始化为0），优先级（可随机产生）等信息，并负责子线程的调度。

调度的基本时间单位为1 S。

⑵ 创建20个线程（可以只用一个线程函数，传递不同的参数即上述数据结构）分别实现FCFS调度、SJF调度、RR调度、优先级调度和多级队列调度，并且计算每个调度的平均等待时间。

其中，多级队列调度要求设计4个调度队列，每个队列5个线程，队列内部分别采用FCFS、SJF、RR和优先级调度。

时间片的长度可以随机生成为n S。

⑶ 对于每个子线程，在其运行期间，输出其占用的时间标号（例如，第3个线程占用了第10秒的CPU时间，输出为：“Thread 3： 10”，格式可自行设计）。

实验二：进程同步⑴ 模拟哲学家就餐问题：设置5个子线程模拟5个哲学家，设置5个互斥区为筷子。

⑵ 输出问题解决方法：在每个哲学家线程中输出其获得的筷子标号与时间（可以读取系统时间，或者自行设置时间标准），例如：哲学家2在第n秒获得筷子1，在第m秒获得筷子2。

实验报告要求：写明实验目的、实验设计步骤、实验结果、总结。

附录：windows线程基本操作以windows线程函数为例介绍线程基本操作,以下函数都必须包含windows.h头文。

如果想更深入地了解线程，请参见《c++编程艺术》等相关书籍。

线程创建函数：HANDLE CreateThread (LPSECURITY_ATTRIBUTES secAttr,SIZE_T stackSize,LPTHREAD_START_ROUTINE threadFunc,LPVOID param,DWORD flags,LPDWORD threadID);在此，secAttr是一个用来描述线程的安全属性的指针。

操作系统实验报告哲学家就餐一、实验目的：通过模拟哲学家就餐问题，了解并掌握操作系统中的进程同步机制，以及解决进程间资源竞争所引发的死锁问题。

二、实验介绍：哲学家就餐问题是由荷兰计算机科学家伊克斯特拉(Dijkstra)于1965年首次提出的。

其问题描述如下：五位哲学家坐在一张圆桌子周围，每个哲学家面前有一碗饭和一根筷子。

哲学家的生活方式是交替地进行思考和进食。

当一个哲学家思考时，他不需要使用他的两个筷子；当一个哲学家想吃饭时，他需要同时获取他的左右两个筷子，并在获取到筷子后才能开始进食。

问题的关键是如何解决哲学家间的筷子竞争问题，以及避免死锁的发生。

三、实验设计：1.并发思路每个哲学家作为一个进程，在进行思考和进食这两个操作之前，需要获取他的两个筷子。

接下来考虑进程同步的两个关键点：-互斥：保证每个筷子同时只能被一个哲学家使用，避免资源竞争问题。

-死锁避免：通过限制只允许至多四位哲学家同时持有筷子，从而避免死锁发生。

2.进程同步机制- 互斥：使用Semaphore实现互斥，每个筷子都是一个Semaphore，初始值为1-死锁避免：引入一个全局计数器，记录当前持有筷子的哲学家数量，每次哲学家想要获取筷子时，先检查该计数器，仅当计数器小于4时才会获取筷子。

四、实验步骤：1.创建5个哲学家进程和5个筷子线程。

2.每个哲学家的线程循环执行思考和进食操作。

3.在进食之前，哲学家需要获取两个筷子，获取筷子的顺序按照哲学家编号进行，每个哲学家先获取自己的左边筷子，再获取自己的右边筷子。

4.进行进食操作后，哲学家释放两个筷子。

5.循环执行步骤3和步骤4，直到实验结束。

五、实验结果：通过观察实验结果，可以看到哲学家的思考和进食操作交替进行，并且避免了死锁的发生。

六、实验总结：通过本次实验，我了解了操作系统中的进程同步机制，并学会了如何解决资源竞争和死锁问题。

在本实验中，我使用了Semaphore和全局计数器实现了互斥和死锁避免，从而成功模拟了哲学家就餐问题。

西安邮电大学（计算机学院）课内实验报告实验名称：进程间通信/信号量/死锁专业名称：班级：学生姓名：学号（8位）：指导教师：实验日期：一.实验目的及实验环境（一）实验环境CPU：Intel Core i3 2.30 GHz内存：2.0 GB操作系统：LINUX（二）实验目的实验1 掌握linux基本命令和开发环境1. 掌握编译环境gcc及跟踪调试工具gdb2. 掌握常用的linux shell命令3. 掌握编辑环境vim实验2 进程通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握在posix规范中fork和kill系统调用的功能和使用。

实验3 线程通过观察、分析实验现象，深入理解线程及线程在调度执行和内存空间等方面的特点，并掌握线程与进程的区别。

掌握posix规范中pthread_creat()函数的功能和使用方法。

实验4 互斥通过观察、分析实验现象，深入理解互斥锁的原理及特点掌握在posix 规范中的互斥函数的功能及使用方法。

二.实验内容（一）实验21. 填写代码：1)建立child_proc_number个子进程，要执行：proc_number = i；do_something(); 父进程把子进程的id保存到pid[i] 。

2)向pid[ch-'0']发信号SIGTERM，杀死该子进程。

3)杀死本组的所有进程。

2. 实验过程先猜想一下这个程序的运行结果。

假如运行“./process 20”，输出会是什么样？然后按照注释里的要求把代码补充完整，运行程序。

可以多运行一会儿，并在此期间启动、关闭一些其它进程，看process的输出结果有什么特点，记录下这个结果。

开另一个终端窗口，运行“ps aux|grep process”命令，看看process究竟启动了多少个进程。

回到程序执行窗口，按“数字键+回车”尝试杀掉一两个进程，再到另一个窗口看进程状况。

操作系统实验二报告一．实验名称：死锁的检测与解除二．实验目的：观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生。

三．实验内容：死锁的检测算法：1．找出不再申请资源的进程，将它们所占的资源与系统中还剩余的资源加在一起作为“可分配的资源”，同时对这些进程置标志；2．检测所有无标志的进程，找出一个所需资源量不超过“可分配的资源”量的进程，将其所占用的资源添加到“可分配的资源”中，同时为该进程置标志；重复2）直到所有进程均有标志或无标志的进程的所需资源量均超过“可分配的资源”量；3．若进程均有标志，说明系统当前不存在死锁；若存在无标志的进程，则表示系统当前已有死锁形成，这些无标志的进程就是一组处于死锁状态的进程。

死锁的解除：当死锁检测程序检测到有死锁存在时，一般采用两种方式来解除死锁：1．终止进程：终止一个或多个涉及死锁的进程的执行，收回它们所占的资源再分配。

2．抢夺资源：从涉及死锁的一个或几个进程中抢夺资源，把夺来的资源再分配给卷入死锁的其他进程，直到死锁解除。

四．实验代码：#include <iostream>using namespace std;#define mp 50 //最大进程数#define mr 100 /最大资源数int keyong[mr]; //可用资源数组int MAX[mp][mr]; //最大需求矩阵int fenpei[mp][mr]; //分配矩阵int need[mp][mr]; //剩余需求矩阵bool FINISH[mp]; //系统是否有足够资源分配int p[mp]; //记录序列int Work[mr]; //工作数组int m,n; //m个进程,n个资源int l=0;void Init(); //初始化bool Safe();void jc();void main(){ Init();Safe();if(l!=m)jc();}void Init() //初始化算法{ int i,j;cout<<"请输入进程的数目:";cin>>m;cout<<"请输入资源的种类:";cin>>n;cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>MAX[i][j];cout<<"请输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++){ for(j=0;j<n;j++){cin>>fenpei[i][j];need[i][j]=MAX[i][j]-fenpei[i][j];if(need[i][j]<0){ cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl; j--;continue; }}}cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){ cin>>keyong[i]; }cout<<"剩余需求矩阵:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){ cout<<need[i][j]<<" ";if(j==n-1)cout<<endl;}cout<<"各资源现有数量:"<<endl;for(i=0;i<n;i++)cout<<keyong[i]<<" ";cout<<endl;}bool Safe() /*安全性算法*/{ int i,j,k;for(i=0;i<n;i++)Work[i]=keyong[i];for(i=0;i<m;i++){ FINISH[i]=false; //判断进程i是否已执行}for(i=0;i<m;i++){if(FINISH[i]==true){ continue;}else{ for(j=0;j<n;j++){ if(need[i][j]>Work[j]){ break;}}if(j==n){ FINISH[i]=true;for(k=0;k<n;k++){ Work[k]+=fenpei[i][k]; //进程i执行完后回收资源}p[l++]=i;i=-1;}else{continue;}}if(l==m){cout<<"系统是安全的"<<endl;cout<<"安全序列:"<<endl;for(i=0;i<l;i++){cout<<p[i];if(i!=l-1){cout<<"-->";}}cout<<""<<endl;return true;}}cout<<"会发生死锁,发生死锁的进程是:"<<endl;for(i=0;i<m;i++)if(FINISH[i]==false)cout<<i<<" ";cout<<endl;return false;}void jc(){int i,j,k,q;i=0;while(i<m&&FINISH[i]==false) //寻找没执行的{for(j=0;j<n;j++){keyong[j]+=fenpei[i][j]; //回收fenpei[i][j]=0;}if(Safe())cout<<"死锁已解除"<<endl;elsei++;Safe();}}五．实验结果进程已拥有资源数总需求资源数1 （0.0.1.2）（0.0.1.2.）2 （2.0.0.0）（2.7.5.0）3 （0.0.3.4）（6.6.5.6）4 （2.3.5.4）（4.3.5.6）5 （0.3.3.2）（0.6.5.2）其中系统可用资源数为2 1 0 0给进程3 分配资源数0 1 0 0六．实验心得：加深理解了有关资源申请分配、检测以及避免死锁等概念，了解死锁和避免死锁的具体实施方法。