Форум программистов [Powered by Invision Power Board]

Код

unit ExThreadForm;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

// константы используемые при передаче данных из потока в форму с помощью
// отсылки оконных сообщений
const
  WM_USER_SendMessageMetod = WM_USER+10;
  WM_USER_PostMessageMetod = WM_USER+11;

type
  // описание класса потока, потомка от tThread
  tMyThread = class(tThread)
    private
      SyncDataN :Integer;
      SyncDataS :String;
      procedure SyncMetod1;
    protected
      procedure  Execute; override;
    public
      Param1 :String;
      Param2 :Integer;
      Param3 :Boolean;
      Stopped :Boolean;
      LastRandom :Integer;
      IterationNo :Integer;
      ResultList :tStringList;

      constructor Create (aParam1 :String);
      destructor  Destroy; override;
  end;

  // описание класса использующей поток формы
  TForm1 = class(TForm)
    Label1: TLabel;
    Memo1: TMemo;
    btnStart: TButton;
    btnStop: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    CheckBox1: TCheckBox;
    Label2: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    procedure btnStartClick(Sender: TObject);
    procedure btnStopClick(Sender: TObject);
  private
    { Private declarations }
    MyThread :tMyThread;
    procedure EventMyThreadOnTerminate (Sender :tObject);
    procedure EventOnSendMessageMetod (var Msg: TMessage);message WM_USER_SendMessageMetod;
    procedure EventOnPostMessageMetod (var Msg: TMessage); message WM_USER_PostMessageMetod;

  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{
  Stopped - демонстрирует передачу данных от формы к потоку.
    Дополнительной синхронизации не требует, поскольку является простым
    однословным типом, и пишется только одним потоком.
}

procedure TForm1.btnStartClick(Sender: TObject);
begin
  Randomize(); // обеспечение случайнсти в последовательности по Random() - к потоком отношения не имеет

  // Создание экземпляра объекта потока, с передачей ему входного параметра
    {
    ВНИМАНИЕ!
    Конструктор потока написан таким образом что поток создается
    приостановленным, поскольку это позволяет:
    1. Контролировать момент его запуска. Это почти всегда удобнее, т.к.
    позволяет еще до запуска настроить поток, передать ему входные
    параметры, и т.п.
    2. Т.к. ссылка на созданный объект будет сохранена в поле формы, то
    после самоуничтожения потока (см.ниже) которое при запущенном потоке
    может произойти в любой момент, эта ссылка станет недействительной.
    }
  MyThread := tMyThread.Create(Form1.Edit1.Text);

  // Однако, поскольку поток создан приостановленным, то при любых ошибках
  // во время его инициализации (до запуска), мы должны его сами уничтожить
  // для чегу используем try / except блок
  try

    // Назначение обработчика завершения потока в котором будем принимать
    // результаты работы потока, и "затирать" ссылку на него
    MyThread.OnTerminate := EventMyThreadOnTerminate;

    // Поскольку результаты будем забирать в OnTerminate, т.е. до самоуничтожения
    // потока то снимем с себя заботы по его уничтожению
    MyThread.FreeOnTerminate := True;

    // Пример передачи входных параметров через поля объекта-потока, в точке
    // создания экземпляра, когда он еще не запущен.
    // Лично я, предпочитаю делать это через параметры переопределяемого
    // конструктора (tMyThread.Create)
    MyThread.Param2 := StrToInt(Form1.Edit2.Text);

    MyThread.Stopped := False; // своего рода тоже параметр, но меняющийся во
                               // время работы потока
  except
    // поскольку поток еще не запущен и не сможет самоуничтожиться, уничтожим его "вручную"
    FreeAndNil(MyThread);
    // а дальше пусть исключительная ситуация обрабатывается обычным порядком
    raise;
  end;

  // Поскольку объект потока успешно создан и настроен, настало время запустить его
  MyThread.Resume;

  ShowMessage('Поток запущен');
end;

procedure TForm1.btnStopClick(Sender: TObject);
begin
  // Если экземпляр потока еще существует, то попросим его остановиться
  // Причем, именно "попросим". "Заставить" в принципе тоже можем, но это будет
  // исключительно аварийный вариант, требующий четкого понимания всей этой
  // потоковой кухни. Поэтому, здесь не рассматривается.
  if  Assigned(MyThread) then
    MyThread.Stopped := True
  else
    ShowMessage('Поток не запущен!');
end;

procedure TForm1.EventOnSendMessageMetod(var Msg: TMessage);
begin
  // метод обработки синхронного сообщения
  // в WParam адрес объекта tMyThread, в LParam тек.значение LastRandom потока
  with  tMyThread(Msg.WParam)  do begin
    Form1.Label3.Caption := Format('%d %d %d',[IterationNo,LastRandom,Msg.LParam]);
  end;
end;

procedure TForm1.EventOnPostMessageMetod(var Msg: TMessage);
begin
  // метод обработки асинхронного сообщения
  // в WParam тек.значение IterationNo, в LParam тек.значение LastRandom потока
  Form1.Label4.Caption := Format('%d %d',[Msg.WParam,Msg.LParam]);
end;

procedure TForm1.EventMyThreadOnTerminate (Sender :tObject);
begin
  // ВАЖНО!
  // Метот обработки события OnTerminate всегда вызывается в контексте основного
  // потока - это гарантируется реализацией tThread. Поэтому, в нем можно свободно
  // использовать любые свойства и методы любых объектов

  // На всякий случай, убедимся что экземпляр объекта еще существует
  if  not Assigned(MyThread) then Exit; // если его нет, то и делать нечего

  // получение результатов работы потока экземпляра объекта потока
  Form1.Memo1.Lines.Add(Format('Поток завершился с результатом %d',[MyThread.IterationNo]));
  Form1.Memo1.Lines.AddStrings((Sender as tMyThread).ResultList);

  // Уничтожение ссылки на экземпляр объекта потока.
  // Поскольку поток у нас самоуничтожающийся (FreeOnTerminate := True)
  // то после завершения обрабтчика OnTerminate, экземпляр объекта-потока будет
  // уничтожен (Free), и все ссылки на него станут недействительными.
  // Что бы случайно не напороться на такую ссылку, затрем MyThread
  // Еще раз замечу - не уничтожим объект, а только затрем ссылку. Объект
  // уничтожится сам!
  MyThread := Nil;
end;

{ tMyThread }

constructor tMyThread.Create (aParam1 :String);
begin
  // Создаем экземпляр ПРИОСТАНОВЛЕННОГО потока (см.коментарий при создании экземпляра)
  inherited Create(True);

  // Создание внутренних объектов (если необходимо)
  ResultList := tStringList.Create;

  // Получение исходных данных.

  // Копирование входных данных переданных через параметр
  Param1 := aParam1;

  // Пример получения входных данных из VCL-компонентов в конструкторе объекта-потока
  // Такое в данном случае допустимо, поскольку конструктор вызывается в контексте
  // основного потока. Следовательно, здесь можно обращаться к VCL-компонентам.
  // Но, я такого не люблю, поскольку считаю что плохо когда поток знает что-то
  // о какой-то там форме. Но, чего не сделаешь для демонстрации.
  Param3 := Form1.CheckBox1.Checked;
end;

destructor tMyThread.Destroy;
begin
  // уничтожение внутренних объектов
  FreeAndNil(ResultList);
  // уничтожение базового tThread
  inherited;
end;

procedure tMyThread.Execute;
var
  t :Cardinal;
  s :String;
begin
  IterationNo := 0; // счетчик результатов (номер цикла)

  // В моем примере тело потока представляет собой цикл, который завершается
  // либо по внешней "просьбе" завершиться передаваемый через изменяемый параметр Stopped,
  // либо просто совершив 5 циклов
  // Мне приятнее такое записывать через "вечный" цикл.

  while  True  do begin

    Inc(IterationNo); // очередной номер цикла

    LastRandom := Random(1000); // слючайное число - для демонстрации передачи параметров от потока в форму

    t := Random(5)+1; // время на которое будем засыпать если нас не завершат

    // Тупая работа (зависящая от входного параметра)
    if  not Param3 then
      Inc(Param2)
    else
      Dec(Param2);

    // Сформируем промежуточный результат
    s := Format('%s %5d %s %d %d',
                 [FormatDateTime('hh:nn:ss:zzz',Now) // время записи
                 ,IterationNo                        // номер цикла
                 ,Param1                             // то что было в параметре
                 ,Param2                             // текущий результат работы
                 ,t                                  // время на которое предполагаем заснуть
                 ]);

    // Добавим промежуточный результат к списку резуольтатов
    ResultList.Add(s);

    //// Примеры передачи промежуточного результата на форму

    //// Передача через синхронизируемый метод - классический способ
    //// Недостатки:
    ////   - синхронизируемый метод - это обычно метод класса потока (для доступа
    ////     к полям объекта-потока), но, для доступа к полям формы, он должен
    ////     "знать" про нее и ее поля (объекты), что обычно не очень хорошо с
    ////     точки зрения организации программы.
    ////   - текущий поток будет приостановлен до завершения выполнения
    ////     синхронизированного метода.
    ////   - требует существенных затрат процессорного времени на каждый вызов
    ////     (на переключение потоков) поэтому нежелателен очень частый вызов
    //// Достоинства:
    ////   - стандартность и универсальность
    ////   - в синхронизированном методе можно пользоваться
    ////     всеми полями объекта-потока.
    //
    // сначала, если необходимо, надо сохранить передаваемые данные в
    // специальных полях объекта объекта.
    SyncDataN := IterationNo;
    SyncDataS := 'Sync'+s;
    // и затем обеспечить синхронизированный вызов метода
    Synchronize(SyncMetod1);

    //// Передача через синхронную отсылку сообщения (SendMessage)
    //// в этом случае, данные можно передать как через параметры сообщения (LastRandom),
    //// так и через поля объекта, передав в параметре сообщения адрес экземпляра
    //// объекта-потока - Integer(Self).
    //// Недостатки:
    ////   - поток должен знать handle окна формы
    ////   - как и при Synchronize, текущий поток будет приостановлен до
    ////     завершения обработки сообщения основным потоком
    ////   - требует существенных затрат процессорного времени на каждый вызов
    ////     (на переключение потоков) поэтому нежелателен очень частый вызов
    //// Достоинства:
    ////   - как и при Synchronize, при обработке сообщения можно пользоваться
    ////     всеми полями объекта-потока (если конечно был передан его адрес)
    ////   - в отличии от синхронизированного вызова, обработчиком сообщения
    ////     является метод формы, который должен иметь знания об объекте-потоке,
    ////     или вовсе ничего не знать о потоке, если данные передаеются только
    ////     через параметры сообщения. Т.е., поток может ничего не знать о форме
    ////     вообще - только ее Handle, который может быть передан как параметр до
    ////     запуска потока.
    SendMessage(Form1.Handle,WM_USER_SendMessageMetod,Integer(Self),LastRandom);

    //// Передача через асинхронную отсылку сообщения (PostMessage)
    //// Поскольку в этом случае к моменту получения сообщения основным потоком,
    //// посылающий поток может уже завершиться, передача адреса экземпляра
    //// объекта-потока недопустима!
    //// Недостатки:
    ////   - поток должен знать handle окна формы;
    ////   - из-за асинхронности, передача данных возможна только через параметры
    ////     сообщения, что существенно усложняет передачу данных имеющих размер
    ////     более двух машинныхх слов. Удобно применять для передачи Integer и т.п.
    //// Достоинства:
    ////   - в отличие от предыдущих методов, текущий поток НЕ будет
    ////     приостановлен, а сразу же продолжит свое выполнение
    ////   - в отличии от синхронизированного вызова, обработчиком сообщения
    ////     является метод формы, который должен иметь знания об объекте-потоке,
    ////     или вовсе ничего не знать о потоке, если данные передаеются только
    ////     через параметры сообщения. Т.е., поток может ничего не знать о форме
    ////     вообще - только ее Handle, который может быть передан как параметр до
    ////     запуска потока.
    PostMessage(Form1.Handle,WM_USER_PostMessageMetod,IterationNo,LastRandom);



    //// Проверка возможного завершения

    // Проверка завершения по параметру
    if  Stopped  then  Break;

    // Проверка завершения по случаю
    if  IterationNo >= 10 then  Break;



    Sleep(t*1000); // Засыпаем на t секунд
  end;
end;

procedure tMyThread.SyncMetod1;
begin
  // этот метод вызывается посредством метода Synchronize.
  // Т.е., не смотря на то что он является методом потока tMyThread,
  // он выполняется в контексте основного потока приложения.
  // Следовательно, ему все можно, ну или почти все :)
  // Но помним, здесь не стоит долго "возиться"

  // Переданные параметры, мы можем извлечь из специальных поле, куда мы их
  // сохранили перед вызовом.
  Form1.Label1.Caption := SyncDataS;

  // либо из других полей объекта потока, например отражающих его тек.состояние
  Form1.Label2.Caption := Format('%d %d',[IterationNo,LastRandom]);
end;

end.