河北工业大学操作系统实验报告linux 和windows部分

操作系统实验报告 Linux部分

2.3 Linux并发程序设计

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

? 背景知识 ? 实验目的

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

背景知识

管道是Linux中最常用的进程间通信IPC机制。利用管道时，一个进程的输出可成为另外一个进程的输入。当输入输出的数据量特别大时，这种IPC机制非常有用。可以想象，如果没有管道机制，而必须利用文件传递大量数据时，会造成许多空间和时间上的浪费。

在Linux中，通过将两个file结构指向同一个临时的索引节点，而两个索引节点又指向同一个物理页而实现管道。 实验目的

1) 通过在Linux进程之间进行的通信实例来学习并发程序设计的方法。 2) 通过Linux进程通信的程序设计与实现，进一步熟悉操作系统的进程概念，理解Linux进程管理概念。

3) 通过阅读和分析Linux实验程序，学习Linux程序设计、调试和运行的方法。 工具/准备工作

在开始本实验之前，请回顾教科书的相关内容。 需要准备一台运行Linux操作系统的计算机。 实验内容与步骤

并发程序的设计关键是使用创建进程的系统调用，使一个程序运行时可以生成几个同时运行的程序，如果程序中没有创建进程的动作则为顺序程序设计。

本实验中的并发程序例子完成两个程序child和father之间的数据传递工作，具体做法分为四步。

步骤1：编制并发程序pipeline.c。

单击红帽子，在“GNOME帮助”菜单中单击“附件”-“文本编辑器”命令，在文本编辑中键入程序并保存为pipeline.c。

在该程序中定义管道和文件描述符，并且创建子进程child。该程序用到的系统调用有pipe() 、dup() 、fork() 、close、execl() 、exit，它们的功能分别是建立管道、复制文件描述符、创建进程并使子进程与父进程有相同的程序正文、关闭文件描述符、用指定文件覆盖调用程序、撤销当前进程。

清单4-5 pipeline.c

// 定义管道程序

# define STD_INPUT 0 # define STD_OUTPUT 1

int fd[2];

// 定义标准输入设备描述符 // 定义标准输出设备描述符

main() {

static char process1[]=\ pipe(fd); // 定义管道 pipeline(process1,process2); // 调用自定义函数pipeline() exit(1); // 程序结束 }

pipeline(char* process1,char* process2) {

int i; while ((i=fork())==-1); if (i) { close(fd[0]); close(STD_OUTPUT); dup(fd[1]); close(fd[1]);

execl(process1, process1, 0);

printf(\ } else { close(fd[1]); close(STD_INPUT); dup(fd[0]); close(fd[0]); execl(process2,process2,0); printf(\ } exit(2);

}

// 创建进程，直到创建成功为止

// 关闭管道输入描述符 // 关闭标准输出描述符1

// 指定标准输出描述符1为管道写指针 // 关闭原始管道写指针

// 用程序father覆盖当前程序 // execl()执行失败

// 关闭管道输出描述符 // 关闭标准输入描述符0

// 指定标准输入描述符0为管道读指针 // 关闭原始管道读指针

// 用程序child覆盖当前程序 // execl()执行失败 // 程序结束

步骤2：编制“管道写”程序father.c作为父进程的一部分工作。其内容如下：

单击红帽子，在“GNOME帮助”菜单中单击“附件”-“文本编辑器”命令，在文本编辑中键入程序并保存为father.c。

清单4-6 father.c

main() {

static char string[] = “Parent is using pipe write.” ; int len;

len = sizeof(string) ; write(l, string, len) ; /* 将string中的内容写入管道中 */ printf(“parent, parent, parent \\n \\n \\n” ) ; exit(0) ; }

步骤3：编制“管道读”程序child.c作为子进程的一部分工作。其内容如下：

单击红帽子，在“GNOME帮助”菜单中单击“附件”-“文本编辑器”命令，在文本编辑中键入程序并保存为child.c。

清单4-7 child.c main() {

char output[30] ;

read (0, output, 30) ; /* 从管道中读数据并存入output中 */ printf(“%s \\n child, child. \\n” , output) ; return(0) ; }

步骤4：编译。

cc –o child child.c cc –o father father.c

cc –o pipeline pipeline.c

步骤5：运行。

./pipeline

若运行不成功，则应该用文本编辑器对源程序进行修改调试。

2.4 Linux重定向和管道

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

? ? ? ? ?

背景知识 实验目的

工具/准备工作 实验内容与步骤 可选练习

背景知识

在本实验中，我们将使用高级Linux命令来完成重定向和管道。每一个Linux命令都有一个源作为标准输入，一个目的作为标准输出。命令的输入通常来自键盘 (尽管它也可以来自文件) 。命令通常输出到监视器或者屏幕上。Linux计算环境使用重定向可以控制命令的I/O。当试图把命令的输出保存到一个文件，以供以后查看的时候是很有用的。通过管道，可以取得一个命令的输出，把它作为另一个命令的进一步处理的输入。

有几个元字符可用于输入/输出重定向符号：输出重定向使用右尖括号 (>，又称大于号) ；输入重定向使用左尖括号 (<，又称小于号) ；出错输出重定向使用右尖括号之前有一个数字2 (如2>) 。本实验重点在输出重定向。

重定向命令的格式是：

Command Redirection-Symbol File (text file or device file)

标准输出比标准输入或标准出错更经常被重定向。许多命令，如ls、cat、head和tail产生标准输出到屏幕上，常常会希望把这个输出重定向到一个文件中，以便将来查看、处理或者打印。通过替换文件名，可以截获命令的输出，而不是让它到达默认的监视器上。

最强大的元字符之一是管道符号 (|) 。管道取得一个命令的标准输出，把它作为标准输入传递给下一个命令 (通常为more命令、lp (行式打印机) 命令或者一个文件处理命令，如grep或sort) 。必须在管道的每边都有一个命令，命令和管道之间的空格是可选的。

管道命令的格式是： command | command 实验目的

通过重定向和管道操作：

1) 熟悉输入/输出 (I/O) 重定向； 2) 把标准输出重定向创建一个文件； 3) 防止使用重定向的时候覆盖文件； 4) 把输出追加到一个现有的文件中；

5) 把一个命令的输出导入到另一个命令中。 工具/准备工作

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

您需要做以下准备：

1) 由指导老师分配的登录用户名 (如user2) 和口令。

2) 一台运行Red Hat Linux操作系统，带有GNOME的计算机。 实验内容与步骤

1. 使用重定向标准输出符号 2. 使用管道符号

在本实验中将会用到下列命令： pwd： 显示当前的工作路径。 cd： 改变目录路径。 ls： 显示指定目录的内容。 more： 分页显示文件的内容。这是用于显示文本文件的首选方法。 head： 截取显示文件的开头部分 (默认为开头10行) 。 tail： 截取显示文件的结尾部分 (默认为最后10行) 。 cal： 有关日历的命令。 set： shell特性的设置。 echo： 显示变量的值。 ps： 显示当前进程。 data： 显示或设置系统日期和时间。 grep： 查找文件中有无指定的关键字。

提示：如果对命令的格式不清楚，可以用man命令请求帮助，即： man more

步骤1：开机，登录进入GNOME。

在GNOME登录框中填写指导老师分配的用户名和口令并登录。 步骤2：访问命令行。

单击红帽子，在“GNOME帮助”菜单中单击“系统工具”-“终端”命令，打开终端窗口。

1. 使用重定向标准输出符号

步骤3：重定向标准输出，创建一个文件。

右尖括号或称大于符号 (>) 把命令的输出发送到一个文件中：使用单个右尖括号，当指定文件名不存在的时候，将创建一个新文件；如果文件名存在，它将被覆盖。(注意：命令、重定向符号和文件名之间的空格是可选的) 。

重定向标准输出命令的格式是： command > file

1) 为核实当前所在目录位置，使用什么命令？ pwd

如果当前位置不在主目录中，使用什么命令可以改变到主目录中？ cd /_

2) 如果希望把文件和目录列表截获，存储为主目录中的一个文件，这样可以追踪主目录中有什么文件。使用什么命令，把长文件列表的输出重定向，创建一个叫做homedir.list的文件。 ls >homedir.list_

3) 新文件homedir.list被放在哪里？

根目录_ 使用ls命令核实新文件存在。

4) 使用什么命令，以一次一屏的方式，来查看刚才创建的文件内容？ _ls –l|more homedir.list

5) 使用head命令截获homedir.list文件的前10行，通过重定向，创建一个叫做dhomedir.list-top-10的新文件。应该使用什么命令？

head –10 homedir.list >dhomedir.list-tail-10 使用more命令查看文件的内容。

6) 使用tail命令，截获homedir.list文件的最后10行，通过重定向，创建一个叫做dhomedir.list-top-10的新文件。使用什么命令？

tail –10 homedir.list >dhomedir.list-top-10

使用more命令查看文件的内容。

7) 截获cal -y命令的输出，把它存到名为calendar的文件中。查看文件的内容。截获了什么

cal –y>calendar |more calendar 截获了2011年12个月份的日历

8) 截获cal 2010命令的输出，把它存到名为calendar的文件中。查看文件的内容。其中有什么内容？

cal -y 2010 > calendar |more calendar 2010年12月份的日历

日历有什么变化？

不是2011年，变成2010年了 步骤4：防止使用重定向的时候覆盖文件。 在bash shell中，一个叫做noclobber的选项可以用来设定防止在重定向的过程中覆盖文件。可以在命令行中使用$set -o noclobber命令来完成。o代表选项。

为了重新激活clobber特性，使用$set -o noclobber；撤消则用set +o noclobber。

如果你使用的是csh shell，为了激活/撤消C shell中的clobber特性，使用set noclobber和unset noclobber。

1) 输入命令，打开shell中的noclobber选项。输入什么命令？

set –o noclobber_ 2) 输入命令ls -l > homedir.list，结果是什么？ bash:homedir.list:cannot overwrite existing file.因为clobber选项防止了 重定向过程覆盖文件___________________________________

3) 输入命令ls -l > homedir.list2，结果是什么？

不能重定向成功 步骤5：向现有的文件追加输出。

如果想向一个现有的文件追加 (添加到末尾) 文本而不是覆盖它，可以使用双右尖括号 (>>) 。这个选项当文件不存在的时候，会创建一个新文件，或者追加到已有文件。

追加命令的格式是： command >> file

1) 输入命令，显示“Happy Bday”一行字，使用重定向符号截获输出，把它存到叫做bday4me的文件中。使用什么命令？

echo “Happy Bday” >>bday4me

2) 输入命令，显示 一行字，使用双重定向符号，把输出追加到bday4me文件中。查看bday4me文件的内容。其中有什么？

echo “HELLO” >>bday4me （HELLO是自己随便键入的） 3) 输入命令，显示您出生年月的日历 (如果在1985年的6月出生，输入cal 6 1985) ，使用双重定向符号，把输出追加到bday4me文件中。使用什么命令？

cal 06 1989 >>bday4me_

4) 查看bday4me文件的内容。注意这3个命令的输出在bday4me文件中已经被组合起来了。您是在一周中的哪一天出生的？

周一 2. 使用管道符号

步骤6：把命令的输出导入到另一个命令中。

1) 使用管道元字符，发送ls -l命令的输出，作为more命令的输入 (注意：如果在当前目录中没有太多的文件，使用 /etc目录获取长列表) 。把输出作为more命令的输入的时候，得到什么结果？

输入命令ls –l |more 结果以一屏一次的方式显示在屏幕上 2) 查看使用ls –l | more命令列出来的文件，注意创建或修改的日期。为了查看在同一个月被创建或修改的文件或目录的列表，可以使用grep命令对那个月进行搜索。当月份显示在列表中的时候，指定它 (例如：Oct) 。输入命令ls -1 | grep Oct (或者想查找的月份) 。

结果是什么？

只显示10月的目录_ 3) 目录总是4096字节大小。输入命令ls -1 | grep 4096。产生的列表是什么？

4096字节大小的目录显示 4) 可以使用多个管道连接多个命令。输入取得长文件列表输出的命令，把它输入给tail命令，然后到sort命令。输入的命令是： ls –l|tail|sort

5) ps (进程状态) 命令用于查看Linux系统中运行什么进程。把ps -e命令的输出输入给more命令。-e选项将给出每一个在系统中运行的进程。把输出输入到more命令中的结果是什么？

输入命令_ps –e|more____显示所有系统中运行的程序___ 步骤7：删除在本实验中创建的文件和目录。 步骤8：关闭终端窗口，注销。 可选练习

1. 使用set -o命令不指定任何选项，可以查看noclobber特性是否已经打开。

1) 输入set -o。noclobber特性打开还是关闭的？如果它是关闭的，打开它。使用什么命令？

关闭set –o noclobber 2) 永久的关闭noclobber特性。使用什么命令？ set +o noclobber 2. 可以把管道和重定向组合起来使用，达到特殊的效果。输入命令创建一个名为top5.list的文件，内容为主目录中的头5行记录，使用什么命令？ ls –l|head –5 >top5.list

3.4 管理Linux系统进程

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

? ? ? ?

? 背景知识 ? 实验目的

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

背景知识

在本实验中，我们将使用Linux命令工作，来标识和控制系统进程。Linux操作系统使用进程管理作业，进程由系统或者用户初始化。用户在Linux环境下执行的作业大多数都会启动一个进程。进程可以启动或者派生一个子进程，这样创建了一个进程层次结构或者进程树，类似于具有父子关系的文件系统层次结构。

可以使用ps (进程状态) 命令工作，监控系统进程，使用kill命令终止不想要的进程。 实验目的

1) 2) 3) 4) 5) 6) 7) 8) 9) 回顾系统进程的概念，加深对Linux / UNIX进程管理的理解。 回顾ps命令和选项。

列出当前shell中的进程。

列出运行在系统中的所有进程。 根据命令名搜索特定的进程。 确定一个进程，终止它。 使用kill命令终止进程。 根据用户查找和终止进程。 根据命令名终止进程。

工具/准备工作

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

1) 由指导老师分配的登录用户 ID (如user2) 和口令。 2) 一台运行Red Hat Linux操作系统的计算机。 实验内容与步骤

步骤1：登录进入GNOME。

在Linux登录框中填写指导老师分配的用户名和口令，登录Linux系统。 步骤2：访问命令行。

单击红帽子，在“GNOME帮助”菜单中单击“系统工具”-“终端”命令，打开“终端”窗口。

步骤3：回顾系统进程概念。

每个运行的程序都会创建一个进程，进程分配到一个唯一的进程标识符 (PID) 。PID被系统用于标识和跟踪进程，直到进程结束。操作系统内核管理所有进程的初始化和终止。每一个进程都要求系统资源 (例如CPU时间和RAM空间) 在其中工作。当进程启动的时候，操作系统把系统资源分配给每个进程，当进程终止的时候，系统回收这些资源。在Linux系统启动的时候，首先启动的两个进程是sched (调度) 和init (初始化) ，它们管理着其他进程。Linux系统中有几种不同类型的进程：

守护进程：由Linux内核启动的进程，为了特定目的而存在。例如，lpsched守护进程

存在只是为了处理打印作业。

父进程：派生其他进程的进程是父进程。一个叫做init的守护进程是第一个调用的进程。每一个进程，除了init之外，都有一个父进程。

子进程：由其他进程派生出来的进程叫做子进程。

孤儿进程：在进程返回输出之前，它的父进程结束了，这样的进程叫做孤儿进程。 僵进程：子进程没有带着输出返回给父进程。这样的进程在系统中变成丢失的进程。 使用此前的信息，完成以下填空：

1) Linux系统中，几乎每一个启动的进程，都会由内核分配一个唯一的PID 进程标识符，用于跟踪从进程启动到进程结束。

2) 当启动新进程的时候，内核也给它们分配系统资源，如 CPU时间和RAM空间 。

3) 永远不向父进程返回输出的进程叫做 僵进程 。 4) 由父进程派生出来的进程叫做 子进程 。 5) 父进程 是一个派生另一个进程的进程。

6) 运行用于提供服务的Linux系统进程是 守护进程 。 7) 如果父进程在子进程之前结束，它创建了一个 孤儿进程 。 步骤4：回顾ps命令和信息。

ps命令用于列出当前系统中运行的进程。

如果一个进程耗时太长，或者看上去好像已经终止了，表现为一个终端窗口不再响应或挂起，通常需要使用ps查看系统中的进程。通过列出进程，可以查看初始化进程的命令或程序的名字，以及所有它派生出来的子进程。通过多次执行ps命令，查看进程的时间——进程占用的CPU时间，可以检查一个进程是否还在运行。如果时间小再增长，那么进程可能已经终止了。如果进程占用太长的时间或者已经停止，可以使用ps命令检查进程的进程ID (PID) ，然后杀死进程。

ps命令的输出将显示PID号和与其相关的命令或程序。PID号通常用于终止一个进程。ps命令 ( ps [-options] ) 的3个主要选项如下表所示。

表3-5 ps命令选项

ps选项 Ps ps –e ps –f ps -u userid

基本的ps命令显示在当前shell中的进程信息，用户只能够查看在这个终端窗口中初始化的进程。输入ps命令，将结果填入表3-6中。

意义 无选项 每一个 完全 用户 功能 显示当前shell或终端窗口中，当前用户的进程信息 显示系统中每一个进程的信息 产生一个完全列表，给出每个进程的所有可用信息 显示特定用户的所有进程

表3-6 实验记录

PID 4848 4493

从当前终端窗口中，练习使用给出的每个选项的ps命令。

输入 ps -f 命令，显示运行在系统中的某个进程的完全信息，填入表3-7中。

表3-7 实验记录

UID student student ps -f命令输出的各栏标题见表3-8所示。

表3-8 ps -f栏标题

值 UID PID PPID C STIME TTY TIME CMD

步骤5：列出系统中运行的所有进程。

输入 ps -ef 命令，显示运行在系统中的各个进程的完全信息。执行该命令，并与ps –f命令的输出结果对照，一致吗？有何不同

不一致，用户类型增加了。 注意分析当前终端窗口中的输出结果：

初始化进程的用户ID 进程的进程标识号。PID可以用来杀死进程 进程的父进程标识号 进程的优先级 进程的启动时间 控制进程终端的终端举型 进程使用的CPU时间的数量 命令名守护进程 (执行的程序的名字) 描述 PID 4848 4901 PPID 4846 4848 C 0 0 STIME 08:30 08:49 TTY pts/0 pts/0 TIME 00:00:00 00:00:00 CMD bash ps -f pts/0 pts/0 TTY TIME 00:00:00 00:00:00 bash ps CMD

· 因为在口令输入的时候看不见它们，当知道自己键入了错误字符的时候，使用Ctrl + U擦除密码，重新开始输入。

如果输入一个命令，如ls –R/，有时候，会在按下回车键之前想擦除命令行。输入一个命令，在接下回车键执行命令之前按下Ctrl + U。结果是什么？

整行命令被擦除 步骤4：使用file命令确定文件类型。

在Linux系统中可以找到许多类型的文件。文件类型可以通过使用file命令来确定。当一个用户试图打开或阅读一个文件的时候，这个信息很重要。确定文件类型可以帮助一个用户决定使用哪个程序或命令来打开这个文件。这个命令的输出最常见的是如下几种：文本文件、可执行文件或数据文件。

1) 文本文件：包括ASCII或英语文本、命令文本和可执行的shell脚本。这种类型的文件可以使用cat或more命令读取，可以使用vi或其他文本编辑器编辑。

单击红帽子，在“GNOME帮助”菜单中单击“辅助设施”-“Text Editor”命令，在文本编辑中键入适当内容并保存为test文件。

使用file命令来确定test文件的文件类型。它是哪种类型的文件？ ASCII text_

2) 可执行 (或二进制) 文件：包括32位的可执行文件和可扩展链接格式(ELF) 编码文件，和其他动态链接的可执行文件。这种文件类型表示这个文件是一个命令或程序。

单击红帽子，在“GNOME帮助”菜单中单击“办公”-“OpenOffice.org Writer”命令，建立一个文档如ww.sxw。

使用file命令确定你所建立的文件类型。它是哪种类型的文件？(注意文件名部分必须包括扩展名，如file ww.sxw 。)

可执行文件

3) 数据文件：数据文件是由系统中运行的应用创建的。在某些情况下，文件的类型是会说明的。例如，FrameMaker (桌面印刷软件) 文档。

使用file命令确定dir1/coffees子目录中beans文件的文件类型。它是什么文件类型的？ Koffice application/x-kword 步骤5：使用strings命令。

strings命令可以用于打印可执行文件或者二进制文件中的可读字符。

一些有编程背景的人，可以解释strings产生的输出。这个命令在这里只是作为一个展示可执行文件中可打印字符的方法来介绍。strings命令必须用于读取可执行文件，如 /usr/bin/cat。在大多数情况下，strings命令也可以给出命令的使用语法。

使用strings命令查看 /usr/bin/cal文件的可读字符。列出strings命令中的一些输出。 _/lib/ld-linux.so.2 libc.so.6 strerror wcstombs wcscpy

optind --progname getopt vwarn stderr wcswidth util-linux-2.11y

步骤6：使用cat命令显示文件的内容。

cat命令在屏幕上显示一个文本文件的内容。它常用于显示如脚本文件 (类似批处理文件) 这样的短文本文件。如果文件超过一屏的话，必须使用一个屏幕可以滚动的窗口，如GNOME环境中的终端窗口。

键入 ls /dev > dev1

使用cat命令显示主目录中dev1文件的内容。文本的显示出现了什么情况？

显示出了很长一串文本内容，必须按滚动条才能看全部文本内容

步骤7：使用more命令显示文件的内容。

more命令是一个用于显示文本文件首选的方法，因为它会自动的一次显示一屏文件内容。如果文件的信息比一屏更长，屏幕的底部显示如下的信息：--More-- (n％) (文件的n％已经显示) 。按下回车键，继续一次显示一行信息。空格键将继续一次显示一屏内容。

使用more命令显示主目录中dev1文件的内容。文本的显示出现了什么情况？

显示出了第一页文本。每按一次回车显示下一行，每按一次空格显示下一页

步骤8：使用head命令显示文件的一部分。

head命令用于显示一个或多个文本文件的前n行。在默认情况下，如果没有给出 -n选项，将显示前10行。当您只想查看文件的开始的几行，而不管文件的大小的时候，head命令是很有用的。

1) 单独使用head命令，显示主目录中dev1文件的开始部分。显示了多少行？ 10行

2) 使用带 -n选项的head命令，显示主目录中dante文件的前20行。您输入什么命令？ head –20 dante

步骤9：使用tail命令显示文件的一部分。

使用tail命令，显示文件的最后几行。在默认情况下，如果没有指定 -n选项，将显示最后10行。当检查大型日志文件最近输入内容的时候，tail命令是很有用的。备份工具程序常把备份哪个文件和什么时候做的备份，写到日志文件中去。一个备份日志文件中最后的输入通常是备份文件的总数和备份是否成功完成的信息。-n选项显示了文件的最后n行。

单独使用tail命令，显示主目录中dante文件的末端。显示了多少行？ 10行_

步骤10：通过使用wc命令，确定行数、单词数和字符数。

wc (单词计数) 命令可以用于显示文本文件的行数、单词数、字节数或者字符数。当确定文件特征或者当比较两个文件的时候，这个命令是很有用的。使用不带选项的wc将给出文件的行数、字节数。使用带一个选项的wc，可以确定想查看的哪一项内容。

使用wc命令确定主目录中dev1文件的行数、单词数和字符数。有多少行、多少个单词和多少个字符？

5374行5374个单词33706个字符

步骤11：使用wc计算目录条目的数目。

使用wc和ls命令确定主目录中条目 (文件和目录) 的数目。为此，必须把ls命令的输出导入到wc命令中。

更多符号是竖线，和后斜线 (\\) 在同一个键上。在命令行提示行下，输入命令ls l wc -w。有多少个文件和目录名 (单词) ？

8个

步骤12：使用diff命令确定文件之间的不同之处。

diff (不同) 命令用于比较2个文本文件，找出在它们之间的不同之处。wc命令可以比较文件，因为它计算行数、单词数和字符数。有可能2个文件有相同的行数、单词数和字符数，但是字符和单词不同。diff命令可以从实际上找出文件之间的不同。

这个命令的输出把2个文本文件之间的不同一行一行的显示出来。diff命令有2个选项：-i 和 -c。-i选项忽略字母的大小写，例如A和a相等。-c选项执行细致的比较。

单击红帽子，在“GNOME帮助”菜单中单击“辅助设施”-“Text Editor”命令，创建两个文件fruit1和fruit2，并键入适当内容。

使用diff命令执行细节比较，确定fruit1文件和fruit2文件之间的区别。 在fruit1文件和在fruit2文件中，哪几行是不同的？

fruit1:ghaoujogh bngab ba fruit2:GNAW BALBNA

_______g joaiwje jannb _______________BHNA;OBN AJBN______ 1) cat命令： · 对fruit1文件使用cat命令。 · 对fruit2文件使用cat命令。

· 键入命令行cat fruit1 fruit2 > filex。 · 对filex文件使用cat命令。上面的命令行做了什么工作？

把fruit1和fruit2的文本内容合并在了一起，成为filex文件的文本内容

2) 可以使用哪2个命令来确定2个文件是否相同？

diff fruit1 fruit2和cat fruit1,cat fruit2__

步骤13：关闭终端窗口，注销。

2. 基本的命令行文件管理

步骤14：回顾Linux的文件和目录命名规则。

在本实验中，我们将创建文件和目录，因此，在开始之前，先来回顾一下Linux文件和目录的命名规则和指导方针。

1) 最大长度：组成文件和目录名最大长度为255个数字字母字符。一般来说，应该尽可能的保持文件名短但是仍然有意义。

2) 非数字字母字符：一些非数字字母字符或者元字符是可用的：下划线 (_) 、连字符号 (-) 和句点 (.) 。这些元字符可以在文件或目录名中使用多次(Feb.Reports.Sales是一个有效的文件或目录名) 。尽管shell允许把星号 (*) 、问号(?) 和发音符号 (~) 、方话号 ([ ]) 、&、管道 [ | ] 、引号 (“”) 和美元符号 ($) 在文件名中使用，但这不是推荐的，因为这些字符对于shell有特殊的意义。分号 (;) 、小于号 (<) 和大于号 (>) 是不允许作为文件名的。

3) 文件名扩展：文件名可以包含一个或多个扩展名。扩展名常被一个应用追加到文件的末端。扩展名通常是1个到3个字符，追加到文件名的末端，之前有一个句点 (.) 。当命名文件的时候，您可以选择使用这个规则。

4) 目录名的扩展名：目录名一般不包含扩展名，但是也没有规则反对这一点。

5) 大小写敏感：Linux文件和目录名是大小写敏感的。Project1和projectl不是同一个文件。在一个目录中，不能够有两个文件有着同样的名字。一般规则都是使用小写字母。

检查表7-1中的文件名，指出它们是否是有效或者推荐的Linux文件或目录名，为什么是或为什么不是。

表7-1 实验记录

文件名 12345abcde678 Hobbies: 2 Adcd-123 Sales*repts*2001 D.projects.bj.2001 Projects>1.bj-2001 是否为Linux文件或目录名 是 不是 是 不是 是 不是 为什么是或为什么不是 文件或目录名没超过256个字符 空格不可以在文件或目录名中使用 “-” 可以在文件或目录名中使用 “*”不可以在文件或目录名中使用 “.” 可以在文件或目录名中使用 大于号（>）不允许作为文件名

步骤15：使用touch命令创建文件。

每次创建一个新的字处理文档或者电子数据表，就是正在创建一个新文件，应该符合之前提到的文件命名规则。也必须拥有创建文件的目录的足够权限。

使用touch命令，可以同时创建一个或多个文件。一些应用要求在写文件之前，文件必须存在。touch命令对于快速创建需要处理的文件很有用。也可以使用touch命令更新文件被访问的时间和日期，使文件可以再次被备份。当创建文件或目录的时候，可以指定绝对和相对的路径名。

命令格式：

touch filename (s)

1) 在主目录中使用touch命令创建一个名为newfile的文件，应该使用什么命令？ _touch newfile

2) 使用touch命令在这个目录中创建另一个叫做filenew的新文件，应该使用什么命令？

touch filenew

3) 输入命令显示practice目录中的文件的长列表。创建的文件列出来了吗？

列出来了

4) 谁是文件的所有者？ root

5) 和文件关连的组是什么？ root

6) 创建的日期和时间是什么？

12月15日 09：30 7) 文件的大小是多少？

26743 8) 使用file命令确定newfile的文件类型。它是哪一类的文件？ ASCII text

9) 使用touch命令同时创建3个文件：new1、new2和new3，应该使用什么命令？ touch new1 new2 new3 10) 输入命令显示practice目录中文件的长列表。创建的3个新文件列出来了吗？ 列出来了

步骤16：使用mkdir命令创建新目录。

mkdir (创建目录) 命令用于创建目录或文件夹。目录可以包含其他目录，称为子目录，它们可以包含文件。

目录可以使用或者绝对路径名或者相对路径名创建。可以在同一行中指定多个目录名，创建多个新目录。必须有创建目录的足够权限。

mkdir directory_name (s)

1) 从主目录中，使用相对路径名改变到practice目录中。使用什么命令？ cd /practice_ 2) 使用mkdir命令，在这个目录中创建一个叫做newdir的子目录。使用什么命令？ mkdir /newdir_

3) 输入命令，显示practice目录中文件和目录的长列表。创建的目录列出来了吗？ 列出来了 4) 目录的所有者是？

root 5) 文件的大小是多少？

4096 6) 使用file命令确定newdir文件的类型。它是哪一类的文件？ 目录文件directory_

7) 如果名字中没有字符dir，采取别的什么方法来识别出它是一个目录？ 颜色识别，目录是蓝色的

8) mkdir命令创建3个目录，目录名分别为high、medium和low，应该使用什么命令？ mkdie /high mkdir /medium mkdir /low 9) 用ls命令检查创建是否成功？ 成功

步骤17：使用rm命令删除文件。

rm目录可以删除单个文件或多个文件。可以通过在rm命令之后指定文件的名字，或者使用星号 (*) 和问号 (?) 元字符，同时删除几个文件。在Linux系统中删除的文件是永远被删除了，除非使用图形界面删除文件，它们才能够被恢复。rm命令可以带 –i (交互) 选项使用，它在删除文件之前会提示用户。使用rm -i命令作为防范，避免误删文件：

rm [-i] filename (s)

1) 使用rm命令删除早先在practice目录中创建的newfile文件，应该使用什么命令？ rm –r practice/newfile

2) 输入命令显示practice目录中文件的长列表。创建的文件还在吗？ 不在

3) 使用带 -i选项的rm命令，删除早先在practice目录中创建的filenew文件。交互式选项起到什么作用？

在删除之前提示用户,避免误删文件

4) 删除早先创建的三个名为new1、new2和new3的文件。使用问号 (?) 通配符使用一个命令删除所有三个文件。使用什么命令？

rm new?_

5) 输入命令，显示practice目录中文件的长列表。三个文件还在吗？ 不在

6) 还有其他的什么方法来删除new1、new2和new3文件？ rm new[1-3]_

步骤18：使用rm -r命令删除目录。

rm -r目录用于删除目录。它将删除从目标目录开始的目录，包括所有的子目录和文件。当rm命令带 -r信息使用的时候，它可以删除单个目录 (空或不空) 或目录树的整节。rm命令可以带 -i选项使用，它在删除目录之前会提醒用户：

rm –r [i] directory_name (s)

1) 删除早先创建的newdir子目录，使用什么命令？ rm –ri practice/newdir_

2) 输入命令显示practice目录中文件的长列表，创建的子目录还在吗？ 不在 3) 改变到早先创建的mediurn子目录中，输入什么命令？ cd practice/mediurn 4) 删除早先创建的low子目录，使用什么命令？ rm –ri practice/low 5) 用相对路径名和快捷方式，改变回到practice子目录中，应使用什么命令？ cd .

6) 使用一个命令删除high和medium子目录，应使用什么命令？ rm –ri high medium_ 步骤19：练习所学习到的内容。

通过在practice目录中创建一个三级的目录树，练习使用touch、mkdir和rm命令。试着使用有意义的目录名。记住可以使用一个命令创建整个目录结构。在每个目录中创建多个文件。记住可以使用一个命令创建多个文件。

结束的时候，请删除实验时创建的文件和目录。 步骤20：关闭终端窗口，注销

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

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

表示： 建立子进程 2) 等待一段时

间

之

后

子

进

程

杀

死

自

身

进

程

表示： 使子进程退出

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

GetProcessTimes() API函数可向主调者显示进程的终止时间____

Windows部分

班级：网络C091班

姓名：赵丹

学号：098620

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 当前机器中由你打开，正在运行的应用程序有：

Word-3.1我“任务管理器”的进程管理；文件夹-windows部分

Windows“任务管理器”的窗口由3个选项卡组成，分别是：

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

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

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

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

表3-1 实验记录

映像名称 kxescore.exe sqlservr.exe Lbkeybsc.exe jps.exe svchost.exe lsass.exe services.exe winlogon.exe csrss.exe smss.exe spoolsv.exe system system Idle 用户名 SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM SYSTEM CPU 00 00 00 00 00 00 00 00 00 00 00 00 00 内存使用 9,432K 9,628k 2,700k 1,404k 5,300k 1,344k 6,676k 3,372k 8,848k 428k 4,056k 316k 13k

服务 (SERVICE) 进程有__3_个，填入表3-2中。

表3-2 实验记录

映像名称 svchost.exe svchost.exe taskmgr.exe 用户名 NETWORK SERVICE NETWORK SERVICE LOCAL SERVICE CPU 00 00 00 内存使用 3,860K 4,620K 4,084K 用户进程有__10__个，填入表3-3中。

表3-3 实验记录

映像名称 sefastinstalll conime.exe IEXPLORE.EXE 用户名 Administrator Administrator Administrator CPU 00 00 00 内存使用 8,372k 4,320k 11,720k sqlmangr.exe ctfmon.exe kxetray.exe jusched.exe WINWORD.EXE cinime.exe expiorer.exe Administrator Administrator Administrator Administrator Administrator Administrator Administrator 00 00 00 00 00 00 00 6,888k 3,800k 2,960k 5,760k 48,788k 4,728 28,168k

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

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

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

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

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

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

丢失未保存数据，修改后的数据也未保存！

2. 显示其他进程记数器

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

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

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

印象名称 PID CPU CPU时间 内存使用 通过对“查看”菜单的选择操作，可以在“任务管理器”中更改显示选项： · 在“应用程序”选项卡上，可以按详细信息、大图标或小图标查看。 · 在“性能”选项卡上，可以更改CPU记录图，并显示内核时间。“显示内核时间”选项在“CPU使用”和“CPU使用记录”图表上添加红线。红线指示内核操作占用的CPU资源数量。

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

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

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

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

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

更改后并无太多影响，system idle process代表系统空闲进程，观察其CPU占用为99

说明当前计算机基本处于空闲状态。虽然可以把进程优先级调整但是都没有太大影响。但是如果处于多进程同时占用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 PID 1440 03 CPU CPU时间 0：00：38 内存使用 43，792

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

请描述使用第二个实例占用的内存与使用第一个实例时的内存对比情况： 映像名称 WINWORD.EXE safeboxTRAY.EXE PID 3088 1520 CPU 00 00 CPU时间 0：00：16 0：00：03 内存使用 33，268K 972K 步骤4：未分页合并内存。 估算未分页合并内存大小的最简单方法是使用“任务管理器”。未分页合并内存的估计值显示在“任务管理器”的“性能”选项卡的“核心内存”部分。

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

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

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

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

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

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

表5-2 实验记录 映像名称 WINWORD.EXE PID 1440 内存使用 44,552K 页面缓冲池 255K 非页面缓冲池 32K

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

步骤5：提高分页性能。

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

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

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

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

表5-3 实验记录

卷 布局 类型 文件系统 容量 状态 (C:) （D：） （E：） 磁盘分区 磁盘分区 磁盘分区 基本 基本 基本 FAT32 FAT FAT32 19.52GB 493M 10.29GB 状态良好（系统） 状态良好 状态良好

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

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

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

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

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

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

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

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

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

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

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

请记录： 物理内存 (K) 总数： 261616 可用数： 79780 系统缓存： 95365 认可用量 (K) 总数： 350584 限制： 632696 峰值： 378640

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

分页文件的大小。

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

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) 当前计算机的实际内存大小为： 512MB 阅读和分析程序5-1，请回答问题：

1) 理论上每个Windows应用程序可以独占的最大存储空间是： 4GB 2) 在清单5-1程序中，用于检查系统中虚拟内存特性的API函数是： GetSystemInfo(&si)

提示：可供应用程序使用的内存空间实际上已经减去了开头与结尾两个64KB的保护区。虚拟内存空间中的64KB保护区是防止编程错误的一种Windows方式。任何对内存中这一区域的访问 (读、写、执行) 都将引发一个错误陷井，从而导致错误并终止程序的执行。也就是说，假如用户有一个NULL指针 (地址为0) ，但仍试图在此之前很近的地址处使用另一个指针，这将因为试图从更低的保留区域读写数据，从而产生意外错误并终止程序的执行。

3.3 Windows 2000进程的“一生”

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

? ? ? ?

? 背景知识 ? 实验目的

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

背景知识

1. 创建进程

2. 正在运行的进程 3. 终止进程

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

1. 创建进程

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

表3-4 CreateProcess() 函数的参数 参数名称 LPCTSTR lpApplivationName LPCTSTR lpCommandLine LPSECURIITY_ATTRIBUTES lpProcessAttributes LPSECURIITY_ATTRIBUTES lpThreadAttributes BOOL bInheritHandle DWORD dwCreationFlage LPVOID lpEnvironment 一种标志，告诉系统允许新进程继承创建者进程的句柄 特殊的创建标志 (如CREATE_SUSPENDED) 的位标记 向新进程发送的一套环境变量；如为null值则发送调用者环境 使用目的 全部或部分地指明包括可执行代码的EXE文件的文件名 向可执行文件发送的参数 返回进程句柄的安全属性。主要指明这一句柄是否应该由其他子进程所继承 返回进程的主线程的句柄的安全属性 LPCTSTR lpCurrentDirectory STARTUPINFO lpStartupInfo LPPROCESS_INFORMATION lpProcessInformation 新进程的启动目录 STARTUPINFO结构，包括新进程的输入和输出配置的详情 调用的结果块；发送新应用程序的进程和主线程的句柄和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 (进程标识号) 。本实验程序清单3-6中列出了这一API函数与GetVersionEx() 的共同作用，可确定运行进程的系统的版本号。

3. 终止进程

所有进程都是以调用ExitProcess() 或者TerminateProcess() 函数结束的。但最好使用前者而不要使用后者，因为进程是在完成了它的所有的关闭“职责”之后以正常的终止方式来

调用前者的。而外部进程通常调用后者即突然终止进程的进行，由于关闭时的途径不太正常，有可能引起错误的行为。

TerminateProcess() API函数只要打开带有PROCESS_TERMINATE访问权的进程对象，就可以终止进程，并向系统返回指定的代码。这是一种“野蛮”的终止进程的方式，但是有时却是需要的。

如果开发人员确实有机会来设计“谋杀”(终止别的进程的进程) 和“受害”进程 (被终止的进程) 时，应该创建一个进程间通讯的内核对象——如一个互斥程序——这样一来，“受害”进程只在等待或周期性地测试它是否应该终止。 实验目的

1) 通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解Windows 2000进程的“一生”。

2) 通过阅读和分析实验程序，学习创建进程、观察进程和终止进程的程序设计方法。 工具/准备工作

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

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

1. 创建进程

2. 正在运行的进程 3. 终止进程

请回答：

Windows所创建的每个进程都是以调用_Resume Thread() API函数开始和以调用 Exit Process() 或 Terminate Process() API函数终止。

1. 创建进程

本实验显示了创建子进程的基本框架。该程序只是再一次地启动自身，显示它的系统进程ID和它在进程列表中的位置。

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

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

清单3-5 创建子进程 // proccreate项目

# include # include # include

// 创建传递过来的进程的克隆过程并赋于其ID值 void StartClone(int nCloneID) {

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

:: GetModuleFileName(NULL, szFilename, MAX_PATH) ;

// 格式化用于子进程的命令行并通知其EXE文件名和克隆ID TCHAR szCmdLine[MAX_PATH] ;

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

// 用于子进程的STARTUPINFO结构 STARTUPINFO si;

:: ZeroMemory(reinterpret_cast (&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) ; } }

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

// 确定进程在列表中的位置 int nClone(0) ; if (argc > 1) {

// 从第二个参数中提取克隆ID :: sscanf(argv[1] , “%d” , &nClone) ; }

// 显示进程位置

std :: cout << “Process ID: “ << :: GetCurrentProcessId() << “, Clone ID: “ << nClone << std :: endl;

// 检查是否有创建子进程的需要 const int c_nCloneMax = 25; if (nClone < C_nCloneMax) {

// 发送新进程的命令行和克隆号 StartClone(++nClone) ; }

// 在终止之前暂停一下 (l/2秒)

:: Sleep(500) ;

return 0; }

步骤4：单击“Build”菜单中的“Compile 3-5.cpp”命令，系统显示： This build command requires an active project workspace. Would you like to create a default project workspace ? (build命令需要一个活动的项目工作空间。你是否希望建立一个缺省的

项目工作空间？)

单击“是”按钮确认。系统对3-5.cpp进行编译。

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

操作能否正常进行？如果不行，则可能的原因是什么？ 不能正常运行：屏幕一直在闪烁。

原因：在错误的情况下，闪屏的ID一直是0，也就是说 if (nClone < c_nCloneMax)

{

// 发送新进程的命令行和克隆号 StartClone(++nClone) ;

}

中的nClone一直为0，导致类似死循环的窗口闪烁。

步骤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) ; // 返回的进程信息程序运行时屏幕显示 程序运行时屏幕显示的信息是：

显示Clone从0-25的过程中

最后程序显示的结果是：

提示：部分程序在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程序。 运行结果：

当前PID信息：1644 当前操作系统版本：running on OS:5.0(windows2000)

系统提示信息：Task Manager should now indicate thisprocess is high priority.

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

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

Windows2000 当前版本为5.0

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

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

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

vcspawn.exe

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

ProcessID变为1940__ ．

除了改变进程的优先级以外，还可以对正在运行的进程执行几项其他的操作，只要获得其进程句柄即可。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程序。 运行结果： 1)

表示： 建立子进程 2) 等待一段时

间

之

后

子

进

程

杀

死

自

身

进

程

表示： 使子进程退出

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

GetProcessTimes() API函数可向主调者显示进程的终止时间____

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