Управление многопоточностью с использованием FIFO-очереди в Delphi XE для последовательного выполнения функций

Delphi , Компоненты и Классы , Потоки

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

Подтвержденный ответ

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

Пример реализации FIFO-очереди

unit FIFOQueue;

interface

uses
  System.SysUtils, System.Classes;

type
  TFIFOQueue = class
  private
    FList: TList;
    function GetItem: TObject; override;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Enqueue(Item: TObject);
    function Dequeue: TObject;
    property Count: Integer read FCount;
    property Items[Index: Integer]: TObject read GetItem;
  end;

implementation

uses
  System.SyncOb;

{ TFIFOQueue }

constructor TFIFOQueue.Create;
begin
  FList := TList.Create(True);
end;

destructor TFIFOQueue.Destroy;
begin
  FList.Free;
  inherited;
end;

function TFIFOQueue.GetItem: TObject;
begin
  Result := FList[0];
end;

procedure TFIFOQueue.Enqueue(Item: TObject);
begin
  FList.Append(Item);
end;

function TFIFOQueue.Dequeue: TObject;
var
  LockResult: TLockResult;
begin
  Result := nil;
  if FList.Count > 0 then
  begin
    Result := FList[0];
    LockResult := FList.RemoveLock(0);
    if LockResult = lrSuccess then
      FList.UnlockList;
  end;
end;

property TFIFOQueue.Count: Integer read FList.Count;

initialization
  TThread.Synchronize(
    procedure
    begin
      TList.SyncLockType := TList.SyncLockTypes([tlSyncReadWrite]);
    end
  );
end.

Пример использования FIFO-очереди в приложении

unit Main;

interface

uses
  Winapi.Windows, System.SysUtils, FIFOQueue, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, System.Types;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure OnAnswerRequired(Request: string);
  private
    FQueue: TFIFOQueue;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

uses
  System.SysUtils;

procedure TForm1.FormCreate(Sender: TObject);
begin
  FQueue := TFIFOQueue.Create;
end;

procedure TForm1.OnAnswerRequired(Request: string);
var
  Item: TObject;
  MyFunc: TFunc;
begin
  Item := TObject(MyFunc);
  // Предполагаем, что MyFunc - это указатель на функцию, которая должна быть выполнена
  // Можно хранить в Item объект класса с методом, который будет выполнен в отдельном потоке
  FQueue.Enqueue(Item);
  // Показываем запрос пользователю и ожидаем выполнения функций из очереди
  while FQueue.Count > 0 do
  begin
    Item := FQueue.Dequeue;
    // Выполнение функции, которая находится в Item
    // Можно использовать TThread.CreateAnonymousThread для выполнения в отдельном потоке
  end;
end;

end.

Альтернативный ответ

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

Заключение

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

Создано по материалам из источника по ссылке.

Управление многопоточностью с использованием FIFO-очереди в Delphi XE для обеспечения последовательного выполнения функций в строгом порядке их поступления.

Комментарии и вопросы

Получайте свежие новости и обновления по Object Pascal, Delphi и Lazarus прямо в свой смартфон. Подпишитесь на наш Telegram-канал delphi_kansoftware и будьте в курсе последних тенденций в разработке под Linux, Windows, Android и iOS

:: Главная :: Потоки ::