实验1
进程的描述与控制 Windows 2000编程
(实验估计时间：100分钟)
1.1 背景知识
Windows 2000 可以识别的应用程序包括控制台应用程序、GUI应用程序和服务应用程序。控制台应用程序可以创建GUI，GUI应用程序可以作为服务来运行，服务也可以向标准的输出流写入数据。不同类型应用程序间的惟一重要区别是其启动方法。
Windows 2000是以NT技术构建的，它提供了创建控制台应用程序的能力，使用户可以利用标准的C++工具，如iostream库中的cout和cin对象，来创建小型应用程序。当系统运行时，Windows 2000的服务通常要向系统用户提供所需功能。
服务应用程序类型需要ServiceMail()函数，由服务控制管理器(SCM)加以调用。SCM是操作系统的集成部分，负责响应系统启动以开始服务、指导用户控制或从另一个服务中来的请求。其本身负责使应用程序的行为像一个服务，通常，服务登录到特殊的LocalSystem账号下，此账号具有与开发人员创建的服务不同的权限。
当C++编译器创建可执行程序时，编译器将源代码编译成OBJ文件，然后将其与标准库相链接。产生的EXE文件是装载器指令、机器指令和应用程序的数据的集合。装载器指令告诉系统从哪里装载机器代码。另一个装载器指令告诉系统从哪里开始执行进程的主线程。在进行某些设置后，进入开发者提供的main()、Servicemain()或WinMain()函数的低级入口点。机器代码中包括控制逻辑，它所做的事包括跳转到Windows API函数，进行计算或向磁盘写入数据等。
Windows允许开发人员将大型应用程序分为较小的、互相有关系的服务模块，即动态链接库(DLL)代码块，在其中包含应用程序所使用的机器代码和应用程序的数据。
1.2 实验目的
通过对Windows 2000编程，进一步熟悉操作系统的基本概念，较好地理解Windows 2000的结构。
1.3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：
1）一台运行Windows 2000 Professional 操作系统的计算机。 2）计算机中需安装Visual C++ 6.0 专业版或企业版。
1.4 实验内容与步骤
(1)、简单的控制台应用程序
我们先来创建一个名为“Hello，World”的应用程序。 步骤1：登录进入Windows 2000 Professional。
步骤2：利用输入输出类iostream和std::cout编写一个控制台小程序，在屏幕上显示“hello,windows 2000”，并把代码保存为1-1.cpp。 步骤3：在“开始”菜单中单击“程序”、“附件”、“命令提示符”，进入Windows “命令提示符”窗口，并利用简单的标准命令行： C：\\>CL 1-1.cpp
来创建可执行的1-1.exe。
操作能否正常进行？如果不行，原因是什么？
解：首先将所需要的文件拷贝到相应的目录中，执行命令发现不能运行成功，首先是C盘根目录下面没有CL.exe文件.进入到文件夹C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin之后可以发现CL.exe文件，重新运行命令后仍然不能成功，显示fatal error C1034: iostream: no include path set错误，经查找资料可知，应该在命令行中首先运行VCVARS32.BAT 命令如下：
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin>VCVARS32.BAT 然后运行命令成功，成功生成1-1.exe
步骤4：运行1-1.exe程序，产生用户键入的一行文字。 运行结果（如果运行不成功，原因是什么？）：
解：运行命令成功
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin>1-1.exe 输出结果： hello,windows 2000
(2)、GUI应用程序
在下面的实验中，用C++编译器创建一个GUI应用程序，代码应包括WinMain()方法，这是GUI类型的应用程序的标准入口点。
步骤1：用Windows.h头文件、WinMain()、MessageBox() API函数、用pragma指令指示编译器/连接器找到User32.lib库文件编写一段小程序，在屏幕上显示一个窗口，消息框中显示“Hello,Windows 2000\消息框标是用\消息框中设一个“OK”按钮，代码保存为1-2.cpp
步骤2：在“命令提示符”窗口运行CL.exe，产生1-2.exe文件： C：\\>CL 1-2.cpp 运行结果：
解：运行结果如下：
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin>CL 1-2.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8168 for 80x86
Copyright (C) Microsoft Corp 1984-1998. All rights reserved. 1-2.cpp
Microsoft (R) Incremental Linker Version 6.00.8168
Copyright (C) Microsoft Corp 1992-1998. All rights reserved.
/out:1-2.exe 1-2.obj 运行1-2.exe
3、进程对象
操作系统将当前运行的应用程序看作是进程对象。利用系统提供的惟一的称为句柄（HANDLE）的号码，就可与进程对象交互，这一号码只对当前进程有效。
本实验编写一个简单的进程句柄的应用，在系统中运行的任何进程都可调用GetCurrentProcess() API函数，返回标识进程本身的句柄；再利用GetPriorityClass()获得进程的优先级，用cout函数在屏幕上把得到的进程优先级在屏幕上显示出来。
步骤1：将程序键入记事本中，并把代码保存为1-3.cpp
步骤2：在“命令提示符”窗口运行CL.exe，产生1-3.exe文件： C：\\>CL 1-3.cpp 运行结果
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin>CL 1-3.cpp /out:1-3.exe 1-3.obj 运行：
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin>1-3.exe 输出结果：
Current process priority:normal 截图如下：
步骤3：编写一段程序，利用句柄查出进程的详细信息，首先利用Windows 2000的新特性工具帮助库tlhelp.h来获得当前运行的所有进程的快照。然后应用程序进入快照中的每一个进程，得到其以PROCESSENTRY32结构表示的属性，这一结构用来向OpenProcess() API函数提供进程的ID。Windows跟踪每一进程的有关时间，通过打开的进程句柄和GetProcessTime（） API来查询得到有关时间。然后计算进程在内核模式下消耗的时间占总时间的百分比。 将程序键入记事本中，并把代码保存为1-4.cpp。
步骤4：在“命令提示符”窗口运行CL.exe，产生1-4.exe文件： C:\\>CL 1-4.cpp 运行结果：
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin>CL 1-4.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8168 for 80x86 Copyright (C) Microsoft Corp 1984-1998. All rights reserved. 1-4.cpp
Microsoft (R) Incremental Linker Version 6.00.8168
Copyright (C) Microsoft Corp 1992-1998. All rights reserved.
/out:1-4.exe 1-4.obj
运行1-4..exe
1.5 实验总结
1)
首先查找CL.exe文件的位置，然后将所需要的cpp代码文件拷贝到CL.exe所在的文件夹之中，保证在命令行模式执行命令的过程中不会出现找不到文件之类的低级错误。 2)
通过本次实验我还学到了如何在命令行模式下编译C++程序，在直接尝试中遇到许多的错误，在解决错误的过程中我学到： cl.exe要用到MSDev98\\Bin目录下的MSPDB60.DLL 解决第一个错误的方法有以下几种： A. 将电脑目录
C:\\Program Files\\Microsoft Visual Studio\\COMMON\\MSDev98\\Bin下面的
MSPDB60.DLL文件拷贝到CL.exe所在的
文件夹中
B．在“我的电脑--属性--高级--环境变量”中， 添加如下变量： INCLUDE
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Include LIB
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Lib
C:\\ProgramFiles\\MicrosoftVisualStudio\\Common\\MSDev98\\Bin;X:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin 3） 第三个错误
fatal error C1034: iostream: no include path set错误。
解决方案:经查找资料可知，应该在命令行中首先运行VCVARS32.BAT 命令如下：
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin>VCVARS32.BAT 然后运行命令成功。
在解决问题的同时我也学到：vcvars32.bat 文件设置适当的环境变量以启用 32 位命令行编译。 4） 关于程序文件
文件 1-1.cpp内容比较简单，就是用C++输出hello,windows 2000
文件1-2.cpp是用Windows.h头文件、WinMain()、MessageBox() API函数、用pragma指令指示编译器/连接器找到User32.lib库文件编写一段小程序，也就是一个简单的windows编程，再次熟悉了WinMain（）函数。
文件1-3.cpp是一个简单的进程句柄的应用，在系统中运行的任何进程都可调用GetCurrentProcess() API函数，返回标识进程本身的句柄；再利用GetPriorityClass()获得进程的优先级，用cout函数在屏幕上把得到的进程优先级在屏幕上显示出来。
文件1-4.cpp利用Windows 2000的新特性工具帮助库tlhelp.h来获得当前运行的所有进程的快照。
1.6 实验评价（教师）
实验2
进程的描述与控制
Windows 2000进程的一生
(实验估计时间：100分钟)
2.1 背景知识
Windows 2000 所创建的每个进程都从调用CreateProcess() API函数开始，该函数的任务是在对象管理器子系统内初始化进程对象。每一进程都以调用ExitProcess()或TerminateProcess() API函数终止。通常应用程序的框架负责调用ExitProcess()函数，对于C++运行库来说，这一调用发生在应用程序的main()函数返回之后。 1. 创建进程
CreateProcess()调用的核心参数是可执行文件运行时的文件名及其命令行。表2-1详细地列出了每个参数的类型和名称。
表2-1 实验记录
参数名称 LPCTSTR lpApplivationNAME LPCTSTR lpCommandLine LPSECURIITY_ATTRIBUTES lpProcessAttributes LPSECURIITY_ATTRIBUTES lpThreadAttributes BOOL bInheritHandle DWORD dwCreationFlage LPVOID lpEnvironment LPCTSTR lpCurrentDirectory STARTUPINFO lpStartupInfo LPPROCESS_INFORMATION lpProcessInformation 使用目的 全部或部分地指明包括可执行代码的EXE文件的文件名 向可执行文件发送的参数 返回进程句柄的安全属性，主要指明这一句柄是否应该由其他子进程所继承。 返回进程的主线程的句柄的安全属性 一种标志，告诉系统允许新进程继承创建者进程的句柄 特殊的创建标志（如CREATE_SUSPENDED）的位标记 向新进程发送的一套环境变量；如为null值则发送调用者环境 新进程的启动目录 STARTUPINFO结构，包括新进程的输入和输出配置的详情 调用的结果块；发送新应用程序的进程和主线程的句柄和ID 可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。 然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。经常使用的标志是CREATE_SUSPNDED，告诉主线程立刻暂停。当准备好时，应该使用ResumeThread() API来启动进程。另一个常用的标志是CREATE_NEW_CONSOLE，告诉新进程启动自己的控制台窗口，而不是利用父窗口，这一参数还允许设置进程的优先级，用以向系统指明，相对于系统中所有其他的活动进程来说，给此进程多少CPU时间。
接着是CreateProcess()函数调用所需要的三个通常使用缺省值的参数，第一个参数是lpEnvironment参数，指明为新进程提供的环境；第二个参数是lpCurrentDirectory,可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录；第三个参数是STARTUPINFO数据结构中所必需的，用于在必要时指明新应用程序的主窗口的外观。
CreateProcess（）的最后一个参数是用于新进程对象及其主线程的句柄和ID的返回值缓冲区，以PROCESS_INFORMATION结构中返回的句柄调用Close_Handle() API函数是重要的，因为如果不将这些句柄关闭的话，有可能危及主创进程终止之前的任何未释放的资源。 2. 正在运行的进程
如果一个进程程拥有至少一个执行线程，则为正在系统中运行的进程。通常这种进程使用主线程来指示它的存在，当主线程结束时，调用Exitprocess() API函数，通知系统终止它所拥有的所有正在运行、准备运行或正在挂起的其他线程。当进程正在运行时，可以查看它的许多特性，其中少数特性也允许加以修改。
首先可查看的进程特性是系统进程标识符（PID），可利用GetCurrentProcessId() API函数来查看，与GetCurrentProcess()相似，对该函数的调用不能失败，但返回的PID在整个系统中都可使用，其他可显示当前进程信息的API函数还有GetStartInfo()和GetprocessShutdownParameters(),可给出进程存活期内的配置详情。 通常，一个进程需要它运行期环境的信息，例如API函数GetModuleFileName()和GetcommandLine(),可以给出CreateProcess()中的参数以启动应用程序。在创建应用程序时可使用的另一个API函数是IsDebuggerPresent()。
可利用API函数GetGuiResources()来查看进程的GUI资源，此函数既可返回指定进程中的打开的GUI对象的数目，也可返回指定进程中打开的USER对象的数目。进程的其他性能信息可通过GetProcessIoCounters()、GetProcessPriorityBoost（）、GetProcessTimes()和GetProcessWorkingSetSize() API得到，以上这几个API函数都只需要具有PROCESS_QUERY_INFORMATION访问权限的指向所感兴趣进程的句柄。
另一个可用于进程信息查询的API函数是GetProcessVersion(),此函数只需感兴趣进程的PID（进程标识号）。 3. 终止进程
所有进程都是以调用ExitProcess()或者TerminateProcess()函数结束的，但最好使用前者而不要使用后者，因为进程是在完成了它的所有的关闭“职责”之后以正常的终止方式来调用前者的。而外部进程通常调用后者即突然终止进程的进行，由于关闭时的途径不太正常，有可能引起错误的行为。
TerminateProcess() API函数只要打开带有PROCESS_TERMINATE访问权的对象，就可以终止进程，并向系统返回指定的代码，这是一种“野蛮”的终止进程的方式，但是有时却是需要的。 如果开发人员确实有机会来设计“谋杀”（终止别的进程的进程）
和“受害”进程（被终止的进程）时，应该创建一个进程间通信的内核对象，如一个互斥程序，这样一来，“受害”进程只在等待或同期性地测试它是否应该终止。
2.2 实验目的
1）通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解Windows 2000进程的“一生”。
2）通过编写和分析实验程序，学习创建进程、观察进程和终止进程的程序设计方法。
2.3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：
1）一台运行Windows 2000 Professional 操作系统的计算机。 2）计算机中需安装Visual C++ 6.0 专业版或企业版。
2.4 实验内容与步骤
请回答：
Windows所创建的每个进程都是以调用CreateProcess() API函数开始和以调用ExitProcess()或TerminateProcess() API函数终止。
1、创建进程
本实验学习创建进程的基本框架。该程序要求启动自身，显示它的系统进程ID和它在进程列表中的位置。
步骤1：登录进入Windows 2000 Professional。 步骤2：在“开始”菜单中单击“程序”、“Microsoft Visual Studio 6.0”“Microsoft Visual C++ 6.0”，进入Visual C++窗口。
步骤3：在工具栏单击“新建”按钮，输入代码保存为2-1.cpp。 参考类和函数：windows.h、iostream、stdio.h、StartClone()、GetModuleFileName、ZeroMemory。 步骤4：单击“Build”菜单中的“Compile 2-1.cpp”命令，对2-1.cpp进行编译。
步骤5：编译完成后，单击“Build”菜单中的“Build 2-1.exe”命令，建立2-1.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？
解：不能正常运行：屏幕一直在闪烁。
原因：在错误的情况下，闪屏的ID一直是0，也就是说 if (nClone < c_nCloneMax) {
// 发送新进程的命令行和克隆号 StartClone(++nClone) ; }
中的nClone一直为0，导致类似死循环的窗口闪烁。 解决方案：
语句:: sprintf(szCmdLine,\有语法错误，将其该为%d
步骤6：在工具栏单击“Execute program”按钮，或者按Ctrl+F5键，或者单击“Build”菜单中的“Execute 2-1.exe”命令，执行2-1.exe程序。
步骤7：按Ctrl+S键可暂停程序的执行，按Ctrl+Pause（Break）键可终止程序的执行。
程序运行时屏幕显示的信息是： 显示Clone从0-25的过程中
最后程序显示的结果是：
2. 正在运行的进程
本实验用进程信息查询的API函数GetProcessVersion()与GetVersionEx(),确定运行进程的操作系统的版本号。
步骤1：在工具栏单击“新建”按钮，编写代码保存为2-2.cpp。
步骤2：单击“Build”菜单中的“Compile 2-2.cpp”命令，系统对2-2.cpp进行编译。
步骤3：编译完成后，单击“Build”菜单中的“Build 2-2.exe”命令，建立2-2.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 程序能够正确执行。输出结果是：
步骤4：在工具栏单击“Execute program”按钮，执行2-2.exe程序。
运行结果：
当前PID信息： 当前操作系统版本： 系统提示信息：
和系统对比：可见显示是正确的。
除了改变进程的优先级以外，还可以对正在运行的进程执行几项其他的操作，只要获得其进程句柄即可，SetProcessAffinityMask() API函数允许开发人员将线程映射到处理器上；SetProcessAffinityBoost() API可关闭前台应用程序优先级的提升；而SetProcessWorkingSet() API可调节进程可用的非页面RAM的容量；还有一个只对当前进程可用的API函数，即SetProcessShutdownParameters(),可告诉系统如何终止该进程。
3. 终止进程
步骤1：在工具栏单击“新建”按钮，编写代码保存为2-3.cpp。 步骤2：单击“Build”菜单中的“Compile 2-3.cpp”命令，再单击“是”按钮确认，系统对2-3.cpp进行编译。
步骤3：编译完成后，单击“Build”菜单中的“Build 2-3.exe”命
令，建立2-3.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：能正确执行
步骤4：在工具栏单击“Execute program”按钮，执行2-3.exe程序。
运行结果及说明：
运行程序之后，显示两个窗口：父窗口和子窗口
等待一段时间之后子进程杀死自身进程
修改部分程序代码：
std :: cout << \
:: StartClone() ; // 暂停 :: Sleep(5000) ;
// 指令子进程“杀”掉自身
std :: cout << \
:: Sleep(5000) ;
:: ReleaseMutex(hMutexSuicide) ;
在杀死子进程之前等待一段时间，可以清楚的查看到屏幕显示的信息，即输出Telling the child process to quit.等待一段时间之后杀死子进程。
2.5 实验总结
1) 本次试验学到了CreateProcess()，ExitProcess()，TerminateProcess() 等API函数的基本应用以及含义。
2）试验2.1中出现了语法错误，将%d写成了d%，这个错误不是很明显，不容易被发现，在平时的编程中要避免此类语法错误的产生。
3）试验2.2使用GetProcessVersion函数、GetCurrentProcessId函数和GetVersionEx函数得到进程的ID和系统的版本。
4）试验2.3 使用SetProcessAffinityMask() 、SetProcessAffinityBoost() 、SetProcessWorkingSet()、SetProcessShutdownParameters()函数实现了从创建
进程、创建子进程、杀死进程等功能。
5）例如在程序2-3中，在命令行模式下执行2.3.exe，在后面传递参数：
分析程序代码：
int main(int argc, char* argv[] ) {
// 决定其行为是父进程还是子进程
if (argc>1 && :: strcmp(argv[1] , \ {
Child() ; } else {
Parent() ; } return 0; }
当mian()函数中的argc>1 并且 :: strcmp(argv[1] , \是执行子进程，而不是首先执行父进程。
这种直接在命令行下面向mian()函数传递参数的方式也是第一次接触，感触很深。
又例如在2.1.exe中 if (argc > 1) {
// 从第二个参数中提取克隆ID :: sscanf(argv[1] , \
}
执行命令：
C:\\Program Files\\Microsoft Visual Studio\\VC98\\Bin\\Debug>2-1.exe 5 Process ID:5140, Clone ID:5
最终创建的进程号就从5开始，而不是从0开始了。
argc是命令行总的参数个数 ， argv[]是argc个参数，其中第0个参数是程序的全名，以后的参数命令行后面跟的用户输入的参数
2.6 实验评价（教师）
实验3
进程的同步与通信
Windows 2000线程同步
(实验估计时间：100分钟)
3.1 背景知识
Windows 2000 提供的常用对象可分成三类：核心应用服务、线程同步和线程间通信，其中，开发人员可以使用线程同步对象来协调线程和进程的工作，以使其共享信息并执行任务。此类对象包括互锁数据、临界区、事件、互斥信号量等。
多线程编程中关键的一步是保护所有的共享资源，工具主要有互锁函数、临界区和互斥信号量等；另一个实质性部分是协调线程使其完成应用程序的任务，为此，可利用内核中的事件对象和信号。
在进程内或进程间实现线程同步的最方便的方法是使用事件对象，这一组内核对象允许一个线程对其受信状态进行直接控制（见表3-1）。
表3-1 用于管理事件对象API API名称 CreateEvent() OpenEvent() SetEvent() 描述 在内核中创建一个新的事件对象。此函数允许有安全性设置、手工还是自动重置的标志以及初始时已接收还是未接收信号状态的标志。 创建对已经存在的事件对象的引用。此API函数需要名称、继承标志和所需的访问级别。 将手工重置事件转化为已接收信号状态。 ResetEvent() 将手工重置事件转化为非接收信号状态。 PulseEvnt() 将自动重置事件对象转化为已接收信号状态。当系统释放所有的等待它的线程时此种转化立即发生。 与事件对象类似，互斥信号量容易创建、打开、使用并清除。利用CreateMutex()API函数可创建互斥信号量，创建时还可以指定一个初始的拥有权标志，通过使用这个标志，只有当线程完成了资源的所有的初始化工作时，才允许创建线程释放互斥信号量。
为了获得互斥信号量，首先，想要访问调用的线程可使用OpenMutex()API函数来获得指向对象的句柄；然后，线程将这个句柄提供给一个等待函数。当内核将互斥信号量对象发送给等待线程时，就表明该线程获得了互斥信号量的拥有权。当线程获得拥有权时，线程控制了对共享资源的访问——必须设法尽快地放弃互斥信号量。放弃共享资源时需要在该对象上调用ReleaseMutex()API。然后系统负责将互斥信号量拥有权传递给下一个等待着的线程（由到达时间决定顺序）。
3.2 实验目的
在本实验中，通过对事件和互斥信号量对象的了解，加深对Windows 2000线程同步的理解。
1）回顾系统进程、线程的有关概念，加深对Windows 2000的理解。
2）了解事件和互斥信号量对象。
3）通过分析实验程序，了解管理事件对象的API。 4）了解在进程中如何使用事件对象。
5）了解在进程中如何使用互斥信号量对象。 6）了解父进程创建子进程的程序设计方法。
3.3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：
1）一台运行Windows 2000 Professional 操作系统的计算机。 2）计算机中需安装Visual C++ 6.0 专业版或企业版。
3.4 实验内容与步骤
1. 事件对象
在进程间使用事件。父进程启动时，利用CreateEvent()API创建一个命名的、可共享的子进程，然后等待子进程向事件发出信号并终止父进程。在创建时，子进程通过OpenEvent()API打开事件对象，调用SetEvent()API使其转化为已接收信号状态。两个进程在发出信号之后几乎立即终止。
步骤1：登录进入Windows 2000 Professional。 步骤2：在“开始”菜单中单击“程序”、“Microsoft Visual Studio 6.0”“Microsoft Visual C++ 6.0”，进入Visual C++窗口。
步骤3：在工具栏单击“新建”按钮，编写代码保存为3-1.cpp。 程序功能：创建和打开事件对象在进程间传送信号。 参考类和函数：
windows.h、iostream、CreateChild()、szFilename、GetModuleFileName、 szCmdLine、CloseHandle、WaitForChild()。
步骤4：单击“Build”菜单中的“Compile 3-1.cpp”命令，单击“是”按钮确认，系统对3-1.cpp进行编译。
步骤5：编译完成后，单击“Build”菜单中的“Build3-1.exe”命令，建立3-1.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：程序能够正常执行。
步骤6：在工具栏单击“Execute program”按钮，执行3-1.exe程序。
运行结果（分行书写，如果不成功，原因是什么？）： 在去掉:: Sleep(1500);之前的运行结果是： 1. event created 2. chlid created
3. Parent waiting on child. 4. child process begining...... 5. event signaled
6. parent received the envent signaling from child 7. Parent released. 去掉:: Sleep(1500);语句：
1. event created 2. chlid created
3. Parent waitingc on chhiildl. 4. d process begining......
5. eparvent erentceived the ensivegnt nsiganlalinge frd 6. om child
7. Parent released.
这个结果与你期望的一致吗？（从进程并发的角度对结果进行分析）。
分析可知：在有Sleep(1500);时，主程序会等待子程序1.5s，这样的话子程序先输出，然后主程序再输出。这样的话就不会出现错误。而当去掉:: Sleep(1500);语句之后主程序和字程序同时输出就会出现输出结果重叠的情况，变现为输出结果错误。 请回答：
1）程序中，创建一个事件使用了哪一个系统函数？创建时设置的初始信号状态是什么？
a）创建事件用CreateEvent()函数
b）CreateEvent( NULL, TRUE, FALSE, 始状态为有信号状态
g_szContinueEvent); // 事件名称，指定事件的对象的名称，是一个以0结束的字符串指针
// 缺省的安全性，子进程将具有访问权限
// 手工重置事件，必须用ResetEvent函数// 初始时是非接受信号状态，为TRUE，初
来手工将事件的状态复原到无信号状态
2）创建一个进程（子进程）使用了哪一个系统函数？ 创建子进程使用
BOOL CreateProcess (
LPCTSTR lpApplicationName, //指向一个NULL结尾的、用来指定可执行模块的字符串。
LPTSTR lpCommandLine, //指向一个NULL结尾的、用来指定要运行的命令行。
LPSECURITY_ATTRIBUTES lpProcessAttributes。//指向一个结构体，这个结构体决定是否返回的句柄可以被子进程继承。
LPSECURITY_ATTRIBUTES lpThreadAttributes, //向一个结构体，这个结构体决定是否返回的句柄可以被子进程继承
BOOL bInheritHandles, //指示新进程是否从调用进程处继承了句柄。为真表示继承
DWORD dwCreationFlags,// 指定附加的、用来控制优先类和进程的创建的标志。
LPVOID lpEnvironment, //指向一个新进程的环境块。如果此参数为空，新进程使用调用进程的环境。
LPCTSTR lpCurrentDirectory, //指向一个以NULL结尾的字符
串，这个字符串用来指定子进程的工作路径。如果这个参数为空，新进程将使用与调用进程相同的驱动器和目录。
LPSTARTUPINFO lpStartupInfo, //指向一个用于决定新进程的主窗体如何显示的STARTUPINFO结构体。
LPPROCESS_INFORMATION lpProcessInformation //指向一个用来接收新进程的识别信息的结构体。
);
WIN32API函数CreateProcess用来创建一个新的进程和它的主线程，这个新进程运行指定的可执行文件。
2. 互斥信号量对象
使用互斥信号量来保证对两个线程间单一数值的访问。每个线程都企图获得控制权来改变该数值，然后将该数值写入输出流中。创建者实际上创建的是互斥信号量对象，计数方法执行等待并释放，为的是共同使用互斥信号量所需的资源（因而也就是共享资源）。
步骤1：在工具栏单击“新建”按钮，编写代码保存为3-2.cpp。 程序功能：利用互斥信号量保护共享资源
参考类与函数：windows.h、iostream、class CCountUpDown、 WaitForCompletion()、DoCount()、ReleaseMutex()、
步骤2：单击“Build”菜单中的“Compile 3-2.cpp”命令，再单击“是”按钮确认，系统对3-2.cpp进行编译。
步骤3：编译完成后，单击“Build”菜单中的“Build 3-2.exe”命令，建立3-2.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：程序能够正常执行。
步骤4：在工具栏单击“Execute program”按钮，执行3-2.exe程序。
请描述运行结果（如果运行不成功，则可能的原因是什么？）：
解：程序主要是在互斥信号量的保证下限制两个线程之间对单一数值的访问。程序中用的信号量是m_nAccess，实现对m_nValue的递减。当信号量是1时实现第一个进程对数据的访问，这时候进程无法访问数据，在第一个进程访问结束之后，释放信号量，这样进程2就可以实现对数据的访问，而进程1则不能继续访问。依次循环，程序结果是：
thread:2068value:1access:50 thread:2320value:0access:49 thread:2068value:1access:48 thread:2320value:0access:47 thread:2068value:1access:46
thread:2320value:0access:45 thread:2068value:1access:44 thread:2320value:0access:43 thread:2068value:1access:42 thread:2320value:0access:41 thread:2068value:1access:40
…………….
thread:2320value:0access:1 thread:2068value:1access:0
3.5 实验总结
本次实验主要涉及的操作是线程的同步，例如互斥信号量容易创建、打开、使用并清除，并利用互斥信号量保证两个进程互斥的访问共享数据。
当一个任务想对临界区访问时，为了防止别的任务也对该临界区操作，它需要对该临界区上锁，这就是互斥信号量的作用。
1）利用CreateMutex()API函数可创建互斥信号量，使用OpenMutex()API函数来获得指向对象的句柄，放弃共享资源时需要在该对象上调用ReleaseMutex()。 2）学习了用于管理事件对象的API利用CreateEvent()函数创建事件，利用OpenEvent函数实现对已经创建对象的访问等。
3）在利用信号量实现两个进程之间互斥的访问数据的试验之中，用单步调试实时跟踪信号量和共享数据的状态。
4）在3-2程序中删除语句:: ReleaseMutex(m_hMutexValue);，即不对信号量进行释放，程序的运行结果就会变为：
这样就会变为只有进程1对共享的数据变量进行访问了， 程序2没有得到机会执行。
将构造函数中的ReleaseMutex(m_hMutexValue);注释之后，即运行到WaitForSingleObject会死锁。程序将不能访问变量了，程序将不会有任何的输出结果。
两个释放信号量的操作都存在的时候就能让两个进程交替的访问共享变量，程序将会输出正确的结果。
3.6 实验评价（教师）
实验4
进程的同步与通信
Windows 2000线程间的通信
(实验估计时间：100分钟)
4.1 背景知识
Windows 2000 提供的线程间通信类内核对象允许同一进程或跨进程的线程之间互相发送信息，包括文件、文件映射、邮件位和命名管道等，其中最常用的是文件和文件映射，这类对象允许一个线程很容易地向同一进程或其他进程中的另一线程发送信息。 1. 文件对象
文件对象是人们所熟悉的永久存储的传统元素。将一个文件看作是内核对象可使开发人员获得比标准C++文件操作更为强大的功能。 内核允许开发人员在系统设备或网络上创建代表永久存储数据块的文件对象。这些文件对象是对永久存储数据的低级访问者；用C++运行库或其他方法打开的所有文件最终都变成对CreateFile()API的调用。
CreateFile()函数分配一个内核对象来代表一个永久的文件，当在磁盘上创建一个新文件或当打开一个已经存在的文件时，就调用这个API，其参数总结见表4-1
表4-1 CreateFile()API参数
参数名 LPCTSTR lpFileName DWORD dwDesiredAccess DWORD dwShareMode lpSecurityAttributes DWORD dwCreationDisposition DWORD dwFlagsAndAttributes HANDLE hTemplateFile 使用目的 要打开或创建的文件名。 所要求的文件访问权；一个包括GENERIC_READ或GENERIC_WRITE的屏蔽。 指定与其他进程共享的文件类型（如果有的话） 性 在文件系统的级别上所采取的操作的类型。如新文件的创建或打开一个已有的文件 文件系统的属性，如只读、隐藏等。还可以是文件对象的属性、如可缓存写入等。 指向另一文件对象的句柄，常用于为新创建的文件提供属性。 LPSECURITY_ATTRIBUTES 当被文件系统支持时与备份文件对象有关的安全
通常可以使用ReadFile()和WriteFile()API在永久存储和应用程序间通过文件对象来移动数据，因为创建调用将对象的大多数复杂性封装起来了，这两个函数只是简单地利用指向要交换数据的文件对象的句柄（即指向内存内的数据缓存区的指针），然后计数移动数据的字节数。除此之外，这两个函数还执行重叠式的输入和输出，由于不会“堵塞”主线程，可用来传送大量的数据。
Createfile()函数除了可访问标准的永久文件外，还可访问控制台输入和输出，以及从命名的管道来的数据。
GetFileType() API指明要处理的关键文件句柄的结构。除此之外，内核还提供了GetFileInformationByHandle()、GetFileSize()和GetFileTime()API用于获得关键数据的详细情况。其它用于在文件中改变数据的工具函数包括Lockfile()、SetFilePoint()和SetEndOfFile() API。 除了这些基于句柄的API之外，内核还提供了大量的工具，用于按文件名对文件直接操作。文件对象用完之后，应该用CloseHandle()API加以清除。 2. 文件映射对象
比使用ReadFile()和WriteFile()API通过文件对象来读取和写入数据更为简单的是，Windows 2000还提供了一种在文件中处理数据的方法，名为内存映射文件，也称为文件映射。文件映射对象是在虚拟内存中分配的永久或临时文件对象区域（如果可能的话、可大到整个文件），可将其看作是二进制的数据块，使用这类对象，可获得直接在内存中访问文件内容的能力。
文件映射对象提供了强大的扫描文件中数据的能力，而不必移动文件指针，对于多线程的读写操作来说，这一点特别有用，因为每个线程都可能想要把读取指针移动到不同的位置——为了防止这种情况，就需要使用某种线程同步机制保护文件。
在CreateFileMapping()API中，一个新的文件映射对象需要有一个永久的文件对象（由CreateFile()所创建）。该函数使用标准的安全性和命名参数，还有用于允许操作（如只读）的保护标志以及大映射的最大容量，随后可根据来自OpenFileMapping()API的其他线程或进程使用该映射——这与事件和互斥信号量的打开进程是非常类似的。
内存映射文件对象的另一个强大的应用是可请求系统创建一个运行映射的临时文件。该临时文件提供一个临时的区域，用于线程或进程互相发送大量数据，而不必创建或保护磁盘上的文件。利用向创建函数中发送INVALID_HANDLE_VALUE来代替真正的文件句柄，就可创建这一临时的内存映射文件；指令内核使用系统页式文件建立支持映射的最大容量的临时数据区。
为了利用文件映射对象，进程必须将对文件的查看映射到它的内存空间中，也就是说，应该将文件映射对象想像为进程的第一步，在这一步中，当查看实际上允许访问的数据时，附加有共享数据的安全性和命名方式。为了获得指向内存区域的指针需要调用MapViewOfFile()API,此调用使用文件映射对象的句柄作为其主要参数。此外还有所需的访问等级（如读-写）和开始查看时文件内的偏移和要查看的容量。该函数返回一个指向进程内的内存的指针，此指针有多种编程方面的应用（但不超过访问权限）。
当结束文件映射查看时，必须用接收到的指针调用UnmapView()OfFile() API，然后再根据映射对象调用CloseHandle()API,从而将其清除。
4.2 实验目的
在本实验中，通过对文件和文件映射对象的了解，来加深对Windows 2000线程同步的理解。
1）回顾系统进程、线程的有关概念，加深对Windows 2000线程间通信的理解。
2）了解文件和文件映射对象。
3）通过实验程序，了解线程如何通过文件对象发送数据。 4）了解在进程中如何使用文件对象。
5） 通过分析实验程序，了解线程如何通过文件映射对象发送数据。
6）了解在进程中如何使用文件映射对象。
4.3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：
1）一台运行Windows 2000 Professional 操作系统的计算机。 2）计算机中需安装Visual C++ 6.0 专业版或企业版。
4.4 实验内容与步骤
1. 文件对象
了解线程如何通过文件对象在永久存储介质上互相发送数据。激活并启动一个线程，接着一个线程创建进程。每个线程从指定的文件中读取数据，数据的增加是以创建时发送给它的数量进行的，然后将
新数值写回文件。
步骤1：登录进入Windows 2000 Professional。 步骤2：在“开始”菜单中单击“程序”、“Microsoft Visual Studio 6.0”“Microsoft Visual C++ 6.0”，进入Visual C++窗口。
步骤3：在工具栏单击“新建”按钮，编写代码保存为4-1.cpp。 功能：演示线程通过文件对象发送数据
参考类和函数：windows.h、iostream、CreateFile(）、ReadFile(）、 WriteFile(）、CloseHandle()、CreateThread(）、WaitForSingleObject()。 步骤4：单击“Build”菜单中的“Compile 4-1.cpp”命令，单击“是”按钮确认，系统对4-1.cpp进行编译。
步骤5：编译完成后，单击“Build”菜单中的“Build4-1.exe”命令，建立4-1.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：程序能够正常运行。
步骤6：在工具栏单击“Execute program”按钮，执行4-1.exe程序。
运行结果（如果运行不成功，原因是什么？）：
阅读和分析4-1的程序，请回答下列问题： 1）使用了哪个系统API函数来创建线程实例？
创建文件函数: HANDLE CreateFile(
LPCTSTR lpFileName, // 文件名
DWORD dwDesiredAccess, // 访问方式 DWORD dwShareMode, // 共享模式
LPSECURITY_ATTRIBUTES lpSecurityAttributes, /设为NULL DWORD dwCreationDisposition, /// 创建方式 DWORD dwFlagsAndAttributes, // 属性 HANDLE hTemplateFile // 无模板文件 );
创建线程实例使用的函数是：CreateThread（）
2）文件的读和写操作分别使用了哪个API函数？ 读取文件：
BOOL ReadFile(
HANDLE hFile, //文件的句柄
LPVOID lpBuffer, //用于保存读入数据的一个缓冲区 DWORD nNumberOfBytesToRead, //要读入的字符数
LPDWORD lpNumberOfBytesRead, //指向实际读取字节数的指针 LPOVERLAPPED lpOverlapped //如文件打开时指定了
FILE_FLAG_OVERLAPPED，那么必须，用这个参数引用一个特殊的结构。该结构定义了一次异步读取操作。否则，应将这个参数设为NULL
);
写入文件： BOOL WriteFile(
HANDLE hFile, // 文件句柄
LPCVOID lpBuffer, // 数据缓存区指针
DWORD nNumberOfBytesToWrite, // 你要写的字节数
LPDWORD lpNumberOfBytesWritten, // 用于保存实际写入字节数的存储区域的指针
LPOVERLAPPED lpOverlapped // OVERLAPPED结构体指针
);
3）在程序中，重置文件使用了哪一个函数？ 使用CloseHandle()函数。
2. 文件映射对象
在线程间使用的由页式文件支持的文件映射对象，从中可以看出利用内存映射文件比使用驻留在磁盘上的文件对象更为简单，其中的进程还使用了互斥信号量，以使公平地访问文件映射对象，然后，当每个线程都释放时，程序将文件的视图映射到文件上并增加数据的值。
步骤1：在工具栏单击“新建”按钮，编写代码保存为4-2.cpp。 实现功能：演示使用映射文件的内存交换数据的线程
参考类与函数：windows.h、iostream、WaitForSingleObject()、MapViewOfFile(）、UnmapViewOfFile()、 ReleaseMutex()、MakeSharedFile()、CreateFileMapping(）、ZeroMemory()。
步骤2：单击“Build”菜单中的“Compile 4-2.cpp”命令，再单击“是”按钮确认，系统对4-2.cpp进行编译。
步骤3：编译完成后，单击“Build”菜单中的“Build 4-2.exe”命令，建立4-2.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：程序能正常运行。但是会出现运行结果错误。
步骤4：在工具栏单击“Execute program”按钮，执行4-2.exe程序。
运行结果（如果不成功，原因是什么？）：
在程序修改之前：输出结果是：
由此可见运行结果出现错误。
修改错误： if (nTotal == 1) {
:: Sleep(1500) ;//添加这一句
std :: cout << \
:: WaitForSingleObject(hThread, INFINITE) ; } 程序修改之后：
按照实验的要求将:: Sleep(500) ; 语句注释之后发现程序执行的过程将会立即出现执行结果，最后显示正确的输出结果。 请回答：
1）程序中用来创建一个文件映射对象的系统API函数是什么？
运用CreateFileMapping()函数
2）在文件映射上创建和关闭文件视图分别使用了哪一个系统函数？
a.创建文件试图：MapViewOfFile（）
b. 关闭文件视图：UnmapViewOfFile（）
3）填空：
通过（CreateFileMapping()）函数创建一个小型的文件映射对象（hMapping），接着，使系统API函数（CreateMutex）再创建一个保护其应用的互斥信号量（g_hMutexMapping）。然后，应用程序创建100个线程，每个都允许进行同样的进程，即：通过互体获得访问权，这个操作是由语句：
g_hMutexMapping = :: CreateMutex(NULL, FALSE, NULL) ; 实现的。再通过函数（MapViewOfFile（））操作将视图映射到文件，将高32位看作有符号整数，将该数值增加（即命令： ++ (* pnData) ; ），再将新数值显示在控制台上，每个线程清除文件的视图并在退出之前释放互斥信号量的语句是： :: UnmapViewOfFile(pFile) ; :: ReleaseMutex(g_hMutexMapping) ;，当线程完成时，应用程序关闭并退出。
4.5 实验总结
1.
首先对于4-1
对于程序中用到的w2kdg.Fileobj.file.data.txt文件，用GetTempPath（）这个函数可以获得系统的临时缓存地址。即：在
2. 3.
认识和熟悉了CreateFileMapping，UnmapViewOfFile，MapViewOfFile等API函数。
对于4-2.cpp，程序创建一个互斥体，这个互斥体不能被继承，不由创建者初始化，没有名字（根据参数决定）。然后创建进程，执行ThreadProc（）函数，等待上一个进程对互斥体的使用完毕，然后创建映射，程序通过映射修改了进程的值，然后输出，然后解除映射，释放互斥体。
4.6 实验评价（教师）
实验5 存储管理
提高Windows 2000内存性能
(实验估计时间：50分钟)
5.1 背景知识
耗尽内存是Windows 2000 系统中最常见的问题之一，当系统耗尽内存时，所有进程对内存的总需求超出了系统的物理内存总量，随后，Windows 2000必须借助它的虚拟内存来维持系统和进程的运行，虚拟内存机制是Windows 2000操作系统的重要组成部分，但它的速度比物理内存慢得多，因此，应该尽量避免耗尽物理内存的资源，以免导致性能下降。
解决内存不足问题的一个有效的方法就是添加更多的内存，但是，一旦提供了更多的内存，Windows 2000很可能会立即“吞食”，而事实上，添加更多的内存并非总是可行的，也可能只是推迟了实际问
题的发生，因此，应该相信，优化所拥有的内存是非常关键的。 1. 分页过程
当Windows 2000求助于硬盘以获得虚拟内存时，这个过程被称为分页（paging），分页就是将信息从主内存移动到磁盘进行临时存储的过程，应用程序将物理内存和虚拟内存视为一个独立的实体，甚至不知道Windows 2000使用了两种内存方案，而认为系统拥有比实际内存更多的内存。例如：系统的内存数量可能只有16MB，但每一个应用程序仍然认为有4GB内存可供使用。
使用分页方案带来了很多好处，不过就是有代价的，当进程需要已经交换到硬盘上的代码或数据时，系统要将数据送回物理内存，并在必要时将其他信息传输到硬盘上，而硬盘与物理内存在性能上的差异很大，例如：硬盘的访问时间通常为4-10ms，而物理内存的访问时间为60us，甚至更快。 2. 内存共享
应用程序经常需要彼此通信和共享信息，为了提高这种能力，Windows 2000必须允许访问某些内存空间而不危及它和其他应用程序的安全性和完整性，从性能的角度来看，共享内存的能力大大减少了应用程序使用的内存数量，运行一个应用程序的多个副本时，每一个实例都可以使用相同的代码和数据，这意味着不必维护所加载应用程序代码的单独副本并使用相同的内存资源，无论正在进行多少个应用程序实例，充分支持应用程序代码所需求的内存数量都相对保持不变。 3）未分页合并内存与分页合并内存
Windows 2000决定了系统内存组件哪些可以以及哪些不可以交换到磁盘上，显然，不应该将某些代码（例如内核）交换出主内存，因此，Windows 2000将系统使用的内存进一步划分为未分页合并内存和分页合并内存。
分页合并内是存储迟早需要的可分页代码或数据的内存部分，虽然可以将分页合并内存中的任何系统进程交换到磁盘上，但是它临时存储在主内存的这一部分，以防系统立刻需要它，在将系统进程交换到磁盘上之前，Windows 2000会交换其他进程。
未分页合并内存包含必须驻留在内存中的占用代码或数据，这种结构类似于早期MS-DOS程序使用的结构，在MS-DOS中，相对较小的终止、驻留程序在启时加载到内存中，这些程序在系统重新启动或关闭之前一直驻留在内存的特定部分中，例如，防病毒程序将加载为TSR程序，以预防可能的病毒袭击。
未分页合并内存中包含的进程留在主内存中，并且不能交换到磁盘上，物理内存的这个部分用于内核模式操作（例如：驱动程序）和必须保留在主内存中才能有效工作的其他进程，没有主内存的这个部
分，内核组件就是可分页的，系统本身就有变得不稳定的危险。
分配到未分页内存池的主内存数量取决于服务器拥有的物理内存数量以及进程对系统上的内存空间的需求，不过，Windows 2000将未分页合并内存限制为256MB（在Windows NT4中限制为128MB），根据系统中物理内存数量，复杂的算法在启动时动态确定Windows 2000系统上的未分页合并内存的最大数量，Windows 2000内部的这一自我调节机制可以根据当前的内存配置自动调整大小，例如：如果增加或减少系统中的内存数量，那么Windows 2000将自动调整未分合并内存的大小，以反映这一更改。 4）提高分页性能
只有一个物理硬盘驱动器的系统限制了优化分页性能的能力，驱动器必须处理系统和应用程序的请求以及对分页文件的访问，虽然物理驱动器可能有多个分区，但是将分页文件分布到多个分区的分页文件并不能提高硬盘驱动器的能力。只有当一个分区没有足够的空间来包含整个分页文件时，才将分页文件放在同一个硬盘的多个分区上。 拥有多个物理驱动器的服务器可以使用多个分页文件来提高分页性能，关键是将分页请求的负载分布到多个物理硬盘上，实际上，使用独立物理驱动器上的分页文件，系统可以同时处理多个分页请求，各个物理驱动器可以同时访问它自己的分页文件并写入信息，这将增加可以传输的信息量，多个分页文件的最佳配置是将各个分页文件放在拥有自己的控制器的独立驱动器上，不过，由于额外的费用并且系统上的可用中断很有限，因此对于大多数基于服务器的配置来说，这可能是不切实际的解决方案。
分页文件最重要的配置参数是大小，无论系统中有多少个分页文件，如果它们的大小不合适，那么系统就可能遇到性能问题。
如果初始值太小，那么系统可能必须扩大分页文件，以补偿额外的分页活动。当系统临时增加分页文件时，它必须在处理分页请求的同时创建新的空间，这时，系统将出现大量的页面错误，甚至可能出现系统失效，当系统必须在进程的工作区外部（在物理内存或分页文件中的其他位置）查找信息时，就会出现页面错误。当系统缺乏存储资源（物理内存及虚拟内存）来满足使用需求，从而遇到过多的分页时，就会出现系统失效，系统将花更多的时间来分页而不是执行应用程序。当系统失效时，Memory:Page/see计数器将持续高于每秒100页，系统失效大大降低了系统的性能，此外，动态扩展分页文件将导致碎片化，分页文件将散布在整个磁盘上而不是在启动时的连续空间中创建，从而增加了系统的开销，使系统性能降低，因此，应该尽量避免系统增加分页文件的大小。
提示：在NTFS驱动器上，总是至少保留25%的空闲驱动器空间，
以确保可以在连续的空间中创建分页文件。
在Windows 2000使用内存数量的1.5倍作为分页文件的最小容量，这个最小容量的两倍作为最大容量。它减少了系统因为错误配置的分页文件而崩溃的可能性，系统在崩溃之后能够将内存转储写入磁盘，所以系统分区必须有一个至少等于物理内存数量加上1的分页文件。
5.2 实验目的
通过对Windows 2000“任务管理器”、“计算机管理”、“我的电脑”属性、“系统信息”、“系统监视器”等程序的应用，学习提高Windows内存的性能，加深理解Windows操作系统的内存管理功能，理解操作系统存储管理、虚拟存储管理的知识。
5.3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：
需要一台运行Windows 2000 Professional 操作系统的计算机。
5.4 实验内容与步骤
判断和维护Windows 2000的内存性能有许多方法。 步骤1：阅读背景知识，请回答： 1）什么是分页过程？
解：分页是指计算机操作系统借助硬盘获得虚拟的内存空间的过程，操作系统将内存中的一部分暂时不会用到或者说已经很长时间没用到的信息转移到硬盘上进行临时存储。但是对于用户角度来说，应用程序将物理内存和虚拟内存视为一个独立的实体，这样就解决了内存过小导致的系统速度变慢的问题，一定程度上提高了系统的性能。
2）什么是内存共享
解：共享内存就是多个进程可以把一段内存映射到自己的进程空间，以此来实现数据的共享以及传输，这也是所有进程间通信方式中最快的一种。共享内存是存在于内核级别的一种资源。
在系统内核为一个进程分配内存地址时，通过分页机制可以让一个进程的物理地址不连续，同时也可以让一段内存同时分配给不同的进程。共享内存机制就是通过该原理来实现的，共享内存机制只是提供数据的传送，如何控制服务器端和客户端的读写操作互斥，这就需要一些其他的辅助工具。
3）什么是未分页合并内存和分页合并内存
Windows 2000中，未分页合并内存的最大限制是多少？
解：分页合并内是存储迟早需要的可分页代码或数据的内存部分。
未分页合并内存包含必须驻留在内存中的占用代码或数据，未分页合并内存中包含的进程留在主内存中，并且不能交换到磁盘上，物理内存的这个部分用于内核模式操作。
Windows 2000将未分页合并内存限制为256MB，Windows 2000内部的这一自我调节机制可以根据当前的内存配置自动调整大小。
4）Windows 2000分页文件默认设置的最小容量和最大容量是多少？
解：在Windows 2000使用内存数量的1.5倍作为分页文件的最小容量，这个最小容量的两倍作为最大容量。 步骤2：登录进入Windows 2000。
步骤3：查看包含多个实例的应用程序的内存需求。 1）启动想要监视的应用程序，例如：WORD。 2）右键单击任务栏以启动“任务管理器”。
3）在“Windows任务管理器”对话框中选定“进程”选项卡。 4）向下滚动在系统上运行的进程列表，查找想要监视的应用程序。请在表5-1中记录：
表5-1 实验记录
映像名称 WINWORD.EXE PID 1508 CPU 01 CP时间 0:00:34 内存使用 34328K “内存使用”列显示了该应用程序的一个实例正在使用的内存数量。
5）启动应用程序的另一个实例并观察他的内存需求。
请描述使用第二个实例占用的内存与使用第一个实例时的内存对比情况： 监视的第二个实例如下： 对比Chrome浏览器和word程序可知，浏览器占用的内存比较大，而且每打开一个浏览器标签页面，chrome浏览器的内存占用会增加。
步骤4：未分页合并内存。
估算未分页合并内存大小的最简单方法是使用“任务管理器”。未分页合并内存的估计值显示在“任务管理器”的“性能”选项卡的“核心内存”部分。 总数（K）：47706 分页数：37428 未分页（K）：10228
还可以使用“任务管理器”查看一个独立进程正在使用的未分页合并内存数量和分页合并内存数量。操作步骤如下：
1）单击“Windows任务管理器”的“进程”选项卡，然后从“查看”菜单中选择“选择列”，显示“进程”选项卡的可查看选项。 2）在“选择列”对话框中，选定“页面缓冲池”选项和“非页面缓冲池”选项旁边的复选框，然后单击“确定”按钮。
返回Windows 2000“任务管理器”的“进程”选项卡时，将看到其中增加显示了各个进程占用的分页合并内存数量和未分页合并内存数量。
仍以刚才打开观察的应用程序（例如：Word）为例，请在表5-2中记录。
表5-2 实验记录
映像名称 PID 内存使用 页面缓冲池 非页面缓冲池 WINWORD.EXE 1508 45444k 805k 22k 从性能的角度来看，未分页合并内存越多，可以加载到这个空间的数据就越多，拥有的物理内存越多，未分页合并内存就越多，但未分页合并内存被限制为256MB，因此添加超出这个限制的内存对未分页合并内存没有影响。
步骤5：提高分页性能。
在Windows 2000的安装过程中，将使用连续的磁盘空间自动创建分页文件（pagefile.sys）。用户可以事先监视变化的内存需求并正确配置分页文件，使得当系统必须借助于分页时的性能达到最高。
虽然分页文件一般都放在系统分区的根目录下面，但这并不总是该文件的最佳位置，要想从分页获得最佳性能，应该首先检查系统的磁盘子系统的配置，以了解它是否有多个物理硬盘驱动器。 1）在“开始”菜单中单击“设置”、“控制面板”，双击“管理工具”图标，再双击“计算机管理”图标。
2）在“计算机管理”窗口的左格选择“磁盘管理”管理单元来
查看系统的磁盘配置。
请在表5-3中记录有关实验记录
表5-3 实验记录
卷 C MS-DOS 布局 磁盘分区 磁盘分区 基本 FAT 类型 基本 文件系统 NTFS 容量 76.50G 737M 良好 状态 良好
如果系统只有一个硬盘，那么建议尽可能为系统配置额外的驱动器，这是因为Windows 2000最多可以支持在多个驱动器上分布的16个独立的分页文件，为系统配置多个分页文件可以实现对不同磁盘I/O请求的并行处理，这将大大提高I/O请求的分页文件性能。 步骤6：计算分页文件的大小。
要想更改分页文件的位置或大小配置参数，可按以下步骤进行： 1）右键单击桌面上的“我的电脑”图标并选定“属性”。 2）在“高级”选项卡上单击“性能选项”按钮。
3）单击对话框中的“虚拟内存”区域中的“更改”按钮。 请记录：
所选驱动器（C：）的页面文件大小：2046-4092 驱动器：C:
可用空间（MB）：66537 初始大小（MB）：2046 最大值（MB）：4096 所选驱动器（D：）的页面文件大小：（如果有的话） 驱动器：
可用空间（MB）： 初始大小（MB）： 最大值（MB）：
所有驱动器页面文件大小的总数： 允许的最小值（MB）：2MB 推荐（MB）：3031 当前已分配（MB）：2046
4）要想将另一个分页文件添加到现有的配置，在“虚拟内存”对话框中选定一个还没有分页文件的驱动器，然后指定分页文件的初始值和最大值（以兆字节表示），单击“设置”，然后单击“确定”按钮。 5）要想更改现有分页文件的最大值和最小值，可选定分页文件所
在的驱动器，然后指定分页文件的初始值和最大值，单击“设置”按钮，然后单击“确定”按钮。
6）在“性能选项”对话框中单击“确定”按钮。 7）单击“确定”按钮以关闭“系统特性”对话框。 步骤7：使用任务管理器。
可以使用“任务管理器”来简单地检查分页文件是否配置了正确的容量，这样可以实时提供系统正在使用分页文件的方式以及其他重要系统信息的准确描述。
通过右键单击任务栏运行“任务管理器”，选定“性能”选项卡查看实时的系统统计数据。与分页文件大小最有关的信息位于“认可用量”区域，这一区域显示了认可“峰值”是否达到或超过了认可“限制”，以及它是否超过了系统上的物理内存数量。认可“峰值”是指系统迄今为止向进程分配的最大物理内存和虚拟内存数量。 请记录：
物理内存（KB） 总数：2069736 可用数：1627472 系统缓存：359184 认可用量（KB） 总数：355584 限制：4008364 峰值：633180
当系统遇到分页活动增加的情况时，提交的内存数量（“认可总数”）就会增加。一旦它达到了“认可限制”值，系统就需要扩展分页文件，“认可限制”值指出在不必扩展分页文件的情况下可以向内存提交的虚拟内存数量，因为目标是避免扩展分页文件，所以必须保持“认可总数”和“认可限制”值相差较大。如果这两个值接近了，那么系统必须动态增加分页文件的大小。
“任务管理器”的“认可用量”区域显示的信息还说明了系统的主内存是否足以满足系统执行的任务，如果认可“总数”值经常超过系统中的内存数量，那么系统的物理内存可能不足。
5.5 实验总结
1.
加深了对于分页过程，内存共享，分页合并内存，未分页合并内存和虚拟内存的认识，操作系统在实际的物理内存空间不足或者是当前的系统负载过大的时候会将物理内存中的一部分在将来一段时间内不会用到的信息转移到硬盘上去，占用的这部分硬盘空间就是虚拟内存，然后虚拟内存和实际的物理内存成为了一个不可分割的整体，操作系统通过高效的页面置换算法不断的将内存中暂时用不到的数据信息转移到硬盘
上，将虚拟内存中用到的信息载入到内存中，这样从用户的角度来看，计算机的内存变大了，系统的性能也相应的得到了提高。 2. 3.
学会监视系统进程所占用的资源，并在计算机管理中配置虚拟内存的大小。
在系统属性中的性能选项卡中还可以设置系统的显示效果
下面还包含了一些详细的设置项等，用户可以自己设置系统的显示效果。
5.6 实验评价（教师）
实验6 存储管理
Windows 2000内存结构
(实验估计时间：100分钟)
6.1 背景知识
Windows 2000 是32位的操作系统，它使计算机CPU可以用32位地址对32位内存块进行操作，内存中的每一个字节都可以用一个32位的指针来寻址，这样，最大的存储空间就是232字节或4000兆字节（4GB），在Windows下运动的每一个应用程序都认为能独立可用的4GB大小的空间。
而另一方面，实际上没有几台机器的RAM能达到4GB，更不必说让每个进程都独享4GB内存了，显然，Windows在幕后将虚拟内存（virtual memory，VM）地址映射到了各进程的物理内存地址上，而所谓物理内存是指计算机的RAM和由Windows分配到用户驱动器根目录上的换页文件，物理内存完全由系统管理。
6.2 实验目的
1）通过实验了解Windows 2000内存的使用，学习如何在应用程序中管理内存、体会Windows应用程序内存的简单性和自我防护能力。 2）了解Windows 2000内存结构和虚拟内存的管理，进而了解进程堆和Windows为使用内存而提供的一些扩展功能。
6.3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：
1）一台运行Windows 2000 Professional 操作系统的计算机。 2）计算机中需安装Visual C++ 6.0 专业版或企业版。
6.4 实验内容与步骤
Windows提供了一个API，即GetSystemInfo(),以便用户能检查系统中虚拟内存的一些特性。
步骤1：登录进入Windows 2000 Professional。 步骤2：在“开始”菜单中单击“程序”、“Microsoft Visual Studio 6.0”“Microsoft Visual C++ 6.0”，进入Visual C++窗口。
步骤3：在工具栏单击“新建”按钮，编写程序保存为6-1.cpp。 程序功能：获取有关系统的内存设置的信息
参考头文件与函数：windows.h、iostream、shlwapi.h、iomanip ZeroMemory()、GetSystemInfo()、StrFormatByteSize()、 StrFormatByteSize()、 步骤4：编译6-1.cpp。
步骤5：编译完成后，单击“Build”菜单中的“Build 6-1.exe”命令，建立6-1.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：操作能够正确执行。
步骤6：在工具栏单击“Execute program”按钮，执行6-1.exe程序。
运行结果（如果运行不成功，原因是什么？）： 1）虚拟内存每页容量为：4.00KB 2）最小应用地址：0x00010000 3）最大应用地址：0x7ffeffff
4）当前可供应用程序使用的内存空间为：1.99GB 5）当前计算机的实际内存大小为：1.97GB
请回答问题：
1）理论上每个Windows应用程序可以独占的最大存储空间是： 理论上Windows下每一个应用程序最大可以独占的内存空间是4GB。
2）用于检查系统中虚拟内存特性的API函数是：GetSystemInfo()
6.5 实验总结
1.
在实际的32位计算机中系统只能支持4GB的内存空间，但是当用户实
际安装的物理内存大于4GB的时候，一部分内存就不会被系统识别，造成资源浪费。解决这种情况的方案很多，一种是将操作系统换成64位的。另一种就是借助工具软件实现对于大容量内存的突破。
2. 函数原型：
VOID GetSystemInfo ( ); 参数表： lpSystemInfo
wProcessorArchitecture: Word; {处理器的体系结构} wReserved: Word; {保留}
dwPageSize: DWORD; {分页大小}
lpMinimumApplicationAddress: Pointer;{最小寻址空间} lpMaximumApplicationAddress: Pointer;{最大寻址空间}
dwActiveProcessorMask: DWORD; {处理器掩码; 0..31 表示不同的处理器} dwNumberOfProcessors: DWORD; {处理器数目} dwProcessorType: DWORD; {处理器类型}
dwAllocationGranularity: DWORD; {虚拟内存空间的粒度} wProcessorLevel: Word; {处理器等级} wProcessorRevision: Word); {处理器版本}
LPSYSTEM_INFO lpSystemInfo
6.6 实验评价（教师）
实验7
存储管理
Windows 2000虚拟内存
(实验估计时间：120分钟)
7.1 背景知识
在Windows 2000 环境下，4GB的虚拟址空间被划分成两个部分：低端2GB提供给进程使用，高端2GB提供给系统使用。这意味着用户的应用程序代码，包括DLL以及进程使用的各种数据等，都装在用户进程地址空间内（低端2GB），用户过程的虚拟地址空间也被分成三个部分：
1）虚拟内存的已调配区（committed）：具有备用的物理内存，根据该区域设定的访问权限，用户可以进行写、读或在其中执行程序等操作。
2）虚拟内存的保留区（researved）：没有备用的物理内存，但有一定的访问权限。
3）虚拟内存的自由区（free）：不限定其用途，有相应的PAGE_NOAC_CESS权限。
与虚拟内存区相关的访问权限告知系弘进程可在内存中进行何种类型的操作。例如：用户不能在只有PAGE_READONLY权限的区域上进行写操作或执行程序：也不能在只有PAGE_EXECUTE权限的区域里进行读、写操作。而具有PAGE_NOACESS权限的特殊区域，则意味着不允许进程对其地址进行任何操作。
在进程装入之前，整个虚拟内存的地址空间都被设置为只有PAGE_NOACESS权限的自由区域。当系统装入进程代码和数据后，才将内存地址的空间标记为已调配区或保留区，并将诸如EXECUTE、READWRITE和READONLY的权限与这些区域相关联。 如表7-1所示，给出了MEMORY_BASIC_INFORMATION的结构，此数据描述了进程虚拟内存空间中一组虚拟内存页面的当前状态，其中State项表明这些区域是否为自由区、已调配区或保留区；Protect项则包含了Windows系统为这些区域添加了何种访问保护；Type项则表明这些区域是可执行图像、内存映射文件还是简单的私有内存，VirtualQueryEX()API能让用户在指定的进程中，对虚拟内存地址的大小和属性进行检测。
Windows还提供了一整套能使用户精确控制应用程序的虚拟地址空间API，一些用于虚拟内存操作及检测的API如表7-2所示。
表7-1 MEMORY_BASIC_INFORMATION结构的成员
成员名称 PVOID BaseAddress 虚拟内存开始处的指针 PVOID AllocationBase DWORD AllocationProtect 如果这个特定的区域为子分配区的话，则为虚拟内存外面区域的指针；否则此值与BaseAddress相同 虚拟内存最初分配区域的保护属性。其可能值包括： PAGE_NOACESS,PAGE_READONLY,PAGE_READWRITTE和目的 PAGE_EXECUTE_READ。 DWORD RegionSize 虚拟内存区域的字节数 DWORD State DWORD Protect DWORD Type 区域的当前分配状态，其可能值为MEM_COMMIT,MEM_FREE和MEM_RESERVE 虚拟内存当前区域的保护属性，可能值与AllocationProtect成员相同 虚拟内存区域中出现的页面类型，可能值为MEM_IMAGE，MEM_MAPPED和MEM_PRIVATE
表7-2 虚拟内存的API
API名称 VirtualQueryEx() VirtualAlloc() VirtualFree() VirtualProtect() VirtualLock() VirtualUnlock() 拟内存的区域 保留或调配进程的部分虚拟内存，设置分配和保护标志 释放或收回应用程序使用的部分虚拟地址 改变虚拟内存区域保护规范 防止系统将虚拟内存区域通过系统交换到页面文件中 释放虚拟内存的锁定区域，必要时，允许系统将其交换到页面文件中 描 述 通过填充MEMORY_BASIC_INFORMATION结构检测进程内虚 提供虚拟内存分配功能的是VirtualAlloc()API，该API支持用户向系统要求新的虚拟内存或改变已分配内存的当前状态，用户若想通过VirtualAlloc()API函数使用虚拟内存，可以采用两种方式能知系统： 1）简单地将内存内容保存在地址空间内。
2）请求系统返回带有物理存储区（RAM的空间或换页文件）的部分地址空间。
用户可以用flAllocation Type参数（ commit和reserve）来定义这些方式，用户可以通知Windows按只读、读写、不可读写、执行或特殊方式来处理新的虚拟内存。
与VirtualAlloc()函数对应的是VirtualFree()函数，其作用是释放虚拟内存中的已调配页或保留页。用户可利用dwFree Type参数将已调配页修改成保留页属性。
VirtualProtect()是VirtualAlloc()的一个辅助函数，利用它可以改变虚拟内存的保护规范。
7.2 实验目的
1）通过实验了解Windows 2000内存的使用，学习如何在应用程序中管理内存、体会Windows应用程序内存的简单性和自我防护能力。 2）学习检查虚拟内存空间或对其进行操作
3）了解Windows 2000内存结构和虚拟内存的管理，进而了解进程堆和Windows为使用内存而提供的一些扩展功能。
7.3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：
1）一台运行Windows 2000 Professional 操作系统的计算机。 2）计算机中需安装Visual C++ 6.0 专业版或企业版。
7.4 实验内容与步骤
1. 虚拟内存的检测
使用VirtualQueryEX()函数来检查虚拟内存空间。 步骤1：登录进入Windows 2000 Professional。 步骤2：在“开始”菜单中单击“程序”、“Microsoft Visual Studio 6.0”“Microsoft Visual C++ 6.0”，进入Visual C++窗口。
步骤3：在工具栏单击“新建”按钮，编写代码保存为7-1.cpp。 功能：检测进程的虚拟地址空间
参考头文件与函数：windows.h、iostream、shlwapi.h、iomanip、 WalkVM（）、ZeroMemory()、GetSystemInfo(&si)、StrFormatByteSize()、 VirtualQueryEx()API
步骤4：单击“Build”菜单中的“Compile 7-1.cpp”命令，单击“是”按钮确认，系统对7-1.cpp进行编译。
步骤5：编译完成后，单击“Build”菜单中的“Build 7-1.exe”命令，建立7-1.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：操作能正常进行。
步骤6：在工具栏单击“Execute program”按钮，执行7-1.exe程序。
运行结果（如果运行不成功，原因是什么？）：
按committed、reserved、free等三种虚拟地址空间分别记录实验数据，其中“描述”是指对该组数据的简单描述，例如：对下列一组数据：
00010000-00012000<8.00KB>Committed,READWRITE,Private可描
述为：具有READWRITE权限的已调配私有内存区。
将系统当前的自由区（free）虚拟地址空间填入表7-3中。
表7-3 实验记录 地址 00012000-00020000 00021000-00030000 00133000-00140000 00276000-00280000 002bd000-002c0000 00301000-00310000 00316000-00320000 00361000-00370000 00391000-003a0000 003a1000-003b0000 003b3000-003c0000 00485000-00490000 00558000-00560000 00663000-00670000 00a70000-62c20000 7400b000-76300000 7631d000-77be0000 77d9f000-77da0000 77e49000-77e50000 77ee2000-77ef0000 77f38000-77f40000 77fb6000-77fc0000 77fd1000-7c800000 7c91d000-7c920000 7c9b4000-7f6f0000 7f7f0000-7ffa0000 7ffd3000-7ffdb000 7ffdc000-7ffdf000 003d0000-00400000 62c29000-73fa0000 77c38000-77d10000 大小 (56.0 KB) (60.0 KB) (52.0 KB) (40.0 KB) (12.0 KB) (60.0 KB) (40.0 KB) (60.0 KB) (60.0 KB) (60.0 KB) (52.0 KB) (44.0 KB) (32.0 KB) (52.0 KB) (1.53 GB) (34.9 MB) (24.7 MB) (4.00 KB) (28.0 KB) (56.0 KB) (32.0 KB) (40.0 KB) (72.1 MB) (12.0 KB) (45.2 MB) (7.68 MB) (32.0 KB) (12.0 KB) (192 KB) (275 MB) (864 KB) 虚拟地址空间 Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free Free 访问权限 描述 NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS NOACCESS 将系统当前的已调配区（committed）虚拟地址空间填入表7-4中
表7-4 实验记录
地址 大小 虚拟地址空间 访问权限 EXECUTE_READ Image EXECUTE_READ Image EXECUTE_READ Image EXECUTE_READ Mapped EXECUTE_READ Mapped EXECUTE_READ Mapped GUARD, READW Private READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY READONLY Image Image Image Image Image Image Image Image Image Image Image 描述 62c21000-62c26000 (20.0 KB) Committed 76301000-76316000 (84.0 KB) Committed 77fc1000-77fce000 (52.0 KB) Committed 00490000-00496000 (24.0 KB) Committed 00550000-00552000 (8.00 KB) Committed 7f6f0000-7f6f7000 (28.0 KB) Committed 0012c000-0012d000 (4.00 KB) Committed 00470000-00478000 (32.0 KB) Committed 00481000-00485000 (16.0 KB) Committed 62c27000-62c29000 (8.00 KB) Committed 73ff5000-7400b000 (88.0 KB) Committed 76317000-7631d000 (24.0 KB) Committed 77c34000-77c38000 (16.0 KB) Committed 77edc000-77ee2000 (24.0 KB) Committed 77f35000-77f38000 (12.0 KB) Committed 77fae000-77fb6000 (32.0 KB) Committed 77fcf000-77fd1000 (8.00 KB) Committed 7c9a1000-7c9b4000 (76.0 KB) Committed 00400000-00401000 (4.00 KB) Committed 77da0000-77da1000 (4.00 KB) Committed 77ef0000-77ef1000 (4.00 KB) Committed 76300000-76301000 (4.00 KB) Committed 7c800000-7c801000 (4.00 KB) Committed 62c20000-62c21000 (4.00 KB) Committed 77be0000-77be1000 (4.00 KB) Committed 7c920000-7c921000 (4.00 KB) Committed 77e50000-77e51000 (4.00 KB) Committed 77fc0000-77fc1000 (4.00 KB) Committed 77f40000-77f41000 (4.00 KB) Committed 77d10000-77d11000 (4.00 KB) Committed 73fa0000-73fa1000 (4.00 KB) Committed 00130000-00133000 (12.0 KB) Committed 00260000-00276000 (88.0 KB) Committed Image, Module: 7-1.exe Image, Module: ADVAPI32.dll Image, Module: GDI32.dll Image, Module: IMM32.DLL Image, Module: kernel32.dll Image, Module: LPK.DLL Image, Module: msvcrt.dll Image, Module: ntdll.dll Image, Module: RPCRT4.dll Image, Module: Secur32.dll Image, Module: SHLWAPI.dll Image, Module: USER32.dll Image, Module: USP10.dll Mapped Mapped 00310000-00316000 (24.0 KB) Committed 003b0000-003b3000 (12.0 KB) Committed 00560000-00663000 (1.01 MB) Committed 7ffe0000-7ffe1000 (4.00 KB) Committed 00478000-0047b000 (12.0 KB) Committed 0047d000-00481000 (16.0 KB) Committed 62c26000-62c27000 (4.00 KB) Committed 73fef000-73ff1000 (8.00 KB) Committed 73ff4000-73ff5000 (4.00 KB) Committed 76316000-76317000 (4.00 KB) Committed 77c2f000-77c30000 (4.00 KB) Committed 77c31000-77c34000 (12.0 KB) Committed 77d70000-77d71000 (4.00 KB) Committed 77e16000-77e17000 (4.00 KB) Committed 77edb000-77edc000 (4.00 KB) Committed 77f34000-77f35000 (4.00 KB) Committed 77fad000-77fae000 (4.00 KB) Committed 77fce000-77fcf000 (4.00 KB) Committed 7c884000-7c887000 (12.0 KB) Committed 7c99c000-7c99f000 (12.0 KB) Committed 00250000-00253000 (12.0 KB) Committed 00010000-00012000 (8.00 KB) Committed 00020000-00021000 (4.00 KB) Committed 0012d000-00130000 (12.0 KB) Committed 00140000-00145000 (20.0 KB) Committed 00240000-00246000 (24.0 KB) Committed 00370000-00378000 (32.0 KB) Committed 00380000-00388000 (32.0 KB) Committed 00390000-00391000 (4.00 KB) Committed 003a0000-003a1000 (4.00 KB) Committed 003c0000-003c3000 (12.0 KB) Committed 00970000-00978000 (32.0 KB) Committed 7ffdb000-7ffdc000 (4.00 KB) Committed 7ffdf000-7ffe0000 (4.00 KB) Committed 0047b000-0047d000 (8.00 KB) Committed 73fe5000-73fef000 (40.0 KB) Committed READONLY READONLY READONLY READONLY READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE READWRITE WRITECOPY WRITECOPY Mapped Mapped Mapped Private Image Image Image Image Image Image Image Image Image Image Image Image Image Image Image Image Mapped Private Private Private Private Private Private Private Private Private Private Private Private Private Image Image 73ff1000-73ff4000 (12.0 KB) Committed 77c2d000-77c2f000 (8.00 KB) Committed 77c30000-77c31000 (4.00 KB) Committed 77d71000-77d72000 (4.00 KB) Committed 77e17000-77e1b000 (16.0 KB) Committed 7c887000-7c889000 (8.00 KB) Committed 7c99f000-7c9a1000 (8.00 KB) Committed 00401000-00470000 (444 KB) 73fa1000-73fe5000 (272 KB) 77be1000-77c2d000 (304 KB) 77d11000-77d70000 (380 KB) 77da1000-77e16000 (468 KB) 77e51000-77edb000 (552 KB) 77ef1000-77f34000 (268 KB) 77f41000-77fad000 (432 KB) 7c801000-7c884000 (524 KB) 7c921000-7c99c000 (492 KB) 00670000-00705000 (596 KB) 77d72000-77d9f000 (180 KB) 77e1b000-77e49000 (184 KB) 7c889000-7c91d000 (592 KB) 00280000-002bd000 (244 KB) 002c0000-00301000 (260 KB) 00320000-00361000 (260 KB) 7ffa0000-7ffd3000 (204 KB) Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed Committed WRITECOPY WRITECOPY WRITECOPY WRITECOPY WRITECOPY WRITECOPY WRITECOPY EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ EXECUTE_READ READONLY READONLY READONLY READONLY READONLY READONLY READONLY Image Image Image Image Image Image Image Image Image Image Image Image Image Image Image Image Image Mapped Image Image Image Mapped Mapped Mapped Mapped
将系统当前的保留区（reserved）虚拟地址空间填入表5-8中
表7-5 实验记录
地址 大小 虚拟地址空间 访问权限 描述 7ffe1000-7fff0000 (60.0 KB) Reserved 00253000-00260000 (52.0 KB) Reserved 00552000-00558000 (24.0 KB) Reserved 00705000-00970000 (2.41 MB) Reserved 00030000-0012c000 (0.98 MB) Reserved 00145000-00240000 (0.98 MB) Reserved NOACCESS Private READONLY Mapped READONLY Mapped READONLY Mapped READONLY Private READONLY Private 00246000-00250000 (40.0 KB) Reserved 00378000-00380000 (32.0 KB) Reserved 00388000-00390000 (32.0 KB) Reserved 003c3000-003d0000 (52.0 KB) Reserved 00496000-00550000 (744 KB) 7f6f7000-7f7f0000 (996 KB) 00978000-00a70000 (992 KB) Reserved Reserved Reserved READONLY Private READONLY Private READONLY Private READONLY Private READONLY Mapped READONLY Mapped READONLY Private 2. 虚拟内存操作
如何分配一个大容量空间，将物理存储委托给其中的很小一部分（千分之一）并加以使用。
步骤1：在工具栏单击“新建”按钮，编写代码并保存为7-2.cpp。 功能：分配和使用大块内存
参考头文件与函数：windows.h、iostream、FillZero()、malloc()、FillZero ()、free()、VirtualAlloc()、VirtualFree()、 ;
步骤2：单击“Build”菜单中的“Compile7-2.cpp”命令，单击“是”按钮确认，系统对7-2.cpp进行编译。
步骤5：编译完成后，单击“Build”菜单中的“Build 7-2.exe”命令，建立7-2.exe可执行文件。
操作能否正常进行，如果不行，原因是什么？ 解：操作能够正常进行。
步骤6：在工具栏单击“Execute program”按钮，执行7-2.exe程序。
运行结果（如果运行不成功，原因是什么？）： 解：结果是：
7.5 实验总结
1.
实验中的函数
1：LPVOID VirtualAlloc(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flAllocationType, DWORD flProtect
);
lpAddress是指定内存开始的地址。 dwSize是分配内存的大小。 flAllocationType是分配内存的类型。 flProtect是访问这块分配内存的权限。
2：BOOL VirtualFree(
LPVOID lpAddress, // 区域地址
SIZE_T dwSize, // 区域大小，字节
DWORD dwFreeType // 类型 );
VirtualProtect()是VirtualAlloc()的一个辅助函数，利用它可以改变虚拟内存的保护规范。 2.
_try与_except(EXCEPTION_EXECUTE_HANDLER)时异常处理的函数。 3.
移位30位就是1GB 移位20位就是1MB
4．FileZero（）可以把一段地址赋为全0。
7.6 实验评价（教师）
实验8 文件系统
优化Windows 2000磁盘子系统
（估计时间：100分钟)
8.1 背景知识
1. 选择文件系统
文件系统决定了操作系统能够对磁盘进行的处理，Windows 2000支持的文件系统主要有：
1）文件分配表（File Allocation Table,FAT）文件系统（FAT16）。 2）保护模式FAT文件系统（FAT32）。 3）Windows NT文件系统（NTFS）。
FAT文件系统是早期文件系统之一，也是MS-DOS使用的原始文件系统。它将文件信息储存在位于卷标开头处的文件分配表中，并保
存两份文件分配表，以防其中的一个遭到破坏。 FAT文件系统最大的优点是MS-DOS、Windows 9x甚至OS/2都能访问的FAT卷标；而其最大的弱点是随着FAT卷标尺寸的增长，最小的簇尺寸也随之增长，对于大于512MB的硬盘而言，最小的簇尺寸为16KB；对于大于2GB的硬盘，最小的簇尺寸为64KB，这就导致了磁盘空间的极大浪费，因为一个文件必须占用整数个簇，因此，1KB的文件在2GB的硬盘上将占用64KB的磁盘空间，FAT文件系统不支持尺寸大于4GB的卷标。
FAT32文件系统通过提供长文件名的支持来扩展FAT文件系统，并与FAT16兼容，FAT（16和32）文件系统是支持可移动媒体（例如软盘）上的唯一的文件系统。
Windows NT文件系统（NTFS）包括了FAT文件系统的所有功能，同时又提供了对高级文件系统特征（例如安全模式、压缩和加密）的支持，它是为在大磁盘上有效地完成文件操作而设计的，与FAT和保护模式FAT文件系统不同，它的最小簇尺寸不超过4KB，但是，NTFS卷标只能为Windows NT、2000和XP操作系统所访问。
Windows 2000提供的新特征（NTFS 5.0）使文件系统更安全、更可靠，比以往的Windows版本更好地支持分布式计算。 此外，Windows 2000支持的文件系统还有：
CDFS：光盘文件系统（compact disc file system）用于光盘的文件存储。
UDF：通过磁盘格式（universal disk format）用于DVD的文件存储。
在文件系统中，FAT16、FAT32和NTFS这三个文件系统对磁盘子系统的性能影响最大，而事实上，选择NTFS之外的任何文件系统都只有两个理由，即：
1）可双引导系统。 2）小于400MB的卷。
如果系统不是这两种情况，那么NTFS就应该是所选择的文件系统，NTFS将提供更好的性能、可靠性和安全性。 2. EFS加密文件系统
EFS（encrypting file system）实际上是NTFS的一个特性，它提供了核心文件加密技术，主要用来在NTFS文件系统卷上存储加密文件，在加密了文件或文件夹之后，使用加密文件和文件夹的方法与使用其它任何文件和文件夹相同，即加密对于加密该文件的用户来说是透明的，这意味着不必在使用加密文件之前将其解密，可以像平常一样打开和更改文件，但是，如果侵入者试图打开、复制、移动和重命名加密的文件或文件夹，那么他将接收一条拒绝访问的消息。
像设置其他任何属性（如只读、压缩或隐藏）一样，可以通过设置文件夹和文件的加密属性来对文件夹或文件加密或解密。如果加密文件夹，那么在加密文件夹中创建的所有文件和子文件夹都将加密，因此，推荐在文件夹一级加密。
使用EFS保护文档的安全，可以防止侵入者获得对存储的敏感数据的未经授权的物理方问。
EFS带来的附加安全性是以性能为代价的，当操作系统对所访问的加密文件进行加密或解密时，文件传输将增加一点延迟。
系统影响性能的程序将具体取决于执行加密或解密操作的系统的处理能力。对于在本地驱动器上包含加密文件的现代工作站来说，因为这些系统通常不受处理器限制，所以影响通常可以忽略不计，这种影响对处理器上的额外负载可能不到1%，对于使用低端处理器的早期工作站来说，这种额外负载可能大约占处理器时间的10%。
对于服务器来说，负载可能会很重，在服务器上，可能同时发生许多不同的文件访问，如果其中许多文件都使用EFS来保护，那么处理器上的负载可能是处理器总负载的10%—25%。对于包含大量加密文件（或非常大的加密文件）的文件服务器而言，如果额外的处理开销使服务器负担过重，则应该添加处理器或者升级现有的处理器。 3. 压缩
Windows 2000支持在NTFS卷上压缩文件和目录，因为任何应用程序都可以读写在NTFS卷上压缩的文件而不需要首先由其他应用程序解压缩，在关闭或保存文件时再次压缩。
只有Windows 2000 NTFS驱动程序才能读取数据的压缩开式，当应用程序或操作系统命令请求访问文件时，NTFS在使文件可用之前首先对文件解压缩。当文件被解压缩、复制，然后重新压缩为一个新文件时，压缩可能导致性能降低，即使在同一台计算机中复制文件也是如此。对于网络传输，文件将被解压缩并以完整的大小传输，这会影响带宽和速度。 4. 磁盘配额
Windows 2000包括了一些用于存储管理的新技术，这些技术使管理员及最终用户可以得到更好的整体数据存储，通常使用一些预防性磁盘管理原则，可以合理安排网络卷上存储的数据量。
下面介绍磁盘配额追踪和控制卷的磁盘空间使用情况，当网络磁盘达到其容量后，磁盘和服务器的性能将出现严重的问题，除非对最终用户施加了磁盘限制，否则当用户决定将他们的所有硬盘驱动器数据都转存到一个目录中，或者他们认为网络是存储他们下载的mp3文件的最佳位置时，服务器磁盘可能很快就会耗尽，使用Windows 2000磁盘配额系统，管理员可以配置Windows的以下特性：
1）防止进一步使用磁盘空间，并在用户超出指定的磁盘空间限制时记录一个事件。
2）在用户超出指定的磁盘空间警级别时记录事件。
在启用磁盘配额时，可以设置两个值：磁盘配额限制和磁盘配额警告级别。配额限制指定允许用户使用的磁盘空间，而警告级别指定用户正接近其配额限制的时刻。例如：可以将用户的磁盘配额限制设置为50MB，将磁盘配额警告级别设置为45MB，在这种情况下，用户可以在卷上存储不多于50MB的文件，如果用户在卷上存储的文件超过了45MB，则可以让磁盘配额系统记录一个系统事件。
8. 2 实验目的
通过对Windows 2000 提供的文件与文件夹加密、磁盘配额管理、创建紧急修复磁盘、进行磁盘清理、执行备份操作、使用CHKDSK维护文件完整性和整理磁盘碎片等功能进行操作： 1）熟悉Windows 2000的文件系统。
2）明确应用NTFS文件系统的积极意义。
3）掌握优化Windows 2000磁盘子系统的基本方法。 4）进一步理解现代操作系统文件管理知识。
8. 3 工具/准备工作
在开始本实验之前，请回顾教科书的相关内容。
需要一台准备安装Windows 2000 Professional 操作系统的计算机。
8. 4 实验内容与步骤
步骤1：阅读“背景知识”，请回答：
1）Windows 2000支持哪三种主要的文件系统？ a.FAT16 b.FAT32 c.NTFS
2）NTFS文件系统只能用于哪些操作系统环境？
NTFS是为在大磁盘上有效地完成文件操作而设计的, 只能为Windows NT、2000和XP操作系统所访问
步骤2：登录进入Windows 2000 Professioal。
步骤3：加密文件或文件夹，可按照以下步骤进行：
1）在“Windows资源管理器”中，右键单击想要加密的文件或文件夹，然后单击“属性”。
2）在“常规”选项卡上，单击“高级”按钮。
在“高级属性”对话框中，可以设置的文件属性有：