[关闭]
@1405010312 2016-04-21T14:05:08.000000Z 字数 11538 阅读 797

实验五 Windows进程管理和银行家算法

VisualStudio可视化程序设计 银行家算法

报告提交日期:2016.4.20     报告提交截止日期:2016.4.21
姓名:肖罗罗     学号:1405010312     班级:计算机三班


Windows进程管理

一丶实验题目

  • Windows进程管理

二丶实验目的

  • 1.学会使用VC编写基本的Win32 Consol Application(控制台应用程序).
  • 2.通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作,进一步熟悉操作系统的进程概念,理解Windows进程的“一生”。
  • 3.通过阅读和分析实验程序,学习创建进程、观察进程、终止进程以及父子进程同步的基本程序设计方法。

三丶实验平台和环境

  • 带有vs2012的Windows操作系统平台

四丶实验要求

  • 自己操作,了解vs可视化编程设计

五丶背景知识

  Windows 所创建的每个进程都从调用 CreateProcess() API 函数开始,该函数的任务是在对象管 理器子系统内初始化进程对象。每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。 通常应用程序的框架负责调用 ExitProcess() 函数。对于 C++ 运行库来说,这一调用发生在应用程 序的 main() 函数返回之后。

(1).创建进程

  CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。表 1-1 详细地列出 了每个参数的类型和名称。
表 1-1 CreateProcess() 函数的参数

参数名称 使用目的
LPCTSTR lpApplivationName 全部或部分地指明包括可执行代码的 EXE 文件的文件名
LPCTSTR lpCommandLine 向可执行文件发送的参数
LPSECURIITY_ATTRIBUTES lpProcessAttributes 返回进程句柄的安全属性。主要指明这一句柄是否应该由其他 子进程所继承
LPSECURIITY_ATTRIBUTES lpThreadAttributes 返回进程的主线程的句柄的安全属性
BOOL bInheritHandle 一种标志,告诉系统允许新进程继承创建者进程的句柄
DWORD dwCreationFlage 特殊的创建标志 (如 CREATE_SUSPENDED) 的位标记
LPVOID lpEnvironment 向新进程发送的一套环境变量;如为 null 值则发送调用者环境
LPCTSTR lpCurrentDirectory 新进程的启动目录
STARTUPINFO lpStartupInfo STARTUPINFO 结构,包括新进程的输入和输出配置的详情
LPPROCESS_INFORMATION lpProcessInformation 调用的结果块;发送新应用程序的进程和主线程的句柄和 ID

     可以指定第一个参数,即应用程序的名称,其中包括相对于当前进程的当前目录的全路径或者 利用搜索方法找到的路径;lpCommandLine 参数允许调用者向新应用程序发送数据;接下来的三个 参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。
     然后是标志参数,用以在 dwCreationFlags 参数中指明系统应该给予新进程什么行为。经常使用 的标志是 CREATE_SUSPNDED,告诉主线程立刻暂停。当准备好时,应该使用 ResumeThread() API 来启动进程。另一个常用的标志是 CREATE_NEW_CONSOLE,告诉新进程启动自己的控制台窗口, 而不是利用父窗口。这一参数还允许设置进程的优先级,用以向系统指明,相对于系统中所有其他 的活动进程来说,给此进程多少 CPU 时间。
     接着是 CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。第一个参数是
lpEnvironment 参数,指明为新进程提供的环境;第二个参数是 lpCurrentDirectory,可用于向主创进 程发送与缺省目录不同的新进程使用的特殊的当前目录;第三个参数是 STARTUPINFO 数据结构所 必需的,用于在必要时指明新应用程序的主窗口的外观.
     CreateProcess() 的后一个参数是用于新进程对象及其主线程的句柄和 ID 的返回值缓冲区。 以 PROCESS_INFORMATION 结构中返回的句柄调用 CloseHandle() API 函数是重要的,因为如果 不将这些句柄关闭的话,有可能危及主创进程终止之前的任何未释放的资源。

(2).正在运行的进程

     如果一个进程拥有至少一个执行线程,则为正在系统中运行的进程。通常,这种进程使用主线 程来指示它的存在。当主线程结束时,调用 ExitProcess() API 函数,通知系统终止它所拥有的所有 正在运行、准备运行或正在挂起的其他线程。当进程正在运行时,可以查看它的许多特性,其中少 数特性也允许加以修改。
     首先可查看的进程特性是系统进程标识符 (PID) ,可利用 GetCurrentProcessId() API 函数来查 看,与 GetCurrentProcess() 相似,对该函数的调用不能失败,但返回的 PID 在整个系统中都可使用。 其他的可显示当前进程信息的 API 函数还有 GetStartupInfo()和 GetProcessShutdownParameters() , 可给出进程存活期内的配置详情。
     通常,一个进程需要它的运行期环境的信息。例如 API 函数 GetModuleFileName() 和 GetCommandLine() ,可以给出用在 CreateProcess() 中的参数以启动应用程序。在创建应用程序时 可使用的另一个 API 函数是 IsDebuggerPresent()
     可利用 API 函数 GetGuiResources() 来查看进程的 GUI 资源。此函数既可返回指定进程中的打 开的 GUI 对象的数目,也可返回指定进程中打开的 USER 对象的数目。进程的其他性能信息可通过 GetProcessIoCounters()、GetProcessPriorityBoost() 、GetProcessTimes() 和 GetProcessWorkingSetSize() API 得到。以上这几个 API 函数都只需要具有 PROCESS_QUERY_INFORMATION 访问权限的指向 所感兴趣进程的句柄。
     另一个可用于进程信息查询的 API 函数是 GetProcessVersion() 。此函数只需感兴趣进程的 PID (进程标识号) 。这一 API 函数与 GetVersionEx() 的共同作用,可确定运行进程的系统的版本号。

(3).终止进程

     Windows 2000/XP 提供的常用对象可分成三类:核心应用服务、线程同步和线程间通讯。其中, 开发人员可以使用线程同步对象来协调线程和进程的工作,以使其共享信息并执行任务。此类对象 包括互锁数据、临界段、事件、互斥体和信号等。
     多线程编程中关键的一步是保护所有的共享资源,工具主要有互锁函数、临界段和互斥体等; 另一个实质性部分是协调线程使其完成应用程序的任务,为此,可利用内核中的事件对象和信号。
     在进程内或进程间实现线程同步的方便的方法是使用事件对象,这一组内核对象允许一个线 程对其受信状态进行直接控制 (见表 1-2) 。
     而互斥体则是另一个可命名且安全的内核对象,其主要目的是引导对共享资源的访问。拥有单
3
一访问资源的线程创建互斥体,所有想要访问该资源的线程应该在实际执行操作之前获得互斥体, 而在访问结束时立即释放互斥体,以允许下一个等待线程获得互斥体,然后接着进行下去。
     与事件对象类似,互斥体容易创建、打开、使用并清除。利用 CreateMutex() API 可创建互斥体, 创建时还可以指定一个初始的拥有权标志,通过使用这个标志,只有当线程完成了资源的所有的初 始化工作时,才允许创建线程释放互斥体。

表 1-2 用于管理事件对象的 API

API名称 描述
CreateEvent() 在内核中创建一个新的事件对象。此函数允许有安全性设置、手工还是 自动重置的标志以及初始时已接受还是未接受信号状态的标志
OpenEvent() 创建对已经存在的事件对象的引用。此 API 函数需要名称、继承标志和 所需的访问级别
SetEvent() 将手工重置事件转化为已接受信号状态
ResetEvent() 将手工重置事件转化为非接受信号状态
PulseEvent() 将自动重置事件对象转化为已接受信号状态。当系统释放所有的等待它 的线程时此种转化立即发生

     为了获得互斥体,首先,想要访问调用的线程可使用 OpenMutex() API 来获得指向对象的句柄; 然后,线程将这个句柄提供给一个等待函数。当内核将互斥体对象发送给等待线程时,就表明该线 程获得了互斥体的拥有权。当线程获得拥有权时,线程控制了对共享资源的访问——必须设法尽快 地放弃互斥体。放弃共享资源时需要在该对象上调用 ReleaseMute() API。然后系统负责将互斥体拥 有权传递给下一个等待着的线程 (由到达时间决定顺序)

六丶实验内容,步骤

  • 1.编写基本的 Win32 Consol Application

第一个结果

  • 2.创建进程
  • 3.父子进程的简单通信及终止进程

七丶实验结论

八丶程序清单

1-1

  1. #include<iostream>
  2. void main(){
  3. std::cout << "Hello,Win32 Consol Application" << std::endl;
  4. }

1-2

  1. #include<windows.h>
  2. #include<iostream>
  3. #include<stdio.h>
  4. ///创建传递过来开的进程的克隆过程并赋予其ID值
  5. void StartClone(int nCloneID){
  6. ///提取用于当前可执行文件的文件名
  7. TCHAR szFilename[MAX_PATH];
  8. GetModuleFileName(NULL, szFilename, MAX_PATH);
  9. ///格式化用于子进程的命令行并通知其EXE文件名和克隆ID
  10. TCHAR szCmdLine[MAX_PATH];
  11. sprintf(szCmdLine,"\"%s\"%d", szFilename, nCloneID);
  12. ///用于子进程的STARTUPINFO结构
  13. STARTUPINFO si;
  14. ZeroMemory(&si, sizeof(si));
  15. si.cb = sizeof(si); ///必须是本结构的大小
  16. ///返回的用于子进程的进程信息
  17. PROCESS_INFORMATION pi;
  18. ///利用同样的可执行文件和命令行创建进程,并赋予其子进程的性质
  19. BOOL bCreateOK=::CreateProcess(
  20. szFilename, ///产生这个EXE的应用程序的名称
  21. szCmdLine, ///告诉其行为像一个子进程的标志
  22. NULL, ///缺省的进程安全性
  23. NULL, ///缺省的线程安全性
  24. FALSE, ///不继承句柄
  25. CREATE_NEW_CONSOLE, ///使用新的控制台
  26. NULL, ///新的环境
  27. NULL, ///当前目录
  28. &si, ///启动信息
  29. &pi ///返回的进程信息
  30. );
  31. if(bCreateOK){
  32. CloseHandle(pi.hProcess);
  33. CloseHandle(pi.hThread);
  34. }
  35. }
  36. int main(int argc, char* argv[]){
  37. ///确定派生出几个进程,及派生进程在进程列表中的位置
  38. int nClone = 0;
  39. ///修改语句: int nClone;
  40. ///第一次修改: nClone = 0;
  41. if(argc > 1){
  42. ///从第二个参数中提取克隆ID
  43. ::sscanf(argv[1], "%d", &nClone);
  44. }
  45. ///第二次修改: nClone = 0;
  46. ///显示进程位置
  47. std::cout<<"Process ID:" << ::GetCurrentProcessId()<<",CloneID:"<<nClone<<std::endl;
  48. ///检查是否有创建子进程的需要
  49. const int c_nCloneMax = 5;
  50. if(nClone < c_nCloneMax){
  51. ///发送新进程的命令行和克隆号
  52. StartClone(++nClone);
  53. }
  54. ///等待响应键盘输入结束进程
  55. getchar();
  56. return 0;
  57. }

1-3

  1. #include<windows.h>
  2. #include<iostream>
  3. #include<stdio.h>
  4. static LPCTSTR g_szMutexName="w2kdg.ProcTerm.mutex.Suicide";
  5. void StartClone()
  6. {
  7. TCHAR szFilename[MAX_PATH];
  8. GetModuleFileName(NULL,szFilename,MAX_PATH);
  9. TCHAR szCmdLine[MAX_PATH];
  10. sprintf(szCmdLine,"\"%s\"child",szFilename);
  11. STARTUPINFO si;
  12. ZeroMemory(&si,sizeof(si));
  13. si.cb=sizeof(si);
  14. PROCESS_INFORMATION pi;
  15. BOOL bCreateOK=CreateProcess(
  16. szFilename,
  17. szCmdLine,
  18. NULL,
  19. NULL,
  20. FALSE,
  21. CREATE_NEW_CONSOLE,
  22. NULL,
  23. NULL,
  24. &si,
  25. &pi);
  26. if(bCreateOK)
  27. {
  28. CloseHandle(pi.hProcess);
  29. CloseHandle(pi.hThread);
  30. }
  31. }
  32. void Parent()
  33. {
  34. HANDLE hMutexSuicide=CreateMutex(
  35. NULL,
  36. TRUE,
  37. g_szMutexName);
  38. if(hMutexSuicide!=NULL)
  39. {
  40. std::cout<<"Creating thw child process."<<std::endl;
  41. StartClone();
  42. std::cout<<"Telling the child process to quit."<<std::endl;
  43. getchar();
  44. ReleaseMutex(hMutexSuicide);
  45. CloseHandle(hMutexSuicide);
  46. }
  47. }
  48. void Child()
  49. {
  50. HANDLE hMutexSuicide=OpenMutex(
  51. SYNCHRONIZE,
  52. FALSE,
  53. g_szMutexName);
  54. if(hMutexSuicide!=NULL)
  55. {
  56. std::cout<<"Child waiting for suicide instructions."<<std::endl;
  57. WaitForSingleObject(hMutexSuicide,INFINITE);
  58. std::cout<<"Child quiting."<<std::endl;
  59. CloseHandle(hMutexSuicide);
  60. }
  61. }
  62. int main(int argc,char* argv[])
  63. {
  64. if(argc>1&&::strcmp(argv[1],"child")==0)
  65. {
  66. Child();
  67. }
  68. else
  69. {
  70. Parent();
  71. }
  72. return 0;
  73. }

银行家算法

一丶实验目的

  • 1.掌握银行家算法
  • 2.了解死锁,饥饿问题
  • 3.学会使用方法来解决死锁问题

二丶实验平台

  • 装有codeblocks的Windows平台

三丶实验要求

  1. 自己操作
  2. 用银行家算法实现
  3. 利用C/c++语言实现

四丶实验步骤

  1. 在codeblocks下建立两个c++文件,一个是banker.h,一个main.cpp
  2. 将程序清单中的1-1代码复制到main.cpp
  3. 将程序清单中的1-2代码复制到banker.h
  4. 按F9运行程序可得到一些结果

五丶程序结果

6

7

六丶实验总结

1.对银行家算法不熟悉,犯了很多小错误
2.很久没用c++编写比较大一点的文件了(都是编译大约200行的代码,这次有将近300了)

七丶程序清单

1-1

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include "banker.h"
  4. //试探分配
  5. void ProbeAlloc(int process,RESOURCE *res)
  6. {
  7. Available.A -= res->A;
  8. Available.B -= res->B;
  9. Available.C -= res->C;
  10. Allocation[process].A += res->A;
  11. Allocation[process].B += res->B;
  12. Allocation[process].C += res->C;
  13. Need[process].A -= res->A;
  14. Need[process].B -= res->B;
  15. Need[process].C -= res->C;
  16. }
  17. //若试探分配后进入不安全状态,将分配回滚
  18. void RollBack(int process,RESOURCE *res)
  19. {
  20. Available.A += res->A;
  21. Available.B += res->B;
  22. Available.C += res->C;
  23. Allocation[process].A -= res->A;
  24. Allocation[process].B -= res->B;
  25. Allocation[process].C -= res->C;
  26. Need[process].A += res->A;
  27. Need[process].B += res->B;
  28. Need[process].C += res->C;
  29. }
  30. //安全性检查
  31. bool SafeCheck()
  32. {
  33. RESOURCE Work = Available;
  34. bool Finish[PROCESSES_NUMBER] = {false,false,false,false,false};
  35. int i;
  36. int j = 0;
  37. for (i = 0; i < PROCESSES_NUMBER; i++)
  38. {
  39. //是否已检查过
  40. if(Finish[i] == false)
  41. {
  42. //是否有足够的资源分配给该进程
  43. if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C)
  44. {
  45. //有则使其执行完成,并将已分配给该进程的资源全部回收
  46. Work.A += Allocation[i].A;
  47. Work.B += Allocation[i].B;
  48. Work.C += Allocation[i].C;
  49. Finish[i] = true;
  50. safe[j++] = i;
  51. i = -1; //重新进行遍历
  52. }
  53. }
  54. }
  55. //如果所有进程的Finish向量都为true则处于安全状态,否则为不安全状态
  56. for (i = 0; i < PROCESSES_NUMBER; i++)
  57. {
  58. if (Finish[i] == false)
  59. {
  60. return false;
  61. }
  62. }
  63. return true;
  64. }
  65. //资源分配请求
  66. bool request(int process,RESOURCE *res)
  67. {
  68. //request向量需小于Need矩阵中对应的向量
  69. if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <= Need[process].C)
  70. {
  71. //request向量需小于Available向量
  72. if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C)
  73. {
  74. //试探分配
  75. ProbeAlloc(process,res);
  76. //如果安全检查成立,则请求成功,否则将分配回滚并返回失败
  77. if(SafeCheck())
  78. {
  79. return true;
  80. }
  81. else
  82. {
  83. printf("安全性检查失败。原因:系统将进入不安全状态,有可能引起死锁。\n");
  84. printf("正在回滚...\n");
  85. RollBack(process,res);
  86. }
  87. }
  88. else
  89. {
  90. printf("安全性检查失败。原因:请求向量大于可利用资源向量。\n");
  91. }
  92. }
  93. else
  94. {
  95. printf("安全性检查失败。原因:请求向量大于需求向量。\n");
  96. }
  97. return false;
  98. }
  99. //输出资源分配表
  100. void PrintTable()
  101. {
  102. printf("\t\t\t*********资源分配表*********\n");
  103. printf("Process Max Allocation Need Available\n");
  104. printf(" A B C A B C A B C A B C\n");
  105. printf(" P0 %d %d %d %d %d %d %d %d %d %d %d %d\n",Max[0].A,Max[0].B,Max[0].C,Allocation[0].A,Allocation[0].B,Allocation[0].C,Need[0].A,Need[0].B,Need[0].C,Available.A,Available.B,Available.C);
  106. printf(" P1 %d %d %d %d %d %d %d %d %d\n",Max[1].A,Max[1].B,Max[1].C,Allocation[1].A,Allocation[1].B,Allocation[1].C,Need[1].A,Need[1].B,Need[1].C);
  107. printf(" P2 %d %d %d %d %d %d %d %d %d\n",Max[2].A,Max[2].B,Max[2].C,Allocation[2].A,Allocation[2].B,Allocation[2].C,Need[2].A,Need[2].B,Need[2].C);
  108. printf(" P3 %d %d %d %d %d %d %d %d %d\n",Max[3].A,Max[3].B,Max[3].C,Allocation[3].A,Allocation[3].B,Allocation[3].C,Need[3].A,Need[3].B,Need[3].C);
  109. printf(" P4 %d %d %d %d %d %d %d %d %d\n",Max[4].A,Max[4].B,Max[4].C,Allocation[4].A,Allocation[4].B,Allocation[4].C,Need[4].A,Need[4].B,Need[4].C);
  110. printf("\n");
  111. }
  112. int main()
  113. {
  114. int ch;
  115. printf("先检查初始状态是否安全。\n");
  116. if (SafeCheck())
  117. {
  118. printf("系统处于安全状态。\n");
  119. printf("安全序列是{P%d,P%d,P%d,P%d,P%d}。\n",safe[0],safe[1],safe[2],safe[3],safe[4]);
  120. }
  121. else
  122. {
  123. printf("系统处于不安全状态。程序将退出...\n");
  124. goto over;
  125. }
  126. do
  127. {
  128. int process;
  129. RESOURCE res;
  130. PrintTable();
  131. printf("请依次输入请求分配的进程和对三类资源的请求数量:");
  132. scanf("%d%d%d%d",&process,&res.A,&res.B,&res.C);
  133. if (request(process,&res))
  134. {
  135. printf("分配成功。\n");
  136. printf("安全序列是{P%d,P%d,P%d,P%d,P%d}。\n",safe[0],safe[1],safe[2],safe[3],safe[4]);
  137. }
  138. else
  139. {
  140. printf("分配失败。\n");
  141. }
  142. printf("是否继续分配?(Y/N):");
  143. fflush(stdin);
  144. ch = getchar();
  145. } while (ch == 'Y' || ch == 'y');
  146. over:
  147. printf("执行完毕。");
  148. return 0;
  149. }

1-2

  1. //系统中所有进程数量
  2. #define PROCESSES_NUMBER 5
  3. typedef struct {
  4. int A;
  5. int B;
  6. int C;
  7. }RESOURCE;
  8. //最大需求矩阵
  9. RESOURCE Max[PROCESSES_NUMBER] =
  10. {
  11. {10,10,10},
  12. {10,10,10},
  13. {10,10,10},
  14. {10,10,10},
  15. {10,10,10}
  16. };
  17. //已分配资源数矩阵
  18. RESOURCE Allocation[PROCESSES_NUMBER] =
  19. {
  20. {0,0,0},
  21. {0,0,0},
  22. {0,0,0},
  23. {0,0,0},
  24. {0,0,0}
  25. };
  26. //需求矩阵
  27. RESOURCE Need[PROCESSES_NUMBER] =
  28. {
  29. {1,2,3},
  30. {2,1,3},
  31. {1,3,2},
  32. {2,3,1},
  33. {3,2,1}
  34. };
  35. //可用资源向量
  36. RESOURCE Available = {10,10,10};
  37. int safe[PROCESSES_NUMBER];
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注