浅谈内存映射文件

内存映射文件（Memory-Mapped File, MMF）允许将文件内容直接映射到进程的虚拟地址空间，使得应用程序能够像访问内存一样访问文件数据。这种机制通过操作系统虚拟内存管理器（Virtual Memory Manager, VMM）的深度集成，绕过了传统I/O操作中固有的数据复制和系统调用开销，从而在特定场景下实现数量级的性能提升。对于开发那些需要在I/O性能上达到极致的系统（如数据库、大数据分析平台、金融交易系统）而言，深入理解并掌握MMF是不可或缺的关键技能。

从传统I/O到内存映射的转变

传统的文件I/O，如通过FileStream进行的操作，其本质是指令驱动的。开发者通过Read、Write、Seek等命令，显式地请求操作系统在内核缓冲区和用户空间缓冲区之间移动数据 。这个过程涉及多次数据复制和频繁的上下文切换，是典型I/O瓶颈的根源。

相比之下，内存映射文件是一种状态驱动的模式。开发者不再是命令“移动数据”，而是声明“让这个文件成为我内存的一部分”。一旦映射建立，对文件的读写就转变为对内存地址的直接操作。这种转变将繁琐的I/O管理职责委托给了操作系统，带来了显著的性能优势，但同时也引入了一系列新的开发考量，例如并发控制、数据持久化和内存布局管理等等。

内存映射文件的基础

内存映射文件并非应用层面的技巧，而是与操作系统虚拟内存子系统深度耦合的底层机制。其高性能的“魔法”源于对现代操作系统和硬件能力的充分利用。

核心引擎：虚拟内存管理器

内存映射文件的核心在于，它是一个进程虚拟地址空间中的一个段（segment），该段与文件或类文件资源（如共享内存对象）的某一部分建立了直接的、逐字节的对应关系。这一映射过程由操作系统的虚拟内存管理器（VMM）全权负责，而VMM也同样负责管理进程的常规内存分配和页面交换文件（swap file）。这个过程离不开一个关键的硬件组件：内存管理单元（Memory Management Unit, MMU）。MMU负责将应用程序使用的虚拟地址实时翻译成物理RAM中的地址。当应用程序试图访问一个位于映射区域内的虚拟地址时，如果该地址对应的数据尚未加载到物理内存中，MMU会无法完成翻译，并触发一个硬件中断，将控制权交给操作系统内核。这表明MMF的实现不仅是软件层面的抽象，更是由硬件加速的。

惰性加载机制：按需分页（Demand Paging）

MMF处理大文件之所以高效，其秘诀在于“按需分页”或称“惰性加载”（Lazy Loading）的机制 ，整个过程如下：

1. 初始访问与缺页中断（Page Fault）：应用程序首次访问映射区域内的某个内存地址时，MMU在其页表（Page Table）中找不到对应的物理内存映射，于是触发一次“缺页中断”。
2. 内核处理：操作系统内核的缺页中断处理程序接管控制。它检查到此次中断发生在内存映射区域，随即执行以下操作：
   1. 在物理RAM中分配一个空闲的页帧（Page Frame）。
   2. 从磁盘上的源文件中，读取与faulted 虚拟地址对应的、页面大小（通常为4KB）的数据块。
   3. 将读取的数据块载入新分配的物理页帧。
   4. 更新进程的页表，建立虚拟地址到该物理页帧的映射关系
3. 指令重启：内核将控制权交还给应用程序，并重新执行之前失败的内存访问指令。这一次，由于MMU能在页表中找到有效的映射，地址翻译成功，数据访问顺利完成。

这种机制意味着，应用程序只有在真正“触碰”到文件某部分数据时，才会产生实际的磁盘I/O开销。这使得程序能以极小的内存占用量来操作远超物理内存大小的文件（例如TB级别），因为文件内容是按需、一页一页地载入内存的。

“零拷贝”优势

MMF最显著的性能优势之一来源于其“零拷贝”（Zero-Copy）特性，这需要与传统I/O的数据路径进行对比。

• 传统I/O的低效路径：当使用标准read()系统调用时，数据至少要经历两次拷贝，这两次拷贝不仅消耗CPU周期，还会污染CPU缓存，降低整体效率：
  1. 磁盘到内核：DMA控制器将数据从磁盘读取到内核空间的页缓存（Page Cache）中。
  2. 内核到用户：CPU将数据从内核的页缓存拷贝到应用程序在用户空间分配的缓冲区中。
• MMF的直接路径：使用MMF时，VMM直接将文件的页缓存映射到进程的虚拟地址空间。数据从磁盘被读取到页缓存中后，应用程序可以直接通过内存指针访问这块位于内核空间的内存。省去了第二次从内核空间到用户空间的拷贝，这是“零拷贝”优化的精髓所在。

此外，MMF还大幅减少了系统调用的数量。在初始的mmap()调用之后，后续的读写操作都变成了简单的内存访问，避免了read()和write()这类操作所需的高昂的上下文切换开销 。

由于所有I/O都以页面为单位进行，访问一个字节和访问4KB（假设页大小为4KB）的初始磁盘开销是相同的。这意味着，当数据访问呈现出良好的“空间局部性”（即连续访问物理上相邻的数据）时，MMF的效率最高，因为一次缺页中断加载的数据能被多次利用。反之，如果对微小且在文件中广泛分散的数据进行随机访问，可能会导致“缺页抖动”（Page Fault Thrashing），即频繁地发生缺页中断并换入换出页面，此时性能可能反而不如传统的、可以精确控制读取字节数的I/O方法。

应用场景

理解了MMF的底层原理后，下一步是明确其在实际工程中的战略定位。选择MMF不仅是技术选型，更是一种架构决策。

高性能大文件处理

• 数据库与搜索引擎：MMF是许多高性能数据存储系统的基石。例如，SQLite、MongoDB早期的MMAPv1存储引擎以及Lucene等搜索引擎索引，都利用MMF将庞大的磁盘数据结构视为内存的一部分。这使得它们能够实现快速的随机数据检索和原地更新（in-place update），而无需在应用层面实现复杂的缓存逻辑 。
• 实时分析与大数据：在处理海量数据集的场景，如机器学习的特征存储、金融时间序列分析等，MMF允许程序高效地对数据进行“窗口”操作或随机采样，而无需将整个文件加载到内存中。
• 原地编辑应用：对于视频剪辑、大型图像处理等应用，MMF允许直接修改文件的特定部分，避免了“读取整个文件 -> 在内存中修改 -> 写回整个文件”的低效流程。

进程间通信（IPC）

MMF提供了在同一台机器上最高效的IPC机制之一。通过让多个进程映射同一个“命名”的MMF，它们实际上共享了完全相同的物理内存页。一个进程写入的数据可以被其他进程立即看到，无需通过管道、套接字等需要内核中转的机制。MMF用于IPC时，存在两种模式：

• 非持久化IPC（Non-persisted）：通过MemoryMappedFile.CreateNew创建，这类MMF由系统页文件（page file）作为后备存储，而非磁盘上的特定文件。它非常适合用于临时的、高速的数据交换，因为当最后一个进程句柄关闭后，这块内存就会被系统回收。这本质上就是纯粹的共享内存 。
• 持久化IPC（Persisted）：通过MemoryMappedFile.CreateFromFile创建，这类MMF使用一个真实的磁盘文件作为后备存储。这实现了“持久化的IPC”，即共享的数据可以在进程重启甚至系统重启后依然存在 。

系统级应用

• 程序加载器：几乎所有现代操作系统（包括Windows、Linux、macOS）都使用MMF来加载可执行文件（如.exe, .dll, .so）。操作系统将文件映射到进程的地址空间，代码和数据段根据执行或访问的需要被“按需分页”载入。这是惰性加载最经典的体现 。
• 共享库：当多个进程使用同一个共享库（如Kernel32.dll或libc.so）时，操作系统只需将该库的代码段在物理内存中加载一次，然后将其映射到所有使用它的进程的虚拟地址空间中。这是通过MMF实现的巨大内存节省优化。

性能剖析：何时选择MMF

基于其工作原理，MMF的适用场景非常明确，MMF表现卓越的场景：

• 大文件随机访问：当需要频繁、非顺序地访问大文件时，MMF的性能远超传统I/O。
• 并发读取：多个进程或线程需要高并发地读取同一份数据集时，MMF通过共享物理内存页，避免了重复的磁盘读取。
• 低延迟IPC：当进程间通信的延迟要求达到极致时，MMF是首选方案 。
• 简化编程模型：当将文件视为一个巨大的内存数组可以极大简化应用逻辑时。

传统I/O可能更优的场景：

• 严格的顺序读写：对于一次性、从头到尾的顺序读写操作（如文件复制），操作系统为流式I/O设计的预读（read-ahead）等优化机制，其性能可能优于MMF的逐页加载。
• 文件远超内存且顺序访问：当文件大小远超可用物理内存，且访问模式是纯顺序时，精心设计的缓冲流可以更好地控制内存占用，避免MMF可能引起的内存抖动。
• 需要精确的资源控制：当需要对内存使用和I/O缓冲进行精确控制以获得可预测的性能时，传统I/O提供了更多的主动权。

最终，在MMF和传统I/O之间的选择，不仅是性能基准测试的结果，更是一种架构上的权衡。选择MMF，意味着将内存和I/O管理的复杂性委托给操作系统。这简化了部分应用代码（无需手动管理缓冲区），但将并发控制、数据布局和持久性保障的责任更多地压在了开发者身上。而选择传统I/O，则赋予了开发者更明确的控制权，可以用更复杂的代码换取更可预测的系统行为。因此，这个决策的核心在于“便利性与控制权”的取舍，这是一个比单纯比较速度更高维度的考量。

C#中的内存映射文件

.NET平台通过System.IO.MemoryMappedFiles命名空间，为开发者提供了强大且易用的MMF功能。本节将通过实战代码，深入讲解如何在C#中掌握这一技术。

System.IO.MemoryMappedFiles

• MemoryMappedFile: 这是MMF操作的入口类，代表映射文件本身。它负责创建（CreateFromFile, CreateNew）和打开（OpenExisting）MMF对象 。
• MemoryMappedViewAccessor: 提供对MMF“视图”（View，即文件的一个映射部分）的随机、类似指针的访问。它使用Read<T>和Write<T>等泛型方法来高效地操作可直接映射到内存的结构体（blittable struct）。
• MemoryMappedViewStream: 在视图上提供一个标准的Stream接口。它适用于顺序访问，或与需要Stream对象的现有API（如BinaryReader, StreamWriter）集成。

MemoryMappedViewAccessor vs. MemoryMappedViewStream

• 使用 CreateViewAccessor: 当数据是结构化的（如定长记录、struct数组），并且你需要高性能的随机访问时，这是首选。这是MMF最强大和最常见的用法 。   
• 使用 CreateViewStream: 当你需要将MMF视为一个标准的流（Stream）时，例如为了与那些期望Stream对象的现有API（如StreamReader、XmlSerializer）兼容，或者进行简单的顺序处理时，使用它 。   

一个至关重要的原则是：以上所有类都管理着底层的操作系统句柄，这些是非托管资源。因此，必须始终在using语句块中使用它们，或者在自定义类中正确实现IDisposable接口，以确保资源被及时释放。否则，将导致严重的资源泄漏，并可能使文件无法被删除或被其他进程访问。

场景一：处理超大文件

目标：在一个数GB大小的结构化数据文件中，读取并原地修改记录，而不将整个文件载入内存。假设我们有一个包含大量订单记录的二进制文件"large_orders.dat"，代码如下：

1. 定义数据结构：首先，定义一个与文件中记录布局完全匹配的struct。注意，它必须是“blittable”的，即只包含值类型或同样是blittable的struct。

   using System.Runtime.InteropServices;
   
   // 使用StructLayout确保内存布局与文件格式精确匹配，无额外填充
   
   public struct OrderRecord
   {
       public long OrderId;
       public int CustomerId;
       public double OrderTotal;
       public byte Status; // 0: Pending, 1: Shipped, 2: Cancelled
   }

2. 读取与修改：下面的代码演示了如何映射文件，并修改第1000条记录的状态。

   using System;
   using System.IO;
   using System.IO.MemoryMappedFiles;
   using System.Runtime.InteropServices;
   
   public class LargeFileProcessor
   {
       public static void UpdateOrderStatus(string filePath, long recordIndex, byte newStatus)
       {
           long offset = recordIndex * Marshal.SizeOf<OrderRecord>();
           long length = Marshal.SizeOf<OrderRecord>();
   
           try
           {
               // 从现有文件创建持久化MMF
               using (var mmf = MemoryMappedFile.CreateFromFile(filePath, FileMode.Open, "OrderDataMap"))
               {
                   // 创建一个覆盖目标记录的视图访问器
                   using (var accessor = mmf.CreateViewAccessor(offset, length))
                   {
                       // 读取现有记录
                       accessor.Read(0, out OrderRecord record);
   
                       Console.WriteLine($"Reading Record {recordIndex}: ID={record.OrderId}, Status={record.Status}");
   
                       // 修改状态并写回
                       record.Status = newStatus;
                       accessor.Write(0, ref record);
   
                       Console.WriteLine($"Updated Record {recordIndex}: New Status={record.Status}");
   
                       // 确保修改被刷新到操作系统缓冲区，但不保证物理写入磁盘
                       accessor.Flush();
                   }
               }
           }
           catch (FileNotFoundException)
           {
               Console.Error.WriteLine("Error: The file was not found.");
           }
           catch (Exception ex)
           {
               Console.Error.WriteLine($"An error occurred: {ex.Message}");
           }
       }
   }

此示例展示了MMF的核心优势：通过简单的偏移量计算，即可实现对巨大文件中任意位置数据的精确、高效的读写操作 。

场景二：读取超大文件

经常有这么一个场景，一个日志文件或者数据文件很大，超过10M，如果用系统默认的记事本打开会非常慢，甚至会卡死。这时可以采用分批读取的方法，这正是MMF的使用场景，下面这个例子展示了这一方法：

1. 界面设计：界面的xmal文件如下：

   <Window x:Class="MmfLargeFileReader.MainWindow"
           xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
           xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
           xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
           xmlns:local="clr-namespace:MmfLargeFileReader"
           mc:Ignorable="d"
          Title="MMF Large File Reader" Height="600" Width="800">
   
       <Window.DataContext>
           <local:MainViewModel/>
       </Window.DataContext>
       <Window.Resources>
           <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"/>
       </Window.Resources>
       <Grid Margin="10">
           <Grid.RowDefinitions>
               <RowDefinition Height="Auto"/>
               <RowDefinition Height="*"/>
               <RowDefinition Height="Auto"/>
           </Grid.RowDefinitions>
   
           <StackPanel Grid.Row="0" Orientation="Horizontal" Margin="0,0,0,10">
               <Button Content="Select File..." Command="{Binding SelectFileCommand}" Padding="10,5"/>
               <TextBlock Text="{Binding FilePath, FallbackValue='No file selected'}" VerticalAlignment="Center" Margin="10,0" FontStyle="Italic"/>
               <TextBlock Text="Lines per load:" VerticalAlignment="Center" Margin="20,0,5,0"/>
               <TextBox Text="{Binding LinesToLoad, UpdateSourceTrigger=PropertyChanged}" Width="50" VerticalAlignment="Center"/>
               <Button Content="Load Initial" Command="{Binding LoadInitialCommand}" Padding="10,5" Margin="20,0,5,0" FontWeight="Bold"/>
               <Button Content="Load More" Command="{Binding LoadMoreCommand}" Padding="10,5"/>
           </StackPanel>
   
           <TextBox Grid.Row="1" 
                    Text="{Binding FileContent, Mode=OneWay}"
                    IsReadOnly="True"
                    VerticalScrollBarVisibility="Auto"
                    HorizontalScrollBarVisibility="Auto"
                    FontFamily="Consolas"
                    AcceptsReturn="True"/>
   
           <StatusBar Grid.Row="2">
               <StatusBarItem>
                   <TextBlock Text="{Binding StatusText, FallbackValue='Ready'}"/>
               </StatusBarItem>
               <StatusBarItem HorizontalAlignment="Right">
                   <ProgressBar IsIndeterminate="{Binding IsBusy}" Width="100" Height="15" Visibility="{Binding IsBusy, Converter={StaticResource BooleanToVisibilityConverter}}"/>
               </StatusBarItem>
           </StatusBar>
       </Grid>
   </Window>
   

2. 后台逻辑如下：

   public class RelayCommand : ICommand
   {
   
       private readonly Action<object> _execute;
       private readonly Predicate<object> _canExecute;
   
       public event EventHandler CanExecuteChanged
       {
           add { CommandManager.RequerySuggested += value; }
           remove { CommandManager.RequerySuggested -= value; }
       }
   
       public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
       {
           _execute = execute ?? throw new ArgumentNullException(nameof(execute));
           _canExecute = canExecute;
       }
   
       public bool CanExecute(object parameter)
       {
           return _canExecute == null || _canExecute(parameter);
       }
   
       public void Execute(object parameter)
       {
           _execute(parameter);
       }
   
   }
   
   public class MainViewModel : INotifyPropertyChanged
   {
       // 私有字段
       private string _filePath;
       private string _fileContent;
       private string _statusText;
       private int _linesToLoad = 1000;
       private long _currentBytePosition = 0;
       private long _totalLinesRead = 0;
       private bool _isBusy = false;
   
       // 公开属性，用于数据绑定
       public string FilePath
       {
           get => _filePath;
           set { _filePath = value; OnPropertyChanged(); OnPropertyChanged(nameof(IsFileSelected)); }
       }
   
       public string FileContent
       {
           get => _fileContent;
           set { _fileContent = value; OnPropertyChanged(); }
       }
   
       public string StatusText
       {
           get => _statusText;
           set { _statusText = value; OnPropertyChanged(); }
       }
   
       public int LinesToLoad
       {
           get => _linesToLoad;
           set { _linesToLoad = value; OnPropertyChanged(); }
       }
   
       public bool IsFileSelected => !string.IsNullOrEmpty(FilePath);
   
       public bool IsBusy
       {
           get => _isBusy;
           set { _isBusy = value; OnPropertyChanged(); }
       }
   
       // 命令
       public ICommand SelectFileCommand { get; }
       public ICommand LoadInitialCommand { get; }
       public ICommand LoadMoreCommand { get; }
   
       public MainViewModel()
       {
           SelectFileCommand = new RelayCommand(SelectFile);
           LoadInitialCommand = new RelayCommand(async _ => await LoadLines(true), _ => IsFileSelected && !IsBusy);
           LoadMoreCommand = new RelayCommand(async _ => await LoadLines(false), _ => IsFileSelected && !IsBusy && _currentBytePosition > 0);
       }
   
       private void SelectFile(object obj)
       {
           OpenFileDialog openFileDialog = new OpenFileDialog
           {
               Filter = "Text files (*.txt)|*.txt|All files (*.*)|*.*",
               Title = "Select a large text file"
           };
   
           if (openFileDialog.ShowDialog() == true)
           {
               FilePath = openFileDialog.FileName;
               // 重置状态
               FileContent = string.Empty;
               _currentBytePosition = 0;
               _totalLinesRead = 0;
               StatusText = $"Selected file: {Path.GetFileName(FilePath)}";
           }
       }
   
       private async Task LoadLines(bool isInitialLoad)
       {
           if (IsBusy) return;
           IsBusy = true;
           StatusText = "Loading...";
   
           try
           {
               if (isInitialLoad)
               {
                   _currentBytePosition = 0;
                   _totalLinesRead = 0;
                   FileContent = string.Empty;
               }
   
               var lines = await Task.Run(() => ReadNextLines());
   
               // 为了性能，当文本过长时，我们不再使用 += 拼接字符串
               var sb = new StringBuilder(FileContent);
               if (!isInitialLoad)
               {
                   sb.AppendLine("--- More content loaded ---");
               }
               sb.Append(lines);
               FileContent = sb.ToString();
   
               StatusText = $"Successfully loaded. Total lines read: {_totalLinesRead}. Current position: {_currentBytePosition:N0} bytes.";
           }
           catch (Exception ex)
           {
               StatusText = $"Error: {ex.Message}";
           }
           finally
           {
               IsBusy = false;
               // 强制刷新命令状态
               CommandManager.InvalidateRequerySuggested();
           }
       }
   
       private string ReadNextLines()
       {
           var linesReadThisTurn = 0;
           var sb = new StringBuilder();
           long fileLength = new FileInfo(FilePath).Length;
   
           if (_currentBytePosition >= fileLength)
           {
               StatusText = "Reached end of file.";
               return string.Empty;
           }
   
           // MMF的核心优势在于，即使文件有几GB大，也只会按需将视图内的部分载入物理内存
           using (var mmf = MemoryMappedFile.CreateFromFile(FilePath, FileMode.Open, null, 0, MemoryMappedFileAccess.Read))
           {
               // 创建一个从当前位置到文件末尾的视图流
               // 操作系统会智能地处理物理内存的分配
               using (var viewStream = mmf.CreateViewStream(_currentBytePosition, 0, MemoryMappedFileAccess.Read))
               {
                   // 使用StreamReader可以方便地处理文本编码和按行读取
                   using (var reader = new StreamReader(viewStream, Encoding.UTF8, true))
                   {
                       string line;
                       while ((line = reader.ReadLine()) != null && linesReadThisTurn < LinesToLoad)
                       {
                           sb.AppendLine(line);
                           linesReadThisTurn++;
                       }
   
                       // 这是最关键的一步：更新我们下一次读取开始的字节位置
                       // reader.BaseStream.Position 会告诉我们在这个视图中读取了多少字节
                       _currentBytePosition += ((MemoryMappedViewStream)reader.BaseStream).Position;
                   }
               }
           }
   
           _totalLinesRead += linesReadThisTurn;
           return sb.ToString();
       }
   
       // INotifyPropertyChanged 实现
       public event PropertyChangedEventHandler PropertyChanged;
       protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
       {
           PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
       }
   }

3. 运行结果如下：

场景三：高速进程间通信（IPC）

目标：创建一个“生产者”进程持续写入数据，同时一个“消费者”进程实时读取该数据。此场景需要两个独立的程序，它们通过一个命名的MMF和命名的Mutex进行通信和同步。
C# 代码示例：

1. 生产者（Producer.cs）:

   using System;
   using System.IO.MemoryMappedFiles;
   using System.Threading;
   
   class Producer
   {
       static void Main()
       {
           const string mapName = "MyIPCSharedMemory";
           const string mutexName = "MyIPCMutex";
           const int dataSize = 1024; // 共享内存大小为1KB
   
           // 创建一个非持久化的MMF，由系统页文件支持
           using (var mmf = MemoryMappedFile.CreateNew(mapName, dataSize))
           {
               // 创建一个命名的、系统级的Mutex用于同步。
               // 将初始状态设置为 false，表示创建时任何进程都不拥有它。
               bool mutexCreated;
               using (var mutex = new Mutex(false, mutexName, out mutexCreated))
               {
                   // 创建视图访问器
                   using (var accessor = mmf.CreateViewAccessor())
                   {
                       for (int i = 0; i < 100; i++)
                       {
                           // 在写入前，等待并获取互斥锁
                           mutex.WaitOne();
                           try
                           {
                               // 在临界区内写入数据
                               accessor.Write(0, i); // 在偏移量0写入当前的计数值
                               Console.WriteLine($"Producer wrote: {i}");
                           }
                           finally
                           {
                               // 操作完成后，必须释放互斥锁，以便消费者可以读取
                               mutex.ReleaseMutex();
                           }
                           
                           // 模拟其他工作
                           Thread.Sleep(500);
                       }
                   }
               }
           }
       }
   }

2. 消费者（Consumer.cs）:

   using System;
   using System.IO.MemoryMappedFiles;
   using System.Threading;
   
   class Consumer
   {
       static void Main()
       {
           const string mapName = "MyIPCSharedMemory";
           const string mutexName = "MyIPCMutex";
   
           Console.WriteLine("Consumer waiting for producer...");
           Thread.Sleep(1000); // 等待生产者创建MMF和Mutex
   
           try
           {
               // 打开已存在的MMF
               using (var mmf = MemoryMappedFile.OpenExisting(mapName))
               {
                   // 打开已存在的Mutex
                   using (var mutex = Mutex.OpenExisting(mutexName))
                   {
                       // 创建视图访问器
                       using (var accessor = mmf.CreateViewAccessor())
                       {
                           for (int i = 0; i < 100; i++)
                           {
                               mutex.WaitOne(); // 等待并获取互斥锁
                               try
                               {
                                   int value = accessor.ReadInt32(0);
                                   Console.WriteLine($"Consumer read: {value}");
                               }
                               finally
                               {
                                   mutex.ReleaseMutex(); // 确保释放互斥锁
                               }
                               Thread.Sleep(500);
                           }
                       }
                   }
               }
           }
           catch (WaitHandleCannotBeOpenedException)
           {
               Console.Error.WriteLine("Mutex not found. Is the producer running?");
           }
           catch (FileNotFoundException)
           {
               Console.Error.WriteLine("Memory-mapped file not found. Is the producer running?");
           }
       }
   }

这个例子清晰地展示了如何使用命名的MMF和Mutex在完全独立的进程之间建立一个高效、同步的数据共享通道 。

结语

内存映射文件是一项功能强大但要求苛刻的技术。它通过将应用程序的内存操作与操作系统的虚拟内存架构对齐，提供了无与伦比的I/O性能潜力。然而，这份强大的力量伴随着重大的责任：开发者必须亲自处理并发控制、数据持久性和跨进程安全等复杂问题，而这些问题在许多其他I/O抽象中是被透明处理的。内存映射文件的核心思想——将存储视为内存的延伸——在今天依然具有强大的生命力。随着持久性内存（Persistent Memory, PMEM）等新硬件的出现，MMF的概念变得更加贴近物理现实。对于那些需要极致单节点性能和低延迟IPC的高密度服务（如缓存、消息队列、数据代理），MMF仍然是一种极具竞争力的核心技术。掌握它，意味着掌握了构建真正高性能系统的关键钥匙。

参考：

• https://learn.microsoft.com/en-us/dotnet/standard/io/memory-mapped-files