rzaripov.kz

Многопоточность в FireMonkey: TThread и TTask

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

В Delphi для таких задач чаще всего применяются два подхода: классический TThread и более современная модель задач TTask из Parallel Programming Library. Оба механизма используют системные потоки, однако отличаются уровнем контроля, способом обработки жизненного цикла и удобством передачи результата в UI FireMonkey.

Главное правило одинаково для любого варианта: элементы формы нельзя изменять из фонового потока. Компоненты TButton, TLabel, TImage, TListView и другие визуальные объекты должны обслуживаться главным потоком приложения. Фоновая часть выполняет вычисления, а затем безопасно передаёт результат через Synchronize, Queue или соответствующий механизм завершения задачи.

Почему интерфейс должен оставаться свободным

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

Перенос работы в отдельный поток решает проблему, однако сам по себе не делает код безопасным. Фоновый поток может читать данные, формировать модель результата и записывать журнал, но прямой вызов Label1.Text := ... из него создаёт риск ошибки доступа, повреждения состояния или нестабильного поведения на конкретной платформе.

В FireMonkey это особенно важно при разработке под Android, iOS, Windows, macOS и Linux. Реализация графической подсистемы различается, но требование единого UI-потока сохраняется. Поэтому архитектура должна заранее разделять вычислительную часть и обновление визуального слоя.

Управление потоком через TThread

TThread подходит, когда нужен подробный контроль над выполнением. Обычно создают наследника класса, переопределяют метод Execute, запускают экземпляр через Start или передают параметр True конструктору для немедленного старта. Внутри Execute размещают операции, которые не должны выполняться в UI-потоке.

Для возврата результата применяются TThread.Synchronize и TThread.Queue. Первый механизм выполняет переданный анонимный метод в главном потоке и ожидает его завершения. Второй ставит действие в очередь UI-потока и позволяет рабочему потоку продолжить выполнение. Для обновления прогресса обычно предпочтительнее Queue, поскольку частые синхронные вызовы могут снижать производительность.

TThread.Queue(nil,
  procedure
  begin
    ProgressBar1.Value := Percent;
    StatusLabel.Text := 'Обработка завершена';
  end);

При использовании TThread важно следить за временем жизни объекта. После завершения работы поток нужно корректно освободить, а анонимные процедуры не должны удерживать уничтоженную форму. Если поток может пережить экран, следует использовать проверку состояния владельца или организовать отмену до закрытия формы.

Метод TThread.CheckSynchronize вручную вызывать в обычном FireMonkey-приложении обычно не требуется: основной цикл платформы обрабатывает очередь синхронизации. Для аварийного завершения следует применять Terminate, проверять Terminated внутри циклов и освобождать ресурсы в блоках try...finally.

Когда удобнее выбрать TTask

TTask избавляет разработчика от значительной части шаблонного кода. Задача запускается через TTask.Run, а операционная система или библиотека задач выбирает поток из пула. Такой вариант удобен для коротких независимых операций: вычисления контрольной суммы, преобразования JSON, фильтрации коллекции или подготовки данных для списка.

Пример базовой схемы выглядит так:

TTask.Run(
  procedure
  var
    LocalResult: string;
  begin
    LocalResult := LoadAndProcessData;

    TThread.Queue(nil,
      procedure
      begin
        ResultLabel.Text := LocalResult;
      end);
  end);

Переменная LocalResult формируется в рабочем потоке, а чтение из неё для изменения ResultLabel происходит уже в главном. Нельзя передавать в задачу ссылку на изменяемый объект, если параллельно этот объект используется формой. Лучше создать независимую копию результата или применить синхронизацию доступа.

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

Синхронизация данных и отмена

Параллельный код становится сложным, когда несколько потоков обращаются к общей памяти. Обычная запись в поле не гарантирует корректного результата при одновременном чтении и изменении. Для счётчиков подходят атомарные операции TInterlocked, для защищённых участков — TCriticalSection или монитор. Блокировку необходимо удерживать как можно меньше, чтобы один поток не задерживал все остальные.

Если задача обрабатывает большую коллекцию, полезно предусмотреть отмену. В наследнике TThread это проверка свойства Terminated в каждой значимой итерации. Для TTask можно использовать общий флаг отмены, который читают рабочие участки, или собственный объект состояния. Проверка должна выполняться регулярно, особенно во время сетевых операций, разбора файлов и длительных циклов.

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

Практика для мобильных и настольных приложений

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

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

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

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

Частые ошибки и выбор подхода

Одна из распространённых ошибок — запуск фонового кода ради самой многопоточности. Если операция занимает несколько миллисекунд, создание задачи и передача результата могут оказаться дороже прямого вызова. Фоновый режим оправдан, когда работа действительно блокирует интерфейс или использует значительный объём процессорного времени.

Другая проблема — слишком частое обновление прогресса. Передача сотен событий в секунду через Queue создаёт очередь действий и увеличивает нагрузку на UI. Обычно достаточно обновлять индикатор по таймеру, через фиксированный интервал или после обработки определённого количества элементов.

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

Критерий TThread TTask
Уровень контроля Полный контроль над жизненным циклом потока Управление задачей через пул потоков
Объём шаблонного кода Выше Ниже
Отмена Terminate и собственная логика проверки Общий флаг или механизм отмены задачи
Подходящие сценарии Долгие процессы, прогресс, сложное состояние Короткие независимые фоновые операции
Передача результата в FireMonkey Synchronize, Queue, ForceQueue Продолжения и TThread.Queue
Основной риск Ошибки времени жизни потока и формы Потеря исключения и неправильное ожидание

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