32位Delphi程序访问200GB图片性能优化方案咨询

方案对比与选型建议 #

针对你的场景，两种方案各有优劣，结合可靠、易维护的需求，优先推荐MSSQL Server 2019内存优化表方案，原因如下：

• 无需自行开发缓存管理、IPC通信逻辑，利用数据库原生的内存优化机制，可靠性与维护性更高
• 32位程序访问SQL Server无任何跨位限制，开发测试成本极低
• 支持数据持久化，避免服务器重启后缓存丢失

若追求极致性能，可选择64位TCP缓存服务方案，通过TIdTCPServer/TIdTCPClient实现跨位通信，完全规避32位程序内存限制问题。

方案1：MSSQL内存优化表实现 #

1. 创建内存优化表 #

首先在SQL Server中创建带持久化的内存优化表，用于存储图片数据：

-- 添加内存优化文件组（仅需执行一次）
ALTER DATABASE ImageDB ADD FILEGROUP ImageMemoryGroup CONTAINS MEMORY_OPTIMIZED_DATA;
ALTER DATABASE ImageDB ADD FILE (NAME = 'ImageStorage', FILENAME = 'D:\SQL_Memory_Files\ImageStorage') TO FILEGROUP ImageMemoryGroup;

-- 创建内存优化表（SCHEMA_AND_DATA确保重启后数据不丢失）
CREATE TABLE dbo.ImageCache
(
    ImageFullPath NVARCHAR(255) NOT NULL PRIMARY KEY NONCLUSTERED HASH WITH (BUCKET_COUNT = 1000000), -- 桶数匹配图片总量（示例为100万张）
    ImageBinary VARBINARY(MAX) NOT NULL
) WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA);

2. 批量导入图片到内存表 #

编写64位批量导入工具（32位程序无法加载200GB数据），遍历目录导入所有图片：

using System;
using System.Data.SqlClient;
using System.IO;

class ImageBatchImporter
{
    static void Main(string[] args)
    {
        var connStr = "Server=localhost;Database=ImageDB;Integrated Security=True;";
        var rootImageDir = @"E:\Main_Image_Directory";

        using (var conn = new SqlConnection(connStr))
        {
            conn.Open();
            // 使用SqlBulkCopy提升批量插入性能
            using (var bulkCopy = new SqlBulkCopy(conn))
            {
                bulkCopy.DestinationTableName = "dbo.ImageCache";
                bulkCopy.ColumnMappings.Add("ImageFullPath", "ImageFullPath");
                bulkCopy.ColumnMappings.Add("ImageBinary", "ImageBinary");

                foreach (var dir in Directory.GetDirectories(rootImageDir))
                {
                    foreach (var filePath in Directory.GetFiles(dir, "*.jpg|*.png", SearchOption.TopDirectoryOnly))
                    {
                        try
                        {
                            var imageBytes = File.ReadAllBytes(filePath);
                            var dataTable = new System.Data.DataTable();
                            dataTable.Columns.Add("ImageFullPath", typeof(string));
                            dataTable.Columns.Add("ImageBinary", typeof(byte[]));
                            dataTable.Rows.Add(filePath, imageBytes);

                            bulkCopy.WriteToServer(dataTable);
                            Console.WriteLine($"导入完成: {filePath}");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"导入失败 {filePath}: {ex.Message}");
                        }
                    }
                }
            }
            conn.Close();
        }
        Console.WriteLine("所有图片导入完成");
    }
}

3. 32位程序查询图片 #

在你的32位服务程序中，通过ADO访问SQL内存表获取图片数据（以Delphi为例）：

function GetImageFromDB(const AImagePath: string): TBytes;
var
  Query: TADOQuery;
begin
  Result := nil;
  Query := TADOQuery.Create(nil);
  try
    Query.Connection := YourDBConnection; // 已初始化的ADO连接
    Query.SQL.Text := 'SELECT ImageBinary FROM dbo.ImageCache WHERE ImageFullPath = :Path';
    Query.Parameters.ParamByName('Path').Value := AImagePath;
    Query.Open;

    if not Query.Eof then
      Result := TBlobField(Query.FieldByName('ImageBinary')).AsBytes;
  finally
    Query.Free;
  end;
end;

方案2：64位TCP缓存服务实现 #

1. 64位缓存服务端（Delphi） #

加载所有图片到内存，通过TIdTCPServer提供查询服务：

unit ImageCacheServer;

interface

uses
  System.SysUtils, System.Classes, IdContext, IdTCPServer, System.Generics.Collections,
  System.IOUtils;

type
  TImageCacheServer = class(TIdTCPServer)
  private
    FImageStore: TDictionary<string, TBytes>;
    procedure LoadAllImages(const ARootDir: string);
    procedure DoExecute(AContext: TIdContext); override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure Start(const ARootDir: string; APort: Integer);
  end;

implementation

{ TImageCacheServer }

constructor TImageCacheServer.Create(AOwner: TComponent);
begin
  inherited;
  FImageStore := TDictionary<string, TBytes>.Create;
end;

destructor TImageCacheServer.Destroy;
begin
  FImageStore.Free;
  inherited;
end;

procedure TImageCacheServer.DoExecute(AContext: TIdContext);
var
  RequestPath: string;
  ImageData: TBytes;
  DataLen: Int64;
begin
  // 读取客户端发送的图片路径（UTF-8编码）
  RequestPath := AContext.Connection.IOHandler.ReadLn(TEncoding.UTF8);
  
  if FImageStore.TryGetValue(RequestPath, ImageData) then
  begin
    DataLen := Length(ImageData);
    AContext.Connection.IOHandler.Write(DataLen); // 先发送数据长度
    AContext.Connection.IOHandler.Write(ImageData); // 发送图片数据
  end
  else
  begin
    AContext.Connection.IOHandler.Write(Int64(-1)); // 标记图片不存在
  end;
end;

procedure TImageCacheServer.LoadAllImages(const ARootDir: string);
var
  FilePath: string;
begin
  FImageStore.Clear;
  for FilePath in TDirectory.GetFiles(ARootDir, '*.*', TSearchOption.soAllDirectories) do
  begin
    if SameText(ExtractFileExt(FilePath), '.jpg') or SameText(ExtractFileExt(FilePath), '.png') then
    begin
      try
        FImageStore.Add(FilePath, TFile.ReadAllBytes(FilePath));
        Writeln(Format('已加载: %s', [FilePath]));
      except
        on E: Exception do
          Writeln(Format('加载失败 %s: %s', [FilePath, E.Message]));
      end;
    end;
  end;
end;

procedure TImageCacheServer.Start(const ARootDir: string; APort: Integer);
begin
  LoadAllImages(ARootDir);
  DefaultPort := APort;
  Active := True;
  Writeln('缓存服务已启动，端口: ', APort);
end;

end.

2. 32位客户端访问代码（Delphi） #

在32位服务程序中，通过TIdTCPClient请求图片数据：

function GetImageFromCache(const AImagePath, AServerIP: string; APort: Integer): TBytes;
var
  Client: TIdTCPClient;
  DataLen: Int64;
begin
  Result := nil;
  Client := TIdTCPClient.Create(nil);
  try
    Client.Host := AServerIP;
    Client.Port := APort;
    Client.Connect;
    
    try
      // 发送图片路径
      Client.IOHandler.WriteLn(AImagePath, TEncoding.UTF8);
      // 读取数据长度
      DataLen := Client.IOHandler.ReadInt64;
      
      if DataLen > 0 then
      begin
        SetLength(Result, DataLen);
        Client.IOHandler.ReadBytes(Result, DataLen);
      end;
    finally
      Client.Disconnect;
    end;
  finally
    Client.Free;
  end;
end;

内容的提问来源于stack exchange，提问作者zaaai bon