rzaripov.kz

Поиск по файлам в Delphi с многопоточностью

Полнотекстовый поиск по каталогу кажется простой задачей: получить список файлов, прочитать содержимое и проверить вхождение запроса. На архивах с документами, исходным кодом и логами последовательный проход надолго блокирует интерфейс. Параллельные рабочие потоки сокращают ожидание, если задачи распределены равномерно, а общие данные защищены от одновременного изменения.

В Delphi задачу удобно разделить на подготовку списка файлов, чтение содержимого и выдачу результатов. Современные версии языка предоставляют TTask, TParallel и TEvent, поэтому большинству проектов не нужен собственный поток. Подход подходит утилитам, настольным программам и приложениям FireMonkey, если вывод отделён от фонового чтения.

Архитектура поиска без блокировки интерфейса

Сначала вызывается TDirectory.GetFiles с маской вроде *.txt и признаком рекурсивного обхода. Перечисление выполняется до запуска параллельных задач: так потоки получают готовый перечень и не соревнуются за каталог. Для очень большого дерева обход каталога также стоит перенести в отдельную задачу, поскольку получение метаданных файлов может занимать заметное время.

Затем каждый файл становится независимой единицей работы. Поток читает содержимое, проверяет запрос и сохраняет найденное совпадение. Разделение на уровне файла проще распределять, отменять и повторять после ошибки. Слишком мелкое дробление по строкам, наоборот, увеличит накладные расходы на запуск задач.

Для FireMonkey результаты нельзя выводить напрямую из рабочего потока. Формы и их компоненты принадлежат основному потоку, поэтому обновление интерфейса выполняется через TThread.Queue или ожидание результата в асинхронной процедуре формы. Такой обмен сохраняет отзывчивость окна и не создаёт гонок за компоненты.

Безопасный доступ к общим результатам

Список файлов после подготовки доступен потокам только для чтения. Общий список совпадений требует защиты: добавление элемента меняет внутреннее состояние коллекции, даже если найденные файлы не повторяются. Для небольшого примера достаточно TMonitor, поскольку синхронизация выполняется только на коротком этапе добавления.

Блокировка должна охватывать само изменение коллекции, а не чтение файла. Не следует удерживать её во время TFile.LoadFromFile или ожидания другого потока: долгая блокировка снижает эффект параллельности и способна вызвать взаимное ожидание. После завершения задач снимок результатов передаётся вызывающему коду уже без конкурентного доступа.

Для потоковой выдачи подходит TQueue, для пакетного накопления — обычная коллекция под монитором. Визуальные компоненты обновляются только в основном потоке. Такой контракт проще поддерживать: рабочие потоки производят данные, а слой представления отвечает за их отображение.

Реализация через TParallel и TTask

Следующий пример использует TParallel.For для обработки массива путей. Функция SearchFiles возвращает массив записей с именем файла и номером строки. Параметр StopEvent позволяет остановить работу, а TMonitor защищает общий список совпадений.

uses
  System.Classes, System.Generics.Collections, System.IOUtils,
  System.SyncObjs, System.SysUtils, System.Threading;

type
  TSearchHit = record
    FileName: string;
    Line: Integer;
  end;

function SearchFiles(const RootDir, Mask, Query: string;
  StopEvent: TEvent): TArray<TSearchHit>;
var
  Files: TArray<string>;
  Hits: TList<TSearchHit>;

  procedure SearchOne(const Index: Integer);
  var
    Content: string;
    FileName: string;
    Position: Integer;
    LineNumber: Integer;
    I: Integer;
    Hit: TSearchHit;
  begin
    if StopEvent.WaitFor(0) = wrSignaled then
      Exit;

    FileName := Files[Index];
    try
      Content := TFile.LoadFromFile(FileName, TEncoding.UTF8);
    except
      // В рабочей версии причина ошибки записывается в журнал.
      Exit;
    end;

    Position := Pos(Query, Content);
    if Position = 0 then
      Exit;

    LineNumber := 1;
    for I := 1 to Position - 1 do
      if Content[I] = #10 then
        Inc(LineNumber);

    Hit.FileName := FileName;
    Hit.Line := LineNumber;

    TMonitor.Enter(Hits);
    try
      Hits.Add(Hit);
    finally
      TMonitor.Exit(Hits);
    end;
  end;

begin
  Result := nil;
  if (RootDir = '') or (Query = '') then
    Exit;

  Files := TDirectory.GetFiles(RootDir, Mask, [soRecurse]);
  Hits := TList.Create;
  try
    if Length(Files) > 0 then
      TParallel.For(0, Length(Files) - 1, SearchOne);
    Result := Hits.ToArray;
  finally
    Hits.Free;
  end;
end;

После TParallel.For функция получает готовый TArray<TSearchHit>. Его можно передать в модель, сохранить в отчёте или отобразить в компоненте списка. Если поиск запускается из формы, саму функцию удобно вызвать через TTask.Run, а итоговый массив вернуть в основной поток. Порядок совпадений не гарантирован, поэтому сортировку выполняют после сбора результатов.

TTask также подходит для разных сценариев: ограничения времени, повторные попытки, приоритеты и объединение нескольких источников. Собственный TThread оправдан при длительном цикле, специальной очереди или нестандартной очистке ресурсов. Создавать отдельный поток для каждого файла невыгодно из-за расходов на запуск и большого числа ожидающих задач.

Отмена поиска и обработка ошибок

Ошибка чтения одного файла не должна отменять весь поиск. Отсутствующие права, удалённый во время обхода файл или повреждённые данные относятся к ожидаемым сбоям отдельной задачи. Их записывают в журнал и продолжают обработку; неожиданные исключения сохраняют для диагностики, чтобы не скрывать дефекты приложения.

Отмена выполняется через TEvent: основной поток вызывает SetEvent, а рабочие проверяют WaitFor(0) между файлами. Это удобнее простой булевой переменной, поскольку событие имеет определённую семантику ожидания. После сигнала новые файлы не запускаются, а уже выполняющиеся задачи завершают текущий шаг.

Проверка отмены не прерывает чтение, которое уже блокирует поток. Сетевой диск или проблемный сервер могут удерживать вызов надолго, поэтому для таких источников нужны тайм-ауты и ограниченный набор одновременных соединений. При закрытии формы сначала отменяют поиск и дожидаются его завершения, затем освобождают общие коллекции и событие.

Кодировки, большие файлы и производительность

Кодировку нужно задавать явно. TEncoding.UTF8 подходит для большинства современных текстов, но TEncoding.Default не гарантирует одинаковое поведение на всех операционных системах. Файлы UTF-16, ANSI или без BOM требуют отдельной обработки; неверно выбранная кодировка даёт ложные совпадения или ошибки преобразования.

Бинарные файлы лучше исключать по расширению, размеру и признакам содержимого. Поиск NUL-байтов или слишком крупных объектов расходует память и время без практической пользы. При большом объёме TFile.LoadFromFile лучше заменить потоковым чтением через TFileStream и TStreamReader: так текст обрабатывается частями, а номер строки известен при совпадении.

Поиск без учёта регистра требует сравнения с правилами языка, а не простого изменения регистра всего документа. При потоковой обработке нужно также учитывать совпадение на границе буферов. Производительность зависит от накопителя: на SSD параллельный доступ к метаданным полезен, а на HDD случайное чтение множества мелких файлов может ухудшить отклик.

Стратегии выбора для разных задач

Выбор стратегии зависит от числа файлов, их размера и требований к интерфейсу. Для небольшого каталога последовательного прохода достаточно. TParallel.For удобен при пакетной обработке, TTask подходит для асинхронного сценария, а TThread даёт полный контроль над жизненным циклом потока.

Универсального числа рабочих потоков нет. Для сетевых каталогов ограничивают одновременные запросы, для локальных SSD обычно полезны несколько параллельных задач. Очень мелкое дробление и слишком большой пул одинаково снижают эффективность, поэтому число активных задач подбирают по измерениям на реальных данных.

Подход Когда выбирать Ограничение
Последовательный проход Небольшой каталог или простая утилита Занимает время выполнения всех файлов
TParallel.For Пакетная обработка множества файлов Нужна синхронизация общих результатов
TTask Асинхронный интерфейс и отмена поиска Требуется безопасный возврат результата
TThread Особый жизненный цикл, очередь или длительная фоновая работа Больше кода управления потоком и ресурсами

В моих проектах на Delphi и FireMonkey поисковое ядро отделяется от интерфейса и работает как независимый модуль. Версии для Windows, macOS и Linux используют системные API файловой подсистемы, а приложения для Android и iOS учитывают разрешения и песочницу. Связанные технические материалы и ссылки на блог и репозитории GitHub собраны на странице проекта.