Windows编程那些事----内存管理方法之二【内存映射文件】
对文件进行操作几乎是所有应用程序都必须进行的，并且这常常是人们争论的一个问题。应用程序究竟是应该打开文件，读取文件并关闭文件，还是打开文件，然后使用一种缓冲算法，从文件的各个不同部分进行读取和写入呢？M i c r o s o f t提供了一种两全其美的方法，那就是内存映射文件。
与虚拟内存一样，内存映射文件可以用来保留一个地址空间的区域，并将物理存储器提交给该区域。它们之间的差别是，物理存储器来自一个已经位于磁盘上的文件，而不是系统的页文件。一旦该文件被映射，就可以访问它，就像整个文件已经加载内存一样。
内存映射文件可以用于3个不同的目的：
• 系统使用内存映射文件，以便加载和执行. e x e和D L L文件。这可以大大节省页文件空间和应用程序启动运行所需的时间。
• 可以使用内存映射文件来访问磁盘上的数据文件。这使你可以不必对文件执行I / O操作，并且可以不必对文件内容进行缓存。
• 可以使用内存映射文件，使同一台计算机上运行的多个进程能够相互之间共享数据。Wi n d o w s确实提供了其他一些方法，以便在进程之间进行数据通信，但是这些方法都是使用内存映射文件来实现的，这使得内存映射文件成为单个计算机上的多个进程互相进行通信的最有效的方法。
1.内存映射的可执行文件和DLL文件
当线程调用C r e a t e P r o c e s s时，系统将执行下列操作步骤：
1) 系统找出在调用C r e a t e P r o c e s s时设定的. e x e文件。如果找不到这个. e x e文件，进程将无法创建，C r e a t e P r o c e s s将返回FA L S E。
2) 系统创建一个新进程内核对象。
3) 系统为这个新进程创建一个私有地址空间。
4) 系统保留一个足够大的地址空间区域，用于存放该. e x e文件。该区域需要的位置在. e x e文件本身中设定。按照默认设置， . e x e文件的基地址是0 x 0 0 4 0 0 0 0 0（这个地址可能不同于在6 4位Windows 2000上运行的6 4位应用程序的地址），但是，可以在创建应用程序的. e x e文件时重载这个地址，方法是在链接应用程序时使用链接程序的/ B A S E选项。
5) 系统注意到支持已保留区域的物理存储器是在磁盘上的. e x e文件中，而不是在系统的页文件中。
当. e x e文件被映射到进程的地址空间中之后，系统将访问. e x e文件的一个部分，该部分列出了包含. e x e文件中的代码要调用的函数的D L L文件。然后，系统为每个D L L文件调用L o a d L i b r a r y函数，如果任何一个D L L需要更多的D L L，那么系统将调用L o a d L i b r a r y函数，以便加载这些D L L。每当调用L o a d L i b r a r y来加载一个D L L时，系统将执行下列操作步骤，它们均类似上面的第4和第5个步骤：
1) 系统保留一个足够大的地址空间区域，用于存放该D L L文件。该区域需要的位置在D L L文件本身中设定。按照默认设置， M i c r o s o f t的Visual C++ 建立的D L L文件基地址是0 x 1 0 0 0 0 0 0 0（这个地址可能不同于在6 4位Windows 2000上运行的6 4位D L L的地址）但是，你可以在创建D L L文件时重载这个地址，方法是使用链接程序的/ B A S E选项。Wi n d o w s提供的所有标准系统D L L都拥有不同的基地址，这样，如果加载到单个地址空间，它们就不会重叠。
2) 如果系统无法在该D L L的首选基地址上保留一个区域，其原因可能是该区域已经被另一个D L L或. e x e占用，也可能是因为该区域不够大，此时系统将设法寻找另一个地址空间的区域来保留该D L L。如果一个D L L无法加载到它的首选基地址，这将是非常不利的，原因有二。首先，如果系统没有再定位信息，它就无法加载该D L L（可以在D L L创建时，使用链接程序的/ F I X E D开关，从D L L中删除再定位信息，这能够使D L L变得比较小，但是这也意味着该D L L必须加载到它的首选地址中，否则它就根本无法加载）。第二，系统必须在D L L中执行某些再定位操作。在Windows 98中，系统可以在页面被转入R A M时执行再定位操作。在Windows 2000中，这些再定位操作需要由系统的页文件提供更多的存储器，它们也增加了加载D L L所需要的时间量。
3) 系统会注意到支持已保留区域的物理存储器位于磁盘上的D L L文件中，而不是在系统的页文件中。如果由D L L无法加载到它的首选基地址，Windows 2000必须执行再定位操作，那么系统也将注意到D L L的某些物理存储器已经被映射到页文件中。
如果由于某个原因系统无法映射. e x e和所有必要的D L L文件，那么系统就会向用户显示一个消息框，并且释放进程的地址空间和进程对象。C r e a t e P r o c e s s函数将向调用者返回FA L S E，调用者可以调用G e t L a s t E r r o r函数，以便更好地了解为什么无法创建该进程。
当所有的. e x e和D L L文件都被映射到进程的地址空间之后，系统就可以开始执行. e x e文件的启动代码。当. e x e文件被映射后，系统将负责所有的分页、缓冲和高速缓存的处理。例如，如果. e x e文件中的代码使它跳到一个尚未加载到内存的指令地址，那么就会出现一个错误。系统能够发现这个错误，并且自动将这页代码从该文件的映像加载到一个R A M页面。然后，系统将这个R A M页面映射到进程的地址空间中的相应位置，并且让线程继续运行，就像这页代码已经加载了一样。当然，这一切是应用程序看不见的。当进程中的线程每次试图访问尚未加载到R A M的代码或数据时，该进程就会重复执行。
1.1可执行文件或DLL的多个实例不能共享静态数据
当为正在运行的应用程序创建新进程时，系统将打开用于标识可执行文件映像的文件映射对象的另一个内存映射视图，并创建一个新进程对象和（为主线程创建）一个新线程对象。系统还要将新的进程I D和线程I D赋予这些对象。通过使用内存映射文件，同一个应用程序的多个正在运行的实例就能够共享R A M中的相同代码和数据。
这里有一个小问题需要注意。进程使用的是一个平面地址空间。当编译和链接你的程序时，所有的代码和数据都被合并在一起，组成一个很大的结构。数据与代码被分开，但仅限于跟在. e x e文件中的代码后面的数据而已。(实际上，文件的内容被分割为不同的节。代码放在一个节中，全局变量放在另一个节中。各个节按照页面边界来对齐。通过调用Get SystemInfo 函数，应用程序可以确定正在使用的页面的大小。在. e x e或D L L文件中，代码节通常位于数据数据节的前面。)图1 7 - 1简单说明了应用程序的代码和数据究竟是如何加载到虚拟内存中，然后又被映射到应用程序的地址空间中的。
作为一个例子，假设应用程序的第二个实例正在运行。系统只是将包含文件的代码和数据的虚拟内存页面映射到第二个应用程序的地址空间，如图1 7 - 2所示。
如果应用程序的一个实例改变了驻留在数据页面中的某些全局变量，那么该应用程序的所有实例的内存内容都将改变。这种类型的改变可能带来灾难性的后果，因此是决不允许的。
系统运用内存管理系统的c o p y - o n - w r i t e（写入时拷贝）特性来防止进行这种改变。每当应用程序尝试将数据写入它的内存映射文件时，系统就会抓住这种尝试，为包含应用程序尝试写入数据的内存页面分配一个新内存块，再拷贝该页面的内容，并允许该应用程序将数据写入这个新分配的内存块。结果，同一个应用程序的所有其他实例的运行都不会受到影响。图1 7 - 3显示了当应用程序的第一个实例尝试改变数据页面2时出现的情况。
图17-1 应用程序的代码和数据加载及映射示意图
图17-2 应用程序与虚拟内存地址空间之间的关系示意图
图17-3 应用程序的第一个实例尝试改变数据页面2时的情况
系统分配一个新的虚拟内存页面，并且将数据页面2的内容拷贝到新页面中。第一个实例的地址空间发生了变更，这样，新数据页面就被映射到与原始地址页面相同位置上的地址空间中。这时系统就可以让进程修改全局变量，而不必担心改变同一个应用程序的另一个实例的数据。
当应用程序被调试时，将会发生类似的事件。比如说，你正在运行一个应用程序的多个实例，并且只想调试其中的一个实例。你访问调试程序，在一行源代码中设置一个断点。调试程序修改了你的代码，将你的一个汇编语言指令改为能使调试程序自行激活的指令。因此你再次遇到了同样的问题。当调试程序修改代码时，它将导致应用程序的所有实例在修改后的汇编语言指令运行时激活该调试程序。为了解决这个问题，系统再次使用c o p y - o n - w r i t e内存。当系统发现调试程序试图修改代码时，它就分配一个新内存块，将包含该指令的页面拷贝到新的内存页面中，并且允许调试程序修改页面拷贝中的代码。
Windows 98 当一个进程被加载时，系统要查看文件映像的所有页面。系统立即为通常用c o p y - o n - w r i t e属性保护的那些页面提交页文件中的存储器。这些页面只是被提交而已，它们并不被访问。当文件映像中的页面被访问时，系统就加载相应的页面。如果该页面从来没有被修改，它就可以从内存中删除，并在必要时重新加载。但是，如果文件的页面被修改了，系统就将修改过的页面转到页文件中以前被提交的页面之一。
Windows 2000与Windows 98之间的行为特性的唯一差别，是在你加载一个模块的两个拷贝并且可写入的数据尚未被修改的时候显示出来的。在这种情况下，在Windows 2000下运行的进程能够共享数据，而在Windows 98下，每个进程都可以得到它自己的数据拷贝。如果只加载模块的一个拷贝，或者可写入的数据已经被修改（这是通常的情况），那么Windows 2000与Windows 98的行为特性是完全相同的。
1.2在可执行文件或DLL的多个实例之间共享静态数据
全局数据和静态数据不能被同一个. e x e或D L L文件的多个映像共享，这是个安全的默认设置。但是，在某些情况下，让一个. e x e文件的多个映像共享一个变量的实例是非常有用和方便的。例如，Wi n d o w s没有提供任何简便的方法来确定用户是否在运行应用程序的多个实例。但是，如果能够让所有实例共享单个全局变量，那么这个全局变量就能够反映正在运行的实例的数量。当用户启动应用程序的一个实例时，新实例的线程能够简单地查看全局变量的值（它已经被另一个实例更新）；如果这个数量大于1，那么第二个实例就能够通知用户，该应用程序只有一个实例可以运行，而第二个实例将终止运行。
本节将介绍一种方法，它允许你共享. e x e或D L L文件的所有实例的变量。不过在介绍这个方法之前，首先让我们介绍一些背景知识。
每个. e x e或D L L文件的映像都由许多节组成。按照规定，每个标准节的名字均以圆点开头。例如，当编译你的程序时，编译器会将所有代码放入一个名叫. t e x t的节中。该编译器还将所有未经初始化的数据放入一个. b s s节，而已经初始化的所有数据则放入. d a t a节中。
每一节都拥有与其相关的一组属性，这些属性如表1 7 - 1所示。
表17-1 .exe或D L L文件各节的属性
| 属性 | 含义 |
| R E A D | 该节中的字节可以读取 |
| W R I T E | 该节中的字节可以写入 |
| E X E C U T E | 该节中的字节可以执行 |
| S H A R E D | 该节中的字节可以被多个实例共享（本属性能够有效地关闭c o p y - o n - w r i t e机制） |
使用M i c r o s o f t的Visual Studio的D u m p B i n实用程序（带有/ H e a d e r s开关），可以查看. e x e或D L L映射文件中各个节的列表。
除了编译器和链接程序创建的标准节外，也可以在使用下面的命令进行编译时创建自己的节：
表17-2 常见的节名及作用
| 节名 | 作用 |
| . b s s | 未经初始化的数据 |
| . C RT | C运行期只读数据 |
| . d a t a | 已经初始化的数据 |
| . d e b u g | 调试信息 |
| . d i d a t a | 延迟输入文件名表 |
| . e d a t a | 输出文件名表 |
| . i d a t a | 输入文件名表 |
| . r d a t a | 运行期只读数据 |
| . r e l o c | 重定位表信息 |
| . r s r c | 资源 |
| . t e x t | . e x e或D L L文件的代码 |
| . t l s | 线程的本地存储器 |
| . x d a t a | 异常处理表 |
LONG g_lInstanceCount = 0;
#pragma data_seg()
LONG g_lInstanceCount;
#pragma data_seg()
// Create Shared section & have compiler place initialized data in it.
#pragma data_seg("Shared")
// Initialized, in Shared section
int a = 0;
// Uninitialized, not in Shared section
int b;
// Have compiler stop placing initialized data in Shared section.
#pragma data_seg()
// Initialized, in Shared section
__declspec(allocate("Shared")) int c = 0;
// Uninitialized, in Shared section
__declspec(allocate("Shared")) int d;
// Initialized, not in Shared section
int e = 0;
// Uninitialized, not in Shared section
int f; 之所以将变量放入它们自己的节中，最常见的原因也许是要在. e x e或D L L文件的多个映像之间共享这些变量。按照默认设置， . e x e或D L L文件的每个映像都有它自己的一组变量。然而，可以将你想在该模块的所有映像之间共享的任何变量组合到它自己的节中去。当给变量分组时，系统并不为. e x e或D L L文件的每个映像创建新实例。
仅仅告诉编译器将某些变量放入它们自己的节中，是不足以实现对这些变量的共享的。还必须告诉链接程序，某个节中的变量是需要加以共享的。若要进行这项操作，可以使用链接程序的命令行上的/ S E C T I O N开关：
/SECTION:name,attributes在冒号的后面，放入你想要改变其属性的节的名字。在我们的例子中，我们想要改变S h a r e d节的属性。因此应该创建下面的链接程序开关/SECTION:Shared,RWS在逗号的后面，我们设定了需要的属性。用R代表R E A D ，W代表W E I T E，E代表E X E C U T E，S代表S H A R E D。上面的开关用于指明位于S h a r e d节中的数据是可以读取、写入和共享的数据。如果想要改变多个节的属性，必须多次设定/ S E C T I O N开关，也就是为你要改变属性的每个节设定一个/ S E C T I O N开关。也可以使用下面的句法将链接程序开关嵌入你的源代码中：
#pragma comment(linker, "/SECTION:Shared,RWS")
虽然可以创建共享节，但是，由于两个原因， M i c r o s o f t并不鼓励你使用共享节。第一，用这种方法共享内存有可能破坏系统的安全。第二，共享变量意味着一个应用程序中的错误可能影响另一个应用程序的运行，因为它没有办法防止某个应用程序将数据随机写入一个数据块。
假设你编写了两个应用程序，每个应用程序都要求用户输入一个口令。然而你又决定给应用程序添加一些特性，使用户操作起来更加方便些：如果在第二个应用程序启动运行时，用户正在运行其中的一个应用程序，那么第二个应用程序就可以查看共享内存的内容，以便获得用户的口令。这样，如果程序中的某一个已经被使用，那么用户就不必重新输入他的口令。
这听起来没有什么问题。毕竟没有别的应用程序而只有你自己的应用程序加载了D L L，并且知道到什么地方去查找包含在共享节中的口令。但是，黑客正在窥视着你的行动，如果他们想要得到你的口令，只需要编写一段很短的程序，加载到你的公司的D L L文件中，然后监控共享内存块。当用户输入口令时，黑客的程序就能知道该用户的口令。
黑客精心编制的程序也可能试图反复猜测用户的口令并将它们写入共享内存。一旦该程序猜测到正确的口令，它就能够将各种命令发送给两个应用程序中的一个。如果有一种办法只为某些应用程序赋予访问权，以便加载一个特定的D L L，那么这个问题也许是可以解决的。但是目前还不行，因为任何程序都能够调用L o a d L i b r a r y函数来显式加载D L L。
2.内存映射数据文件
操作系统使得内存能够将一个数据文件映射到进程的地址空间中。因此，对大量的数据进行操作是非常方便的。
为了理解用这种方法来使用内存映射文件的功能，让我们看一看如何用4种方法来实现一个程序，以便将文件中的所有字节的顺序进行倒序。
2.1一个文件，一个缓存
第一种方法也是理论上最简单的方法，它需要分配足够大的内存块来存放整个文件。该文件被打开，它的内容被读入内存块，然后该文件被关闭。文件内容进入内存后，我们就可以对所有字节的顺序进行倒序，方法是将第一个字节倒腾为最后一个字节，第二个字节倒腾为倒数第二个字节，依次类推。这个倒腾操作将一直进行下去直到文件的中间位置。当所有的字节都已经倒腾之后，就可以重新打开该文件，并用内存块的内容来改写它的内容。
这种方法实现起来非常容易，但是它有两个缺点。首先，必须分配一个与文件大小相同的内存块。如果文件比较小，那么这没有什么问题。但是如果文件非常大，比如说有2 G B大，那该怎么办呢？一个3 2位的系统不允许应用程序提交那么大的物理内存块。因此大文件需要使用不同的方法。
第二，如果进程在运行过程的中间被中断，也就是说当倒序后的字节被重新写入该文件时进程被中断，那么文件的内容就会遭到破坏。防止出现这种情况的最简单的方法是在对它的内容进行倒序之前先制作一个原始文件的拷贝。如果整个进程运行成功，那么可以删除该文件的拷贝。这种方法需要更多的磁盘空间。
2.2两个文件，一个缓存
在第二种方法中，你打开现有的文件，并且在磁盘上创建一个长度为0的新文件。然后分配一个比较小的内部缓存，比如说8 KB。你找到离原始文件结尾还有8 KB的位置，将这最后的8 KB读入缓存，将字节倒序，再将缓存中的内容写入新创建的文件。这个寻找、读入、倒序和写入的操作过程要反复进行，直到到达原始文件的开头。如果文件的长度不是8 KB的倍数，那么必须进行某些特殊的处理。当原始文件完全处理完毕之后，将原始文件和新文件关闭，并删除原始文件。
这种方法实现起来比第一种方法要复杂一些。它对内存的使用效率要高得多，因为它只需要分配一个8 KB的缓存块，但是它存在两个大问题。首先，它的处理速度比第一种方法要慢，原因是在每个循环操作过程中，在执行读入操作之前，必须对原始文件进行寻找操作。第二，这种方法可能要使用大量的硬盘空间。如果原始文件是400 MB，那么随着进程的不断运行，新文件就会增大为400 MB。在原始文件被删除之前，两个文件总共需要占用800 MB的磁盘空间。这比应该需要的空间大400 MB。由于存在这个缺点，因此引来了下一个方法。
2.3一个文件，两个缓存
如果使用这个方法，那么我们假设程序初始化时分配了两个独立的8 KB缓存。程序将文件的第一个8 KB读入一个缓存，再将文件的第二个8 KB 读入另一个缓存。然后进程将两个缓存的内容进行倒序，并将第一个缓存的内容写回文件的结尾处，将第二个缓存的内容写回同一个文件的开始处。每个迭代操作不断进行（以8 KB为单位，从文件的开始和结尾处移动文件块）。如果文件的长度不是16 KB的倍数，并且有两个8 KB的文件块相重叠，那么就需要进行一些特殊的处理。这种特殊处理比上一种方法中的特殊处理更加复杂，不过这难不倒经验丰富的编程员。
与前面的两种方法相比，这种方法在节省硬盘空间方面有它的优点。由于所有内容都是从同一个文件读取并写入同一个文件，因此不需要增加额外的磁盘空间，至于内存的使用，这种方法也不错，它只需要使用16 KB的内存。当然，这种方法也许是最难实现的方法。与第一种方法一样，如果进程被中断，本方法会导致数据文件被破坏。
下面让我们来看一看如何使用内存映射文件来完成这个过程。
2.4一个文件，零缓存
当使用内存映射文件对文件内容进行倒序时，你打开该文件，然后告诉系统将虚拟地址空间的一个区域进行倒序。你告诉系统将文件的第一个字节映射到该保留区域的第一个字节。然后可以访问该虚拟内存的区域，就像它包含了这个文件一样。实际上，如果在文件的结尾处有一个单个0字节，那么只需要调用C运行期函数_ s t r r e v，就可以对文件中的数据进行倒序操作。
这种方法的最大优点是，系统能够为你管理所有的文件缓存操作。不必分配任何内存，或者将文件数据加载到内存，也不必将数据重新写入该文件，或者释放任何内存块。但是，内存映射文件仍然可能出现因为电源故障之类的进程中断而造成数据被破坏的问题。
3.使用内存映射文件
若要使用内存映射文件，必须执行下列操作步骤：
1) 创建或打开一个文件内核对象，该对象用于标识磁盘上你想用作内存映射文件的文件。
2) 创建一个文件映射内核对象，告诉系统该文件的大小和你打算如何访问该文件。
3) 让系统将文件映射对象的全部或一部分映射到你的进程地址空间中。
当完成对内存映射文件的使用时，必须执行下面这些步骤将它清除：
1) 告诉系统从你的进程的地址空间中撤消文件映射内核对象的映像。
2) 关闭文件映射内核对象。
3) 关闭文件内核对象。
下面将详细介绍这些操作步骤。
3.1步骤1：创建或打开文件内核对象
若要创建或打开一个文件内核对象，总是要调用C r e a t e F i l e函数：
HANDLE CreateFile( PCSTR pszFileName, DWORD dwDesiredAccess, DWORD dwShareMode, PSECURITY_ATTRIBUTES psa, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
第一个参数p s z F i l e N a m e用于指明要创建或打开的文件的名字（包括一个选项路径）。第二个参数d w D e s i r e d A c c e s s用于设定如何访问该文件的内容。可以设定表1 7 - 3所列的4个值中的一个。
表17-3 dwDesiredAccess的值
值 含义 0 不能读取或写入文件的内容。当只想获得文件的属性时，请设定0 G E N E R I C _ R E A D 可以从文件中读取数据 G E N E R I C _ W R I T E 可以将数据写入文件 GENERIC_READ |GENERIC_WRITE 可以从文件中读取数据，也可以将数据写入文件 当创建或打开一个文件，将它作为一个内存映射文件来使用时，请选定最有意义的一个或多个访问标志，以说明你打算如何访问文件的数据。对内存映射文件来说，必须打开用于只读访问或读写访问的文件，因此，可以分别设定G E N E R I C _ R E A D 或GENERIC_READ |G E N E R I C _ W R I T E。
第三个参数d w S h a r e M o d e告诉系统你想如何共享该文件。可以为d w S h a r e M o d e设定表1 7 - 4所列的4个值之一。
表17-4 dwShareMode 的值
值 含义 0 打开文件的任何尝试均将失败 F I L E _ S H A R E _ R E A D 使用G E N E R I C _ W R I T E打开文件的其他尝试将会失败 F I L E _ S H A R E _ W R I T E 使用G E N E R I C _ R E A D打开文件的其他尝试将会失败 FILE_SHARE_READ FILE_SHARE_WRITE| 打开文件的其他尝试将会取得成功 如果C r e a t e F i l e函数成功地创建或打开指定的文件，便返回一个文件内核对象的句柄，否则返回I N VA L I D _ H A N D L E _ VA L U E。
注意能够返回句柄的大多数Wi n d o w s函数如果运行失败，那么就会返回N U L L。但是，C r e a t e F i l e函数将返回I N VA L I D _ H A N D L E _ VA L U E，它定义为（（H A N D L E）- 1）。
3.2步骤2：创建一个文件映射内核对象
调用C r e a t e F i l e函数，就可以将文件映像的物理存储器的位置告诉操作系统。你传递的路径名用于指明支持文件映像的物理存储器在磁盘（或网络或光盘）上的确切位置。这时，必须告诉系统，文件映射对象需要多少物理存储器。若要进行这项操作，可以调用C r e a t e F i l e M a p p i n g函数：
HANDLE CreateFileMapping( HANDLE hFile, PSECURITY_ATTRIBUTES psa, DWORD fdwProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, PCTSTR pszName);第一个参数h F i l e用于标识你想要映射到进程地址空间中的文件句柄。该句柄由前面调用的C r e a t e F i l e函数返回。p s a参数是指向文件映射内核对象的S E C U R I T Y _ AT T R I B U T E S结构的指针，通常传递的值是N U L L（它提供默认的安全特性，返回的句柄是不能继承的）。本章开头讲过，创建内存映射文件就像保留一个地址空间区域然后将物理存储器提交给该区域一样。因为内存映射文件的物理存储器来自磁盘上的一个文件，而不是来自从系统的页文件中分配的空间。当创建一个文件映射对象时，系统并不为它保留地址空间区域，也不将文件的存储器映射到该区域（下一节将介绍如何进行这项操作）。但是，当系统将存储器映射到进程的地址空间中去时，系统必须知道应该将什么保护属性赋予物理存储器的页面。C r e a t e F i l e M a p p i n g函数的f d w P r o t e c t参数使你能够设定这些保护属性。大多数情况下，可以设定表1 7 - 5中列出的3个保护属性之一。
表17-5 使用fdwProtect 参数设定的部分保护属性
保护属性 含义 PA G E _ R E A D O N LY 当文件映射对象被映射时，可以读取文件的数据。必须已经将G E N E R I C _ R E A D传递给C r e a t e F i l e函数 PA G E _ R E A D W R I T E 当文件映射对象被映射时，可以读取和写入文件的数据。必须已经将GENERIC_READ | GENERIC_WRITE传递给C r e a t e F i l e PA G E _ W R I T E C O P Y 当文件映射对象被映射时，可以读取和写入文件的数据。如果写入数据，会导致页面的私有拷贝得以创建。必须已经将G E N E R I C _ R E A D或G E N E R I C _ W R I T E传递给C r e a t e F i l e 在Windows 98下，可以将PA G E _ W R I T E C O P Y标志传递给C r e a t e F i l eM a p p i n g，这将告诉系统从页文件中提交存储器。该页文件存储器是为数据文件的数据拷贝保留的，只有修改过的页面才被写入页文件。你对该文件的数据所作的任何修改都不会重新填入原始数据文件。其最终结果是， PA G E _ W R I T E C O P Y标志的作用在Windows 2000和Windows 98上是相同的。
3.3步骤3：将文件数据映射到进程的地址空间
当创建了一个文件映射对象后，仍然必须让系统为文件的数据保留一个地址空间区域，并将文件的数据作为映射到该区域的物理存储器进行提交。可以通过调用M a p Vi e w O f F i l e函数来进行这项操作：
PVOID MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap);参数h F i l e M a p p i n g O b j e c t用于标识文件映射对象的句柄，该句柄是前面调用CreateFile Mapping或O p e n F i l e M a p p i n g（本章后面介绍）函数返回的。参数d w D e s i r e d A c c e s s用于标识如何访问该数据。不错，必须再次设定如何访问文件的数据。可以设定表1 7 - 6所列的4个值中的一个。
表17-6 值及其含义
值 含义 F I L E _ M A P _ W R I T E 可以读取和写入文件数据。C r e a t e F i l e M a p p i n g函数必须通过传递PA G E _ R E A D W R I T E标志来调用 F I L E _ M A P _ R E A D 可以读取文件数据。C r e a t e F i l e M a p p i n g函数可以通过传递下列任何一个保护属性来调用：PA G E _ R E A D O N LY、PA G E _ R E A D W R I T E或PA G E _ W R I T E C O P Y F I L E _ M A P _ A L L _ A C C E S S 与F I L E _ M A P _ W R I T E相同 F I L E _ M A P _ C O P Y 可以读取和写入文件数据。如果写入文件数据，可以创建一个页面的私有拷贝。在Windows 2000中，C r e a t e F i l e M a p p i n g函数可以用PA G E _ R E A D O N LY、PA G E _ R E A D W R I T E或PA G E _ W R I T E C O P Y等保护属性中的任何一个来调用。在Windows 98中，C r e a t e F i l e M a p p i n g必须用PA G E _ W R I T E C O P Y来调用 Wi n d o w s要求所有这些保护属性一次又一次地重复设置，这当然有些奇怪和烦人。我认为这样做可以使应用程序更多地对数据保护属性进行控制。
剩下的3个参数与保留地址空间区域及将物理存储器映射到该区域有关。当你将一个文件映射到你的进程的地址空间中时，你不必一次性地映射整个文件。相反，可以只将文件的一小部分映射到地址空间。被映射到进程的地址空间的这部分文件称为一个视图，这可以说明M a p Vi e w O f F i l e是如何而得名的。
当将一个文件视图映射到进程的地址空间中时，必须规定两件事情。首先，必须告诉系统，数据文件中的哪个字节应该作为视图中的第一个字节来映射。你可以使用d w F i l e O ff s e t H i g h和d w F i l e O ff s e t L o w参数来进行这项操作。由于Wi n d o w s支持的文件最大可达1 6 E B，因此必须用一个6 4位的值来设定这个字节的位移值。这个6 4位值中，较高的3 2位传递给参数d w F i l e O ff s e t H i g h，较低的3 2位传递给参数d w F i l e O ff s e t L o w。注意，文件中的这个位移值必须是系统的分配粒度的倍数（迄今为止，Wi n d o w s的所有实现代码的分配粒度均为64 KB）。
第二，必须告诉系统,数据文件有多少字节要映射到地址空间。这与设定要保留多大的地址空间区域的情况是相同的。可以使用d w N u m b e r O f B y t e s To M a p参数来设定这个值。如果设定的值是0，那么系统将设法把从文件中的指定位移开始到整个文件的结尾的视图映射到地址空间。
在Windows 98中，如果M a p Vi e w O f F i l e无法找到足够大的区域来存放整个文件映射对象，那么无论需要的视图是多大， M a p Vi e w O f F i l e均将返回N U L L。
在Windows 2000中，M a p Vi e w O f F i l e只需要为必要的视图找到足够大的一个区域，而不管整个文件映射对象是多大。
如果在调用M a p Vi e w O f F i l e函数时设定了F I L E _ M A P _ C O P Y标志，系统就会从系统的页文件中提交物理存储器。提交的地址空间数量由d w N u m b e r O f B y t e s To M a p参数决定。只要你不进行其他操作，只是从文件的映像视图中读取数据，那么系统将决不会使用页文件中的这些提交的页面。但是，如果进程中的任何线程将数据写入文件的映像视图中的任何内存地址，那么系统将从页文件中抓取已提交页面中的一个页面，将原始数据页面拷贝到该页交换文件中，然后将该拷贝的页面映射到你的进程的地址空间。从这时起，你的进程中的线程就要访问数据的本地拷贝，不能读取或修改原始数据。
3.4步骤4：从进程的地址空间中撤消文件数据的映像
当不再需要保留映射到你的进程地址空间区域中的文件数据时，可以通过调用下面的函数将它释放：
BOOL UnmapViewOfFile(PVOID pvBaseAddress);该函数的唯一的参数p v B a s e A d d r e s s用于设定返回区域的基地址。该值必须与调用M a p Vi e w O f F i l e函数返回的值相同。必须记住要调用U n m a p Vi e w O f F i l e函数。如果没有调用这个函数，那么在你的进程终止运行前，保留的区域就不会被释放。每当你调用M a p Vi e w O f F i l e时，系统总是在你的进程地址空间中保留一个新区域，而以前保留的所有区域将不被释放。为了提高速度，系统将文件的数据页面进行高速缓存，并且在对文件的映射视图进行操作时不立即更新文件的磁盘映像。如果需要确保你的更新被写入磁盘，可以强制系统将修改过的数据的一部分或全部重新写入磁盘映像中，方法是调用F l u s h Vi e w O f F i l e函数：
BOOL FlushViewOfFile( PVOID pvAddress, SIZE_T dwNumberOfBytesToFlush);
第一个参数是包含在内存映射文件中的视图的一个字节的地址。该函数将你在这里传递的地址圆整为一个页面边界值。第二个参数用于指明你想要刷新的字节数。系统将把这个数字向上圆整，使得字节总数是页面的整数。如果你调用F l u s h Vi e w O f F i l e函数并且不修改任何数据，那么该函数只是返回，而不将任何信息写入磁盘。
对于存储器是在网络上的内存映射文件来说， F l u s h Vi e w O f F i l e能够保证文件的数据已经从工作站写入存储器。但是F l u s h Vi e w O f F i l e不能保证正在共享文件的服务器已经将数据写入远程磁盘，因为服务器也许对文件的数据进行了高速缓存。若要保证服务器写入文件的数据，每当你为文件创建一个文件映射对象并且映射该文件映射对象的视图时，应该将F I L E _ F L A G _W R I T E _ T H R O U G H标志传递给C r e a t e F i l e函数。如果你使用该标志打开该文件，那么只有当文件的全部数据已经存放在服务器的磁盘驱动器中的时候， F l u s h Vi e w O f F i l e函数才返回。
记住U n m a p Vi e w O f F i l e函数的一个特殊的特性。如果原先使用F I L E _ M A P _ C O P Y标志来映射视图，那么你对文件的数据所作的任何修改，实际上是对存放在系统的页文件中的文件数据的拷贝所作的修改。在这种情况下，如果调用U n m a p Vi e w O f F i l e函数，该函数在磁盘文件上就没有什么可以更新，而只会释放页文件中的页面，从而导致数据丢失。
如果想保留修改后的数据，必须采用别的措施。例如，你可以用同一个文件创建另一个文件映射对象（使用PA G E _ R E A D W R I T E），然后使用F I L E _ M A P _ W R I T E标志将这个新文件映射对象映射到进程的地址空间。之后，你可以扫描第一个视图，寻找带有PA G E _ R E A D W R I T E保护属性的页面。每当你找到一个带有该属性的页面时，可以查看它的内容，并且确定是否将修改了的数据写入该文件。如果不想用新数据更新该文件，那么继续对视图中的剩余页面进行扫描，直到视图的结尾。但是，如果你确实想要保存修改了的数据页面，那么只需要调用M o v e M e m o r y函数，将数据页面从第一个视图拷贝到第二个视图。由于第二个视图是用PA G E _ R E A D W R I T E保护属性映射的，因此M o v e M e m o r y函数将更新磁盘上的实际文件内容。可以使用这种方法来确定文件的变更并保存你的文件的数据。
Windows 98不支持c o p y - o n - w r i t e（写入时拷贝）保护属性，因此，当扫描内存映射文件的第一个视图时，无法测试用PA G E _ R E A D W R I T E标志做上标记的页面。你必须设计一种方法来确定第一个视图中的哪些页面已经做了修改。
3.5步骤5和步骤6：关闭文件映射对象和文件对象
不用说，你总是要关闭你打开了的内核对象。如果忘记关闭，在你的进程继续运行时会出现资源泄漏的问题。当然，当你的进程终止运行时，系统会自动关闭你的进程已经打开但是忘记关闭的任何对象。但是如果你的进程暂时没有终止运行，你将会积累许多资源句柄。因此你始终都应该编写清楚而又“正确的”代码，以便关闭你已经打开的任何对象。若要关闭文件映射对象和文件对象，只需要两次调用C l o s e H a n d l e函数，每个句柄调用一次：
让我们更加仔细地观察一下这个进程。下面的伪代码显示了一个内存映射文件的例子：
HANDLE hFile = CreateFile(...); HANDLE hFileMapping = CreateFileMapping(hFile, ...); PVOID pvFile = MapViewOfFile(hFileMapping, ...); // Use the memory-mapped file. UnmapViewOfFile(pvFile); CloseHandle(hFileMapping); CloseHandle(hFile);上面的代码显示了对内存映射文件进行操作所用的“预期”方法。但是，它没有显示，当你调用M a p Vi e w O f F i l e时系统对文件对象和文件映射对象的使用计数的递增情况。这个副作用是很大的，因为它意味着我们可以将上面的代码段重新编写成下面的样子：HANDLE hFile = CreateFile(...); HANDLE hFileMapping = CreateFileMapping(hFile, ...); CloseHandle(hFile); PVOID pvFile = MapViewOfFile(hFileMapping, ...); CloseHandle(hFileMapping); // Use the memory-mapped file. UnmapViewOfFile(pvFile);当对内存映射文件进行操作时，通常要打开文件，创建文件映射对象，然后使用文件映射对象将文件的数据视图映射到进程的地址空间。由于系统递增了文件对象和文件映射对象的内部使用计数，因此可以在你的代码开始运行时关闭这些对象，以消除资源泄漏的可能性。如果用同一个文件来创建更多的文件映射对象，或者映射同一个文件映射对象的多个视图，那么就不能较早地调用C l o s e H a n d l e函数——以后你可能还需要使用它们的句柄，以便分别对C r e a t e F i l e M a p p i n g和M a p Vi e w O f F i l e函数进行更多的调用。
4.内存映射文件与数据视图的相关性
系统允许你映射一个文件的相同数据的多个视图。例如，你可以将文件开头的10 KB映射到一个视图，然后将同一个文件的头4 KB映射到另一个视图。只要你是映射相同的文件映射对象，系统就会确保映射的视图数据的相关性。例如，如果你的应用程序改变了一个视图中的文件内容，那么所有其他视图均被更新以反映这个变化。这是因为尽管页面多次被映射到进程的虚拟地址空间，但是系统只将数据放在单个R A M页面上。如果多个进程映射单个数据文件的视图，那么数据仍然是相关的，因为在数据文件中，每个R A M页面只有一个实例——正是这个R A M页面被映射到多个进程的地址空间。
注意Wi n d o w s允许创建若干个由单个数据文件支持的文件映射对象。Wi n d o w s不能保证这些不同的文件映射对象的视图具有相关性。它只能保证单个文件映射对象的多个视图具有相关性。
然而，当对文件进行操作时，没有理由使另一个应用程序无法调用C r e a t e F i l e函数以打开由另一个进程映射的同一个文件。这个新进程可以使用R e a d F i l e和Wr i t e F i l e函数来读取该文件的数据和将数据写入该文件。当然，每当一个进程调用这些函数时，它必须从内存缓冲区读取文件数据或者将文件数据写入内存缓冲区。该内存缓冲区必须是进程自己创建的一个缓冲区，而不是映射文件使用的内存缓冲区。当两个应用程序打开同一个文件时，问题就可能产生：一个进程可以调用R e a d F i l e函数来读取文件的一个部分，并修改它的数据，然后使用Wr i t e F i l e函数将数据重新写入文件，而第二个进程的文件映射对象却不知道第一个进程执行的这些操作。由于这个原因，当你为将被内存映射的文件调用C r e a t e F i l e函数时，最好将d w S h a r e M o d e参数的值设置为0。这样就可以告诉系统，你想要单独访问这个文件，而其他进程都不能打开它。
只读文件不存在相关性问题，因此它们可以作为很好的内存映射文件。内存映射文件决不应该用于共享网络上的可写入文件，因为系统无法保证数据视图的相关性。如果某个人的计算机更新了文件的内容，其他内存中含有原始数据的计算机将不知道它的信息已经被修改
5.设定内存映射文件的基地址
正如你可以使用Vi r t u a l A l l o c函数来确定对地址空间进行倒序所用的初始地址一样，你也可以使用M a p Vi e w O f F i l e E x函数而不是使用M a p Vi e w O f F i l e函数来确定一个文件被映射到某个特定的地址。请看下面的代码：
PVOID MapViewOfFileEx( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, PVOID pvBaseAddress);该函数的所有参数和返回值均与M a p Vi e w O f F i l e函数相同，唯一的差别是最后一个参数p v B a s e A d d r e s s有所不同。在这个参数中，你为要映射的文件设定一个目标地址。与Vi r t u a l A l l o c一样，你设定的目标地址应该是分配粒度边界（ 64 KB）的倍数，否则M a p Vi e w O f F i l e E x将返回N U L L，表示出现了错误。在Windows 2000下，如果设定的地址不是分配粒度的倍数，就会导致函数运行失败，同时G e t L a s t E r r o r将返回11 3 2（E R R O R _ M A P P E D _ A L I G N M E N T）。在Windows 98中，该地址将圆整为分配粒度边界值。
如果系统无法将文件映射到该位置上（通常由于文件太大并且与另一个保留的地址空间相重叠），那么该函数的运行就会失败并且返回N U L L。M a p Vi e w O f F i l e E x并不设法寻找另一个地址空间来放置该文件。当然，你可以设定N U L L作为p v B a s e A d d r e s s参数的值，这时，M a p Vi e w O f F i l e E x函数的运行特性与M a p Vi e w O f F i l e函数完全相同。
当你使用内存映射文件与其他进程共享数据时，你可以使用M a p Vi e w O f F i l e E x函数。例如，当两个或多个应用程序需要共享包含指向其他数据结构的一组数据结构时，可能需要在某个特定地址上的内存映射文件。链接表是个极好的例子。在链接表中，每个节点或元素均包含列表中的另一个元素的内存地址。若要遍历该列表，必须知道第一个元素的地址，然后参考包含下一个元素地址的元素成员。当使用内存映射文件时，这可能成为一个问题。
如果一个进程建立了内存映射文件中的链接表，然后与另一个进程共享该文件，那么另一个进程就可能将文件映射到它的地址空间中的一个完全不同的位置上。当第二个进程视图遍历该链接表时，它查看链接表的第一个元素，检索下一个元素的内存地址，然后设法引用下一个元素。然而，第一个节点中的下一个元素的地址并不是第二个进程需要查找的地址。
可以用两种办法来解决这个问题。首先，当第二个进程将包含链接表的内存映射文件映射到它自己的地址空间中去时，它只要调用M a p Vi e w O f F i l e E x函数而不是调用M a p Vi e w O f F i l e。当然，这种方法要求第二个进程必须知道第一个进程原先在建立链接表时将文件映射到了什么地方。当两个应用程序打算互相进行交互操作时（这是非常可能的），这就不会出现任何问题，因为地址可以通过硬编码放入两个应用程序，或者一个进程可以通知另一个进程使用另一种进程间通信的方式，比如将消息发送到窗口。
第二个方法是创建链接表的进程将下一个节点所在的地址中的位移存放在每个节点中。这要求应用程序将该位移添加给内存映射文件的基地址，以便访问每个节点。这种方法并不高明，因为它的运行速度可能比较慢，它会使程序变得更大（因为编译器要生成附加代码来执行所有的计算操作），而且它很容易出错。但是，它仍然是个可行的方法， M i c r o s o f t的编译器为使用_ _ b a s e d关键字的基本指针提供了辅助程序
6.实现内存映射文件的具体方法
Windows 98和Windows 2000实现内存映射文件的方法是不同的。必须知道这些差别，因为它们会影响你编写代码的方法，也会影响其他应用程序对你的数据进行不利的操作。
在Windows 98下，视图总是映射到0 x 8 0 0 0 0 0 0 0至0 x B F F F F F F F范围内的地址空间分区中。因此，对M a p Vi e w O f F i l e函数的成功调用都会返回这个范围内的一个地址。你也许还记得，所有进程都共享该分区中的数据。这意味着如果进程映射了文件映射对象的视图，那么该文件映射对象的数据实际上就可以被所有进程访问，而不管它们是否已经映射了该文件映射对象的视图。如果另一个进程调用使用同一个文件映射对象的M a p Vi e w O f F i l e函数，Windows 98便将返回给第一个进程的同一个内存地址返回给第二个进程。这两个进程访问相同的数据，并且它们的视图具有相关性。
7.使用内存映射文件在进程之间共享数据
Wi n d o w s总是出色地提供各种机制，使应用程序能够迅速而方便地共享数据和信息。这些机制包括R P C、C O M、O L E、D D E、窗口消息（尤其是W M _ C O P Y D ATA）、剪贴板、邮箱、管道和套接字等。在Wi n d o w s中，在单个计算机上共享数据的最低层机制是内存映射文件。不错，如果互相进行通信的所有进程都在同一台计算机上的话，上面提到的所有机制均使用内存映射文件从事它们的烦琐工作。如果要求达到较高的性能和较小的开销，内存映射文件是举手可得的最佳机制。
数据共享方法是通过让两个或多个进程映射同一个文件映射对象的视图来实现的，这意味着它们将共享物理存储器的同一个页面。因此，当一个进程将数据写入一个共享文件映射对象的视图时，其他进程可以立即看到它们视图中的数据变更情况。注意，如果多个进程共享单个文件映射对象，那么所有进程必须使用相同的名字来表示该文件映射对象。
让我们观察一个例子，启动一个应用程序。当一个应用程序启动时，系统调用C r e a t e F i l e函数，打开磁盘上的. e x e文件。然后系统调用C r e a t e F i l e M a p p i n g函数，创建一个文件映射对象。最后，系统代表新创建的进程调用M a p Vi e w O f F i l e E x函数（它带有S E C _ I M A G E标志），这样， . e x e文件就可以映射到进程的地址空间。这里调用的是M a p Vi e w O f F i l e E x，而不是M a p Vi e w O f F i l e，这样，文件的映像将被映射到存放在. e x e文件映像中的基地址中。系统创建该进程的主线程，将该映射视图的可执行代码的第一个字节的地址放入线程的指令指针，然后C P U启动该代码的运行。
如果用户运行同一个应用程序的第二个实例，系统就认为规定的. e x e文件已经存在一个文件映射对象，因此不会创建新的文件对象或者文件映射对象。相反，系统将第二次映射该文件的一个视图，这次是在新创建的进程的地址空间环境中映射的。系统所做的工作是将相同的文件同时映射到两个地址空间。显然，这是对内存的更有效的使用，因为两个进程将共享包含正在执行的这部分代码的物理存储器的同一个页面。
与所有内核对象一样，可以使用3种方法与多个进程共享对象，这3种方法是句柄继承性、句柄命名和句柄复制。
8.页文件支持的内存映射文件
到现在为止，已经介绍了映射驻留在磁盘驱动器上的文件视图的方法。许多应用程序在运行时都要创建一些数据，并且需要将数据传送给其他进程，或者与其他进程共享。如果应用程序必须在磁盘驱动器上创建数据文件，并且将数据存储在磁盘上以便对它进行共享，那么这将是非常不方便的。
M i c r o s o f t公司认识到了这一点，并且增加了一些功能，以便创建由系统的页文件支持的内存映射文件，而不是由专用硬盘文件支持的内存映射文件。这个方法与创建内存映射磁盘文件所用的方法几乎相同，不同之处是它更加方便。一方面，它不必调用C r e a t e F i l e函数，因为你不是要创建或打开一个指定的文件，你只需要像通常那样调用C r e a t e F i l e M a p p i n g函数，并且传递I N VA L I D _ H A N D L E _ VA L U E作为h F i l e参数。这将告诉系统，你不是创建其物理存储器驻留在磁盘上的文件中的文件映射对象，相反，你想让系统从它的页文件中提交物理存储器。分配的存储器的数量由C r e a t e F i l e M a p p i n g函数的d w M a x i m u m S i z e H i g h和d w M a x i m u m S i z e L o w两个参数来决定。
当创建了文件映射对象并且将它的一个视图映射到进程的地址空间之后，就可以像使用任何内存区域那样使用它。如果你想要与其他进程共享该数据，可调用C r e a t e F i l e M a p p i n g函数，并传递一个以0结尾的字符串作为p s z N a m e参数。然后，想要访问该存储器的其他进程就可以调用C r e a t e F i l e M a p p i n g或O p e n F i l e M a p p i n g函数，并传递相同的名字。
当进程不再想要访问文件映射对象时，该进程应该调用C l o s e H a n d l e函数。当所有句柄均被关闭后，系统将从系统的页文件中收回已经提交的存储器