操作系统实验报告 windows部分（原创）

操作系统实验报告 （windows部分）

班级： 姓名： 学号：

3.1 Windows“任务管理器”的进程管理

(实验估计时间：60分钟)

? ? ? ?

? 背景知识 ? 实验目的

? 工具/准备工作 ? 实验内容与步骤

背景知识

Windows 2000的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息，也显示了最常用的度量进程性能的单位。使用任务管理器，可以打开监视计算机性能的关键指示器，快速查看正在运行的程序的状态，或者终止已停止响应的程序。也可以使用多个参数评估正在运行的进程的活动，以及查看CPU 和内存使用情况的图形和数据。其中：

1) “应用程序”选项卡显示正在运行程序的状态，用户能够结束、切换或者启动程序。 2) “进程”选项卡显示正在运行的进程信息。例如，可以显示关于CPU 和内存使用情况、页面错误、句柄计数以及许多其他参数的信息。

3) “性能”选项卡显示计算机动态性能，包括CPU 和内存使用情况的图表，正在运行的句柄、线程和进程的总数，物理、核心和认可的内存总数 (KB) 等。 实验目的

通过在Windows 任务管理器中对程序进程进行响应的管理操作，熟悉操作系统进程管理的概念，学习观察操作系统运行的动态性能。 工具/准备工作

在开始本实验之前，请回顾教科书的相关内容。

需要准备一台运行Windows 2000 Professional操作系统的计算机。 实验内容与步骤

1. 使用任务管理器终止进程 2. 显示其他进程计数器

3. 更改正在运行的程序的优先级

启动并进入Windows环境，单击Ctrl + Alt + Del键，或者右键单击任务栏，在快捷菜单中单击“任务管理器”命令，打开“任务管理器”窗口。

在本次实验中，你使用的操作系统版本是：

Microsoft Window 2000 5.00.2195 Service Pack 4 当前机器中由你打开，正在运行的应用程序有：

3.1Windows “任务管理器” 的进程管理，Windows部分

Windows“任务管理器”的窗口由3个选项卡组成，分别是： 应用程序，进程，性能

当前“进程”选项卡显示的栏目分别是 (可移动窗口下方的游标/箭头，或使窗口最大化进行观察) ：

映像名称，PID，CPU，CPU时间，内存使用

1. 使用任务管理器终止进程

步骤1：单击“进程”选项卡，一共显示了_22_个进程。请试着区分一下，其中： 系统 (SYSTEM) 进程有__13___个，填入表3-1中。

表3-1 实验记录 映像名称 用户名 CPU 内存使用 MDM.exe spoolsv.exe lsass.exe services.exe winlogon.exe csrss.exe smss.exe nutsrv4.exe system System idle process svchost.exe inetinfo.exe smss.exe

SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM 00 00 00 00 00 00 00 00 00 97 00 00 00 2448K 1968K 1568K 3460K 1436K 3556K 384K 1036K 180K 16K 2036K 1756K 52K 服务 (SERVICE) 进程有__3__个，填入表3-2中。

表3-2 实验记录 映像名称 用户名 CPU 内存使用 svchost.exe svchost.exe 00svchost.exe

LOCAL SERVICE NETWORK SERVICE NETWORK SERVICE 00 00 00 1676K 3124K 3744K 用户进程有__6__个，填入表3-3中。

表3-3 实验记录 映像名称 用户名 CPU 内存使用 360tray.exe ctfmon.exe students students 00 00 15K 2204K

iexplore.exe Explorer.exe taskmgr.exe WINWORD.EXE

students students students students 04 00 00 03 33244K 8524K 2500K 26984K 提示：在Windows XP的“任务管理器”中，“进程”选项卡增加了一个“用户名”栏目，其中区分了SYSTEM、NETWORK SERVICE、LOCAL SERVICE和用户的不同进程类别。

步骤2：单击要终止的进程，然后单击“结束进程”按钮。

注意：终止进程时要小心。终止进程有可能导致不希望发生的结果，包括数据丢失和系统不稳定等。因为在被终止前，进程将没有机会保存其状态和数据。如果结束应用程序，您将丢失未保存的数据。如果结束系统服务，系统的某些部分可能无法正常工作。

终止进程，将结束它直接或间接创建的所有子进程。例如，如果终止了电子邮件程序 (如

Outlook 98) 的进程树，那么同时也终止了相关的进程，如MAPI后台处理程序mapisp32.exe。

请将终止某进程后的操作结果与原记录数据对比，发生了什么：

结束进程WINWORD.EXE , Microsoft Word关闭了 2. 显示其他进程记数器

在“进程”选项卡上单击“查看”菜单，然后单击“选择列”命令。单击要增加显示为列标题的项目，然后单击“确定”。

为对进程列表进行排序，可在“进程”选项卡上单击要根据其进行排序的列标题。而为了要反转排序顺序，可再次单击列标题。

经过调整，“进程”选项卡现在显示的项目分别是：

映像名称，PID，CPU时间，内存使用，I/O写入，线程计数。 通过对“查看”菜单的选择操作，可以在“任务管理器”中更改显示选项： · 在“应用程序”选项卡上，可以按详细信息、大图标或小图标查看。

· 在“性能”选项卡上，可以更改CPU记录图，并显示内核时间。“显示内核时间”选项在“CPU使用”和“CPU使用记录”图表上添加红线。红线指示内核操作占用的CPU资源数量。

3. 更改正在运行的程序的优先级

要查看正在运行的程序的优先级，可单击“进程”选项卡，单击“查看”菜单，单击“选择列”-“基本优先级”命令，然后单击“确定”按钮。

为更改正在运行的程序的优先级，可在“进程”选项卡上右键单击您要更改的程序，指向“设置优先级”，然后单击所需的选项。

更改进程的优先级可以使其运行更快或更慢 (取决于是提升还是降低了优先级) ，但也可能对其他进程的性能有相反的影响。

记录操作后所体会的结果：

更改后速度略微加快，但效果并不明显，因为 System idle process 代表系统空闲进程，CPU显示为97，证明计算机基本处于空闲状态，但如果太多的进程同时占用CPU和内存的话，调整优先级会有效的提高或降低速度。

在多处理器计算机上，用户还可以给处理器指派进程，将程序或进程的执行限制在选定的处理器上，但这有可能导致总体性能的下降。

3.1 提高Windows 2000内存性能

(实验估计时间：60分钟)

背景知识

1. 分页过程 2. 内存共享

3. 未分页合并内存与分页合并内存 4. 提高分页性能

耗尽内存是Windows 2000系统中最常见的问题之一。当系统耗尽内存时，所有进程对内存的总需求超出了系统的物理内存总量。随后，Windows 2000必须借助它的虚拟内存来维持系统和进程的运行。虚拟内存机制是Windows 2000操作系统的重要组成部分，但它的速度比物理内存慢得多，因此，应该尽量避免耗尽物理内存资源，以免导致性能下降。

解决内存不足问题的一个有效的方法就是添加更多的内存。但是，一旦提供了更多的内存，Windows 2000很可以会立即“吞食”。而事实上，添加更多的内存并非总是可行的，也可能只是推迟了实际问题的发生。因此，应该相信，优化所拥有的内存是非常关键的。

1. 分页过程

当Windows 2000求助于硬盘以获得虚拟内存时，这个过程被称为分页 (paging) 。分页就是将信息从主内存移动到磁盘进行临时存储的过程。应用程序将物理内存和虚拟内存视为一个独立的实体，甚至不知道Windows 2000使用了两种内存方案，而认为系统拥有比实际内存更多的内存。例如，系统的内存数量可能只有16MB，但每一个应用程序仍然认为有4GB内存可供使用。

使用分页方案带来了很多好处，不过这是有代价的。当进程需要已经交换到硬盘上的代码或数据时，系统要将数据送回物理内存，并在必要时将其他信息传输到硬盘上，而硬盘与物理内存在性能上的差异极大。例如，硬盘的访问时间通常大约为4-10毫秒，而物理内存的访问时间为60 us，甚至更快。

2. 内存共享

应用程序经常需要彼此通信和共享信息。为了提供这种能力，Windows 2000必须允许访问某些内存空间而不危及它和其他应用程序的安全性和完整性。从性能的角度来看，共享内存的能力大大减少了应用程序使用的内存数量。运行一个应用程序的多个副本时，每一个实例都可以使用相同的代码和数据，这意味着不必维护所加载应用程序代码的单独副本并使用相同的内存资源。无论正在运行多少个应用程序实例，充分支持应用程序代码所需求的内存数量都相对保持不变。

3. 未分页合并内存与分页合并内存

Windows 2000决定了系统内存组件哪些可以以及哪些不可以交换到磁盘上。显然，不应该将某些代码 (例如内核) 交换出主内存。因此，Windows 2000将系统使用的内存进一步划分为未分页合并内存和分页合并内存。

分页合并内存是存储迟早需要的可分页代码或数据的内存部分。虽然可以将分页合并内存中的任何系统进程交换到磁盘上，但是它临时存储在主内存的这一部分，以防系统立刻需

要它。在将系统进程交换到磁盘上之前，Windows 2000会交换其他进程。

未分页合并内存包含必须驻留在内存中的占用代码或数据。这种结构类似于早期的MS-DOS程序使用的结构，在MS-DOS中，相对较小的终止并驻留程序 (Terminate and Stay Resident，TSR) 在启动时加载到内存中。这些程序在系统重新启动或关闭之前一直驻留在内存的特定部分中。例如，防病毒程序将加载为TSR程序，以预防可能的病毒袭击。

未分页合并内存中包含的进程保留在主内存中，并且不能交换到磁盘上。物理内存的这个部分用于内核模式操作（例如，驱动程序）和必须保留在主内存中才能有效工作的其他进程。没有主内存的这个部分，内核组件就将是可分页的，系统本身就有变得不稳定的危险。

分配到未分页内存池的主内存数量取决于服务器拥有的物理内存数量以及进程对系统上的内存地空间的需求。不过，Windows 2000将未分页合并内存限制为256MB (在Windows NT 4中的限制为128MB) 。根据系统中的物理内存数量，复杂的算法在启动时动态确定Windows 2000系统上的未分页合并内存的最大数量。Windows 2000内部的这一自我调节机制可以根据当前的内存配置自动调整大小。例如，如果增加或减少系统中的内存数量，那么Windows2000将自动调整未分页合并内存的大小，以反映这一更改。

4. 提高分页性能

只有一个物理硬盘驱动器的系统限制了优化分页性能的能力。驱动器必须处理系统和应用程序的请求以及对分页文件的访问。虽然物理驱动器可能有多个分区，但是将分页文件分布到多个分区的分页文件并不能提高硬盘驱动器的能力。只有当一个分区没有足够的空间来包含整个分页文件时，才将分页文件放在同一个硬盘的多个分区上。

拥有多个物理驱动器的服务器可以使用多个分页文件来提高分页性能。关键是将分页请求的负载分布到多个物理硬盘上。实际上，使用独立物理驱动器上的分页文件，系统可以同时处理多个分页请求。各个物理驱动器可以同时访问它自己的分页文件并写入信息，这将增加可以传输的信息量。多个分页文件的最佳配置是将各个分页文件放在拥有自己的控制器的独立驱动器上。不过，由于额外的费用并且系统上的可用中断很有限，因此对于大多数基于服务器的配置来说，这可能是不切实际的解决方案。

分页文件最重要的配置参数是大小。无论系统中有多少个分页文件，如果它们的大小不合适，那么系统就可能遇到性能问题。

如果初始值太小，那么系统可能必须扩大分页文件，以补偿额外的分页活动。当系统临时增加分页文件时，它必须在处理分页请求的同时创建新的空间。这时，系统将出现大量的页面错误，甚至可能出现系统失效。当系统必须在进程的工作区外部 (在物理内存或分页文件中的其他位置) 查找信息时，就会出现页面错误。当系统缺乏存储资源 (物理内存及虚拟内存) 来满足使用需求，从而遇到过多的分页时，就会出现系统失效。系统将花更多的时间来分页而不是执行应用程序。当系统失效时，Memory：Pages/see计数器将持续高于每秒100页。系统失效严重降低了系统的性能。此外，动态扩展分页文件将导致碎片化。分页文件将散布在整个磁盘上而不是在启动时的连续空间中创建，从而增加了系统的开销，并导致系统性能降低。因此，应该尽量避免系统增加分页文件的大小。

提示： 1) 在NTFS驱动器上，总是至少保留25％的空闲驱动器空间，以确保可以在连续的空间中创建分页文件。 2) Windows 2000使用内存数量的1.5倍作为分页文件的最小容量，这个最小容量的两倍作为最大容量。它减少了系统因为错误配置的分页文件而崩溃的可能性。系统在崩溃之后能够将内存转储写入磁盘，所以系统分区必须有一个至少等于物理内存数量加上1的分页文件。

实验目的

通过对Windows 2000“任务管理器”、“计算机管理”、“我的电脑”属性、“系统信息”、“系统监视器”等程序的应用，学习提高Windows内存的性能，，加深理解Windows操作系统的内存管理功能，理解操作系统存储管理、虚拟存储管理的知识。 工具/准备工作

在开始本实验之前，请回顾教科书的相关内容。

需要准备一台运行Windows 2000 Professional操作系统的计算机。 实验内容与步骤

判断和维护Windows 2000的内存性能有许多方法。 步骤1：阅读“背景知识”，请回答： 1) 什么是“分页过程”？

当Windows 2000求助于硬盘以获得虚拟内存时，这个过程被称为分页 (paging) 。分页就是将信息从主内存移动到磁盘进行临时存储的过程。

2) 什么是“内存共享”？

是指两个或多个进程共用内存中的相同区域，其目的是节省内存空间，实现进程间通信，提高内存空间的利用率。

3) 什么是“未分页合并内存”和“分页合并内存”？ Windows 2000中，未分页合并内存的最大限制是多少？

分页合并内存是存储迟早需要的可分页代码或数据的内存部分。 未分页合并内存包含必须驻留在内存中的占用代码或数据。 Windows 2000将未分页合并内存限制为256MB 4) Windows 2000分页文件默认设置的最小容量和最大容量是多少？

Windows 2000使用内存数量的1.5倍作为分页文件的最小容量，这个最小容量的两倍作为最大容量。

步骤2：登录进入Windows 2000 Professional。

步骤3：查看包含多个实例的应用程序的内存需求。 1) 启动想要监视的应用程序，例如Word。 2) 右键单击任务栏以启动“任务管理器”。

3) 在“Windows任务管理器”对话框中选定“进程”选项卡。 4) 向下滚动在系统上运行的进程列表，查找想要监视的应用程序。 请在表5-1中记录：

表5-1 实验记录 映像名称 WINWORD.EXE 820 PID 06 CPU CPU时间 0：00：10 内存使用 34848K

“内存使用”列显示了该应用程序的一个实例正在使用的内存数量。 5) 启动应用程序的另一个实例并观察它的内存需求。

请描述使用第二个实例占用的内存与使用第一个实例时的内存对比情况：

启动360安全卫士，内存使用量为2264K，远小于Microsoft Word 的内容使用量。

步骤4：未分页合并内存。

估算未分页合并内存大小的最简单方法是使用“任务管理器”。未分页合并内存的估计

值显示在“任务管理器”的“性能”选项卡的“核心内存”部分。

总数 (K) ：56552 分页数：45828 未分页 (K) ：10724

还可以使用“任务管理器”查看一个独立进程正在使用的未分页合并内存数量和分页合并内存数量。操作步骤如下：

1) 单击“Windows任务管理器”的“进程”选项卡，然后从“查看”菜单中选择“选择列”命令，显示“进程”选项卡的可查看选项。

2) 在“选择列”对话框中，选定“页面缓冲池”选项和“非页面缓冲池”选项旁边的复选框，然后单击“确定”按钮。

返回Windows 2000“任务管理器”的“进程”选项卡时，将看到其中增加显示了各个进程占用的分页合并内存数量和未分页合并内存数量。

仍以刚才打开观察的应用程序 (例如Word) 为例，请在表5-2中记录：

表5-2 实验记录 映像名称 WINWORD.EXE 820 PID 内存使用 32276K 页面缓冲池 241K 非页面缓冲池 24K

从性能的角度来看，未分页合并内存越多，可以加载到这个空间的数据就越多。拥有的物理内存越多，未分页合并内存就越多。但未分页合并内存被限制为256MB，因此添加超出这个限制的内存对未分页合并内存没有影响。

步骤5：提高分页性能。

在Windows 2000的安装过程中，将使用连续的磁盘空间自动创建分页文件(pagefile.sys) 。用户可以事先监视变化的内存需求并正确配置分页文件，使得当系统必须借助于分页时的性能达到最高。

虽然分页文件一般都放在系统分区的根目录下面，但这并不总是该文件的最佳位置。要想从分页获得最佳性能，应该首先检查系统的磁盘子系统的配置，以了解它是否有多个物理硬盘驱动器。

1) 在“开始”菜单中单击“设置” – “控制面板”命令，双击“管理工具”图标，再双击“计算机管理”图标。

2) 在“计算机管理”窗口的左格选择“磁盘管理”管理单元来查看系统的磁盘配置。 请在表5-3中记录：

表5-3 实验记录 卷 C： D： E： 布局 磁盘分区 磁盘分区 磁盘分区 类型 基本 基本 基本 文件系统 FAT32 FAT FAT32 容量 19.52G 493M 10.29G 状态 状态良好（系统） 状态良好 状态良好

如果系统只有一个硬盘，那么建议应该尽可能为系统配置额外的驱动器。这是因为：Windows 2000最多可以支持在多个驱动器上分布的16个独立的分页文件。为系统配置多个分页文件可以实现对不同磁盘I/O请求的并行处理，这将大大提高I/O请求的分页文件性能。

步骤6：计算分页文件的大小。

要想更改分页文件的位置或大小配置参数，可按以下步骤进行： 1) 右键单击桌面上的“我的电脑”图标并选定“属性”。 2) 在“高级”选项卡上单击“性能选项”按钮。

3) 单击对话框中的“虚拟内存”区域中的“更改”按钮。 请记录：

所选驱动器 (C: ) 的页面文件大小： 驱动器：C 可用空间：8160MB 初始大小 (MB) ：384MB 最大值 (MB) ：768MB

所有驱动器页面文件大小的总数： 允许的最小值：2MB 推荐：382MB 当前已分配：384MB

4) 要想将另一个分页文件添加到现有配置，在“虚拟内存”对话框中选定一个还没有分页文件的驱动器，然后指定分页文件的初始值和最大值 (以兆字节表示) ，单击“设置”，然后单击“确定”。

5) 要想更改现有分页文件的最大值和最小值，可选定分页文件所在的驱动器。然后指定分页文件的初始值和最大值，单击“设置”按钮，然后单击“确定”按钮。

6) 在“性能选项”对话框中单击“确定”按钮。 7) 单击“确定”按钮以关闭“系统特性”对话框。 步骤7：使用任务管理器。

可以使用“任务管理器”来简单地检查分页文件是否配置了正确容量。这样可以实时提供系统正在使用分页文件的方式以及其他重要系统信息的准确描述。

通过右键单击任务栏运行“任务管理器”，选定“性能”选项卡查看实时的系统统计数据。与分页文件大小最有关的信息位于“认可用量”区域。这一区域显示了认可“峰值”是否达到或超过了认可“限制”，以及它是否超过了系统上的物理内存数量。认可“峰值”是指系统迄今为止向进程分配的最大物理内存和虚拟内存数量。

请记录： 物理内存 (K) 总数： 261616K 可用数： 38304K 系统缓存： 66840K 认可用量 (K) 总数： 367380K 限制： 632708K 峰值： 425612K 当系统遇到分页活动增加的情况时，提交的内存数量 (“认可总数”) 就会增加。一旦它达到了“认可限制”值，系统就需要扩展分页文件。“认可限制”值指出在不必扩展分页文件的情况下可以向内存提交的虚拟内存数量。因为目标是避免扩展分页文件，所以必须保持“认可总数”和“认可限制”值相差较大。如果这两个值接近了，那么系统必须动态增加分页文件的大小。

“任务管理器”的“认可用量”区域显示的信息还说明了系统的主内存是否足以满足系统执行的任务。如果认可“总数”值经常超过系统中的内存数量，那么系统的物理内存可能不足。

3.2 Windows 2000编程

(实验估计时间：120分钟)

? ? ? ?

? 背景知识 ? 实验目的

? 工具/准备工作 ? 实验内容与步骤

背景知识

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) 代码块，在其中包含应用程序所使用的机器代码和应用程序的数据。 实验目的

通过对Windows 2000编程，进一步熟悉操作系统的基本概念，较好地理解Windows 2000的结构。 工具/准备工作

在开始本实验之前，请回顾教科书的相关内容。 需要做以下准备：

1) 一台运行Windows 2000 Professional操作系统的计算机。 2) 计算机中需安装Visual C++ 6.0专业版或企业版。 实验内容与步骤

1. 简单的控制台应用程序

2. GUI应用程序 3. 进程对象

1. 简单的控制台应用程序

我们先来创建一个名为“Hello，World”的应用程序。 步骤1：登录进入Windows 2000 Professional。

步骤2：在“开始”菜单中单击“程序”-“附件”-“记事本”命令，将清单3-l中的程序键入记事本中，并把代码保存为Hello.cpp。

清单3-1 一个简单的Windows 2000控制台应用程序 // hello项目

# include

void main() {

std::cout << “Hello, Windows 2000” << std :: endl ; }

步骤3：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows“命令提示符”窗口，并利用简单的标准命令行：

C:\\> CL Hello.cpp

来创建可执行的Hello.EXE。

操作能否正常进行？如果不行，则可能的原因是什么？

运行不正常。缺少MSPDB60.dll文件

步骤4：运行Hello.EXE程序，产生用户键入的一行文字。 运行结果 (如果运行不成功，则可能的原因是什么？) ： 运行不成功，connot execute “clxx”. 2. GUI应用程序

在下面的实验中，C++ 编译器创建一个GUI应用程序，代码中包括了WinMain() 方法，这是GUI类型的应用程序的标准入口点。

步骤5：在“开始”菜单中单击“程序”-“附件”-“记事本”命令，将清单3-2中的程序键入记事本中，并把代码保存为3-2.cpp。

清单3-2 Windows 2000的GUI应用程序 // msgbox项目

# include // 标准的include

// 告诉连接器与包括MessageBox API函数的user32库进行连接 # pragma comment(lib, “user32.lib” )

// 这是一个可以弹出信息框然后退出的筒单的应用程序 int APIENTRY WinMain(HINSTANCE /* hInstance */ , HINSTANCE /* hPrevInstance */ , LPSTR /* lpCmdLine */ ， int /* nCmdShow */ ) {

:: MessageBox( NULL, // 没有父窗口 “Hello, Windows 2000” , // 消息框中的文本 \ // 消息框标题 MB_OK) ; // 其中只有一个OK按钮

// 返回0以便通知系统不进入消息循环 return(0) ;

}

也可以利用任何其他文本编辑器键入程序代码，如果这样，例如使用WORD来键入和编辑程序，则应该注意什么问题？

标点符号的中英文切换。

步骤6：在“命令提示符”窗口运行CL.EXE，产生3-2.EXE文件： C:\\> CL 3-2.cpp

在清单3-2的GUI应用程序中，首先需要Windows.h头文件，以便获得传送给WinMain() 和MessageBox() API函数的数据类型定义。

接着的pragma指令指示编译器/连接器找到User32.LIB库文件并将其与产生的EXE文件连接起来。这样就可以运行简单的命令行命令CL MsgBox.CPP来创建这一应用程序，如果没有pragma指令，则MessageBox() API函数就成为未定义的了。这一指令是Visual Studio C++ 编译器特有的。

接下来是WinMain() 方法。其中有四个由实际的低级入口点传递来的参数。hInstance参数用来装入与代码相连的图标或位图一类的资源，无论何时，都可用GetModuleHandle() API函数将这些资源提取出来。系统利用实例句柄来指明代码和初始的数据装在内存的何处。句柄的数值实际上是EXE文件映像的基地址，通常为0x00400000。下一个参数hPrevInstance是为向后兼容而设的，现在系统将其设为NULL。应用程序的命令行 (不包括程序的名称) 是lpCmdLine参数。另外，系统利用nCmdShow参数告诉应用程序如何显示它的主窗口 (选项包括最小化、最大化和正常) 。

最后，程序调用MessageBox() API函数并退出。如果在进入消息循环之前就结束运行的话，最后必须返回0。

运行结果 (试将其中的信息与清单3-1程序的运行结果进行比较) ： Hello,Windows 2000 Greetings 3. 进程对象

操作系统将当前运行的应用程序看作是进程对象。利用系统提供的惟一的称为句柄 (HANDLE) 的号码，就可与进程对象交互。这一号码只对当前进程有效。

本实验表示了一个简单的进程句柄的应用。在系统中运行的任何进程都可调用GetCurrentProcess() API函数，此函数可返回标识进程本身的句柄。然后就可在Windows需要该进程的有关情况时，利用这一句柄来提供。

步骤7：将清单3-3.cpp程序键入记事本中，并把代码保存为3-3.cpp。 清单3-3 获得和使用进程的句柄

// prochandle项目 # include # include

// 确定自己的优先权的简单应用程序 void main() {

// 从当前进程中提取句柄

HANDLE hProcessThis = :: GetCurrentProcess() ;

// 请求内核提供该进程所属的优先权类

DWORD dwPriority = :: GetPriorityClass(hProcessThis) ;

// 发出消息，为用户描述该类

std :: cout << “Current process priority: ” ; switch(dwPriority) {

case HIGH_PRIORITY_CLASS: std :: cout << “High” ; break;

case NORMAL_PRIORITY_CLASS: std :: cout << “Normal” ; break;

case IDLE_PRIORITY_CLASS: std :: cout << “Idle” ; break;

case REALTIME_PRIORITY_CLASS: std :: cout << “Realtime” ; break; default:

std :: cout << “” ; break; }

std :: cout << std :: endl; }

清单3-3中列出的是一种获得进程句柄的方法。对于进程句柄可进行的惟一有用的操作是在API调用时，将其作为参数传送给系统，正如清单3-3中对GetPriorityClass() API函数的调用那样。在这种情况下，系统向进程对象内“窥视”，以决定其优先级，然后将此优先级返回给应用程序。

OpenProcess() 和CreateProcess() API函数也可以用于提取进程句柄。前者提取的是已经存在的进程的句柄，而后者创建一个新进程，并将其句柄提供出来。

步骤8：在“命令提示符”窗口运行CL.EXE，产生3-3.EXE文件： C:\\> CL 3-3.cpp

运行结果： High Mormal Idle Realtime unknown

步骤9：将清单3-4.cpp程序键入记事本中，并把代码保存为3-4.cpp。 清单3-4显示如何找出系统中正在运行的所有进程，如何利用OpenProcess() API函数来获得每一个访问进程的进一步信息。

清单3-4 利用句柄查出进程的详细信息 // proclist项目

# include # include # include

// 当在用户模式机内核模式下都提供所耗时间时，在内核模式下进行所耗时间的64位计算的帮助方法

DWORD GetKernelModePercentage(const FILETIME & ftKernel, const FILETIME & ftUser) {

// 将FILETIME结构转化为64位整数

ULONGLONG qwKernel =

( ( (ULONGLONG) ftKernel.dwHighDateTime) << 32) +

ftKernel.dwLowDateTime; ULONGLONG qwUser =

( ( (ULONGLONG) ftUser.dwHighDateTime) << 32) +

ftUser.dwLowDateTime;

// 将消耗时间相加，然后计算消耗在内核模式下的时间百分比 ULONGLONG qwTotal = qwKernel + qwUser; DWORD dwPct =

(DWORD) ( ( (ULONGLONG) 100*qwKernel) / qwTotal) ;

return(dwPct) ; }

// 以下是将当前运行进程名和消耗在内核模式下的时间百分数都显示出来的应用程序

void main() {

// 对当前系统中运行的进程拍取“快照”

HANDLE hSnapshot = :: CreateToolhelp32Snapshot( TH32CS – SNAPPROCESS, // 提取当前进程 0) ; // 如果是当前进程，就将其忽略

// 初始化进程入口

PROCESSENTRY32 pe;

:: ZeroMemory(&pe, sizeof(pe) ) ; pe.dwSize = sizeof(pe) ;

// 按所有进程循环

BOOL bMore = :: Process32First(hSnapshot, &pe) ; while(bMore) {

// 打开用于读取的进程

HANDLE hProcess = :: OpenProcess(

PROCESS_QUERY_INFORMATION, // 指明要得到信息 FALSE, // 不必继承这一句柄 pe.th32ProcessID) ; // 要打开的进程 if (hProcess != NULL) {

// 找出进程的时间

FILETIME ftCreation, ftExit, ftKernelMode, ftUserMode; :: GetProcessTimes( hProcess, // 所感兴趣的进程 &ftCreation, // 进程的启动时间 (绝对的) &ftExit, // 结束时间 (如果有的话) &ftKernelMode, // 在内核模式下消耗的时间 &ftUserMode) ; // 在用户模式下消耗的时间

// 计算内核模式消耗的时间百分比

DWORD dwPctKernel = :: GetKernelModePercentage( ftKernelMode, // 在内核模式上消耗的时间 ftUserMode ) ; // 在用户模式下消耗的时间

// 向用户显示进程的某些信息

std :: cout << “Process ID: ” << pe.th32ProcessID << “, EXE file: ” << pe.szExeFile

<< “, % in kernel mode: ” << dwPctKernel << std :: endl;

// 消除句柄

:: CloseHandle(hProcess) ; }

// 转向下一个进程

bMore = :: Process32Next(hSnapshot, &pe) ; } }

清单3-4程序首先利用Windows 2000的新特性，即工具帮助库来获得当前运行的所有进程的快照。然后应用程序进入快照中的每一个进程，得到其以PROCESSENTRY32结构表示的属性。这一结构用来向OpenProcess() API函数提供进程的ID。Windows跟踪每一进程的有关时间，示例中是通过打开的进程句柄和GetProcessTimes() API来直询得到有关时间的。接下来，一个定制的帮助函数取得了几个返回的数值，然后计算进程在内核模式下消耗的时间占总时间的百分比。程序的其余部分比较简单，只是将有关信息显示给用户，清除进程句柄，然后继续循环，直到所有进程都计算过为止。

步骤10：在“命令提示符”窗口运行CL.EXE，产生3-4.EXE文件： C:\\> CL 3-4.cpp 运行结果：

ProcessID: ,EXE file : ,%in kemel mode:

3.2 Windows 2000内存结构

(实验估计时间：120分钟)

? ? ? ?

背景知识 实验目的

工具/准备工作 实验内容与步骤

背景知识

Windows 2000是32位的操作系统，它使计算机CPU可以用32位地址对32位内存块进行操作。内存中的每一个字节都可以用一个32位的指针来寻址。这样，最大的存储空间就是232字节或4000兆字节 (4GB) 。这样，在Windows下运行的每一个应用程序都认为能独占可能的4GB大小的空间。

而另一方面，实际上没有几台机器的RAM能达到4GB，更不必说让每个进程都独享4GB内存了。Windows在幕后将虚拟内存 (virtual memory，VM) 地址映射到了各进程的物理内存地址上。而所谓物理内存是指计算机的RAM和由Windows分配到用户驱动器根目录上的换页文件。物理内存完全由系统管理。 实验目的

1) 通过实验了解Windows 2000内存的使用，学习如何在应用程序中管理内存，体会Windows应用程序内存的简单性和自我防护能力。

2) 了解Windows 2000的内存结构和虚拟内存的管理，进而了解进程堆和Windows为使用内存而提供的一些扩展功能。 工具/准备工作

在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备：

1) 一台运行Windows 2000 Professional操作系统的计算机。 2) 计算机中需安装Visual C++ 6.0专业版或企业版。 实验内容与步骤

Windows提供了一个API即GetSystemInfo() ，以便用户能检查系统中虚拟内存的一些特性。清单5-1显示了如何调用该函数以及显示系统中当前内存的参数。

步骤1：登录进入Windows 2000 Professional。

步骤2：在“开始”菜单中单击“程序-Microsoft Visual Studio 6.0 – Microsoft Visual C++ 6.0”命令，进入Visual C++窗口。

步骤3：在工具栏单击“打开”按钮，在“打开”对话框中找到并打开实验源程序5-1.cpp。

清单5-1 获取有关系统的内存设置的信息 // 工程vmeminfo

# include # include # include #i nclude

# pragma comment(lib, “shlwapi.lib”)

void main() {

// 首先获得系统信息 SYSTEM_INFO si;

:: ZeroMemory(&si, sizeof(si) ) ; :: GetSystemInfo(&si) ;

// 使用外壳辅助程序对一些尺寸进行格式化 TCHAR szPageSize [MAX_PATH] ;

:: StrFormatByteSize(si.dwPageSize, szPageSize, MAX_PATH) ;

DWORD dwMemSize = (DWORD) si.lpMaximumApplicationAddress - (DWORD) si.lpMinimumApplicationAddress; TCHAR szMemSize [MAX_PATH] ;

:: StrFormatByteSize(dwMemSize, szMemSize, MAX_PATH) ;

// 将内存信息显示出来

std :: cout << “Virtual memory page size: ” << szPageSize << std :: endl;

std :: cout.fill (?0?) ;

std :: cout << “Minimum application address: 0x” << std :: hex << std :: setw(8)

<< (DWORD) si.lpMinimumApplicationAddress << std :: endl;

std :: cout << “Maximum application address: 0x” << std :: hex << std :: setw(8)

<< (DWORD) si.lpMaximumApplicationAddress << std :: endl;

std :: cout << “Total available virtual memory: ” << szMemSize << std :: endl ; }

步骤4：单击“Build”菜单中的“Compile 5-1.cpp”命令，并单击“是”按钮确认。系统对5-1.cpp进行编译。

步骤5：编译完成后，单击“Build”菜单中的“Build 5-1.exe”命令，建立5-1.exe可执行文件。

操作能否正常进行？如果不行，则可能的原因是什么？

直接复制源程序会出错。原因：标点不是英文输入法下半角的标点。更改后可以正常运行。结果是：

步骤6：在工具栏单击“Execute Program” (执行程序) 按钮，执行5-1.exe程序。 运行结果 (如果运行不成功，则可能的原因是什么？) ：

1) 虚拟内存每页容量为： 4.00kb 2) 最小应用地址： 0x00010000 3) 最大应用地址： 0x7ffeffff 4) 当前可供应用程序使用的内存空间为： 1.99GB 5) 当前计算机的实际内存大小为：

步骤6：在工具栏单击“Execute Program”(执行程序) 按钮，或者按Ctrl + F5键，或者单击“Build”菜单中的“Execute 3-5.exe”命令，执行3-5.exe程序。

步骤7：按Ctrl + S键可暂停程序的执行，按Ctrl + Pause (Break) 键可终止程序的执行。 清单3-5展示的是一个简单的使用CreateProcess() API函数的例子。首先形成简单的命令行，提供当前的EXE文件的指定文件名和代表生成克隆进程的号码。大多数参数都可取缺省值，但是创建标志参数使用了：

NULL

标志，指示新进程分配它自己的控制台，这使得运行示例程序时，在任务栏上产生许多活动标记。然后该克隆进程的创建方法关闭传递过来的句柄并返回main() 函数。在关闭程序之前，每一进程的执行主线程暂停一下，以便让用户看到其中的至少一个窗口。

CreateProcess() 函数有10个核心参数？本实验程序中设置的各个参数的值是： szFilename, // 产生这个EXE的应用程序的名称 szCmdLine, // 告诉其行为像一个子进程的标志 NULL, // 缺省的进程安全性 NULL, // 缺省的线程安全性 FALSE, // 不继承句柄 CREATE_NEW_CONSOLE, // 使用新的控制台 NULL, // 新的环境 NULL, // 当前目录 &si, // 启动信息 &pi) ; // 返回的进程信息程序运行时屏幕显示

程序运行时屏幕显示的信息是：Process ID:2384,Clone ID: 0

提示：部分程序在Visual C++环境完成编译、链接之后，还可以在Windows 2000的“命令提示符”状态下尝试执行该程序，看看与在可视化界面下运行的结果有没有不同？为什么？

2. 正在运行的进程

本实验的程序中列出了用于进程信息查询的API函数GetProcessVersion() 与GetVersionEx() 的共同作用，可确定运行进程的操作系统的版本号。

步骤8：在Visual C++ 窗口的工具栏中单击“打开”按钮，在“打开”对话框中找到并打开实验源程序3-6.cpp。

清单3-6 使用进程和操作系统的版本信息 // version项目

# include # include

// 利用进程和操作系统的版本信息的简单示例 void main() {

// 提取这个进程的ID号

DWORD dwIdThis = :: GetCurrentProcessId() ;

// 获得这一进程和报告所需的版本，也可以发送0以便指明这一进程 DWORD dwVerReq = :: GetProcessVersion(dwIdThis) ; WORD wMajorReq = (WORD) dwVerReq > 16) ; WORD wMinorReq = (WORD) dwVerReq & 0xffff) ; std :: cout << “Process ID: “ << dwIdThis

<< “, requires OS: “ << wMajorReq << wMinorReq << std :: endl ;

// 设置版本信息的数据结构，以便保存操作系统的版本信息 OSVERSIONINFOEX osvix;

:: ZeroMemory(&osvix, sizeof(osvix) ) ;

osvix.dwOSVersionInfoSize = sizeof(osvix) ;

// 提取版本信息和报告

:: GetVersionEx(reinterpret_cast < LPOSVERSIONINFO > (&osvix) ) ; std :: cout << “Running on OS: “ << osvix.dwMajorVersion << “.” << osvix.dwMinorVersion << std :: endl;

// 如果是NTS (Windows 2000) 系统，则提高其优先权

if (osvix.dwPlatformld = = VER_PLATFORM_WIN32_NT && osvix.dwMajorVersion >= 5) {

// 改变优先级 :: SetPriorityClass(

:: GetCurrentProcess() , // 利用这一进程 HIGH_PRIORITY_CLASS) ; // 改变为high

// 报告给用户

std :: cout << “Task Manager should now now indicate this” “process is high priority．” << std :: endl; } }

步骤9：单击“Build”菜单中的“Compile 3-6.cpp”命令，再单击“是”按钮确认。系统对3-6.cpp进行编译。

步骤10：编译完成后，单击“Build”菜单中的“Build 3-6.exe”命令，建立3-6.exe可执行文件。 操作能否正常进行？如果不行，则可能的原因是什么？

能正常运行

步骤11：在工具栏单击“Execute Program” (执行程序) 按钮，执行3-6.exe程序。 运行结果：

Process ID:1492,requires OS:00 Running on OS:5.1 Task Manager should now now indicate thisprocess is high priority.

清单3-6中的程序向读者表明了如何获得当前的PID和所需的进程版本信息。为了运行这一程序，系统处理了所有的版本不兼容问题。

接着，程序演示了如何使用GetVersionEx() API函数来提取OSVERSIONINFOEX结构。这一数据块中包括了操作系统的版本信息。其中，“OS : 5.0”表示当前运行的操作系统是： Window2000当前版本为_OS:5.0

清单3-6的最后一段程序利用了操作系统的版本信息，以确认运行的是Windows 2000。代码接着将当前进程的优先级提高到比正常级别高。

步骤12：单击Ctrl + Alt + Del键，进入“Windows任务管理器”，在“应用程序”选项卡中右键单击“3-6”任务，在快捷菜单中选择“转到进程”命令。

在“Windows任务管理器”的“进程”选项卡中，与“3-6”任务对应的进程映像名称是 (为什么？) ：

Vcspawn.exe

右键单击该进程名，在快捷菜单中选择“设置优先级”命令，可以调整该进程的优先级，如设置为“高”后重新运行3-6.exe程序，屏幕显示有变化吗？为什么？

有变化。ProcessID值有1492变为：3152 ．

除了改变进程的优先级以外，还可以对正在运行的进程执行几项其他的操作，只要获得其进程句柄即可。SetProcessAffinityMask() API函数允许开发人员将线程映射到处理器上；SetProcessPriorityBoost() API可关闭前台应用程序优先级的提升；而 SetProcessWorkingSet()

API可调节进程可用的非页面RAM的容量；还有一个只对当前进程可用的API函数，即SetProcessShutdownParameters() ，可告诉系统如何终止该进程。 3. 终止进程

在清单3-7列出的程序中，先创建一个子进程，然后指令它发出“自杀弹”互斥体去终止自身的运行。

步骤13：在Visual C++ 窗口的工具栏中单击“打开”按钮，在“打开”对话框中找到并打开实验源程序3-7.cpp。

清单3-7 指令其子进程来“杀掉”自己的父进程 // procterm项目

# include # include # include

static LPCTSTR g_szMutexName = “w2kdg.ProcTerm.mutex.Suicide” ;

// 创建当前进程的克隆进程的简单方法 void StartClone() {

// 提取当前可执行文件的文件名 TCHAR szFilename [MAX_PATH] ;

:: GetModuleFileName(NULL, szFilename, MAX_PATH) ;

// 格式化用于子进程的命令行，指明它是一个EXE文件和子进程 TCHAR szCmdLine[MAX_PATH] ;

:: sprintf(szCmdLine, “\\” %s\\ “ child” , szFilename) ;

// 子进程的启动信息结构 STARTUPINFO si;

:: ZeroMemory(reinterpret_cast < void* > (&si) , sizeof(si) ) ;

si.cb = sizeof(si) ; // 应当是此结构的大小

// 返回的用于子进程的进程信息 PROCESS_INFORMATION pi;

// 用同样的可执行文件名和命令行创建进程，并指明它是一个子进程 BOOL bCreateOK = :: CreateProcess( szFilename, // 产生的应用程序名称 (本EXE文件) szCmdLine, // 告诉我们这是一个子进程的标志 NULL, // 用于进程的缺省的安全性 NULL, // 用于线程的缺省安全性 FALSE, // 不继承句柄 CREATE_NEW_CONSOLE, // 创建新窗口，使输出更直观 NULL, // 新环境 NULL, // 当前目录 &si, // 启动信息结构 &pi ) ; // 返回的进程信息

// 释放指向子进程的引用 if (bCreateOK) {

:: CloseHandle(pi.hProcess) ; :: CloseHandle(pi.hThread) ; } }

void Parent() {

// 创建“自杀”互斥程序体

HANDLE hMutexSuicide = :: CreateMutex( NULL, // 缺省的安全性

TRUE, // 最初拥有的 g_szMutexName) ; // 为其命名 if (hMutexSuicide != NULL) {

// 创建子进程

std :: cout << “Creating the child process.” << std :: endl; :: StartClone() ;

// 暂停

:: sleep(5000) ;

// 指令子进程“杀”掉自身

std :: cout << “Telling the child process to quit. ” << std :: endl;

:: ReleaseMutex(hMutexSuicide) ;

// 消除句柄

:: CloseHandle(hMutexSuicide) ; }

}

void Child() {

// 打开“自杀”互斥体

HANDLE hMutexSuicide = :: OpenMutex( SYNCHRONIZE, // 打开用于同步 FALSE, // 不需要向下传递 g_szMutexName) ; // 名称 if (hMutexSuicide != NULL) {

// 报告正在等待指令

std :: cout << “Child waiting for suicide instructions. ” << std :: endl; :: WaitForSingleObject(hMutexSuicide, INFINITE) ;

// 准备好终止，清除句柄

std :: cout << “Child quiting. ” << std :: endl; :: CloseHandle(hMutexSuicide) ; } }

int main(int arqc, char* argv[] ) {

// 决定其行为是父进程还是子进程

if (argc > l && :: strcmp(argv[l] , “child” ) = = 0) {

Child() ; } else {

Parent() ; }

return 0; }

清单3-7中的程序说明了一个进程从“生”到“死”的整个一生。第一次执行时，它创建一个子进程，其行为如同“父亲”。在创建子进程之前，先创建一个互斥的内核对象，其行为对于子进程来说，如同一个“自杀弹”。当创建子进程时，就打开了互斥体并在其他线程中进行别的处理工作，同时等待着父进程使用ReleaseMutex() API发出“死亡”信号。然后用Sleep() API调用来模拟父进程处理其他工作，等完成时，指令子进程终止。

当调用ExitProcess() 时要小心，进程中的所有线程都被立刻通知停止。在设计应用程序时，必须让主线程在正常的C++ 运行期关闭 (这是由编译器提供的缺省行为) 之后来调用这一函数。当它转向受信状态时，通常可创建一个每个活动线程都可等待和停止的终止事件。

在正常的终止操作中，进程的每个工作线程都要终止，由主线程调用ExitProcess()。接

着，管理层对进程增加的所有对象释放引用，并将用 GetExitCodeProcess() 建立的退出代码从STILL_ACTIVE改变为在ExitProcess() 调用中返回的值。最后，主线程对象也如同进程对象一样转变为受信状态。

等到所有打开的句柄都关闭之后，管理层的对象管理器才销毁进程对象本身。还没有一种函数可取得终止后的进程对象为其参数，从而使其“复活”。当进程对象引用一个终止了的对象时，有好几个API函数仍然是有用的。进程可使用退出代码将终止方式通知给调用GetExitCodeProcess() 的其他进程。同时，GetProcessTimes() API函数可向主调者显示进程的终止时间。

步骤14：单击“Build”菜单中的“Compile 3-7.cpp”命令，再单击“是”按钮确认。系统对3-7.cpp进行编译。

步骤15：编译完成后，单击“Build”菜单中的“Build 3-7.exe”命令，建立3-7.exe可执行文件。 操作能否正常进行？如果不行，则可能的原因是什么？ 能正常运行

步骤16：在工具栏单击“Execute Program”按钮，执行3-7.exe程序。 运行结果：

Creating the child process. Telling the child process to quit.

步骤17：在熟悉清单3-7源代码的基础上，利用本实验介绍的API函数来尝试改进本程序 (例如使用GetProcessTimes() API函数) 并运行。请描述你所做的工作：

GetProcess Times（）API可向主调者显示进程终止时间

本文来源：https://www.bwwdw.com/article/3nzt.html