Delphi. Como usar a Classe TThread ?

em
HandleUsado para chamar funções de manipulação de threads

type THandle = Integer;
ThreadIDIdentifica a thread no sistema

type THandle = Integer;

property ThreadID: THandle;
StartInicia a execução de um segmento.
Iniciar chamada para fazer com que um segmento que foi criado em estado suspenso para iniciar a sua execução. Para criar um thread em estado de suspensão, passar verdade para o construtor do segmento. Para tópicos que não foram criados em estado de suspensão, chamada Start não tem efeito.
Nota: O método Resume é obsoleto e seu uso deve ser evitado. Use o método Start vez.Starts the execution of a thread.


Inicia a tarefa, ou seja: executa o método Execute.
Obs: Dever ser checado se a tarefa está parada antes de executar este método.

Exemplo:

    if (Not Thread_01.Terminated) and (Thread_01.Suspended) then Thread_01.Start;
Suspend Supende a tarefa. Obsoleto.
SuspendedSolicita suspensão da thread.

WaitFor		Espera a thread terminar e retorna a propriedade ReturnValue.

Observe que o método WaitFor neste caso não apresenta parâmetros. Quando aplicado a objetos de sincronização este método terá como parâmetro o tempo de timeout.

Exemplo:
procedure TForm1.Button3Click(Sender: TObject);
var
cRet : Cardinal;
begin
  //Manda Terminar....
  Self.FThread.Terminate;
  //Verifica se a thread não esta suspensa...
  if not (Self.FThread.Suspended) then
  begin
    //Aguarda o término da Thread 
    cRet := Self.FThread.WaitFor;
    Log(Format('Retornou: [%d]',[cRet]));
  end else
  begin
    Log('Esta suspenso');
  end;
  //Livra a instância...
  Self.FThread.Free;
  Self.FThread := nil;
end;


TerminatedIndica que o término da thread foi pedido.

O método terminate ativa o flag Terminated.
Priority
  • Prioridade da thread
    • property Priority: Integer;

      type TThreadPriority = (tpIdle, tpLowest,
      tpLower,tpNormal, tpHigher, tpHighest, tpTimeCritical);

      property Priority: TThreadPriority;

       
  • Nota: Alterando a prioridade das threads
    • Para alterar a prioridade de uma thread ela deve ser criada
      no estado suspenso, a propriedade prioridade deve ser alterada e
      a thread deve ser liberada:
      • E x e m p l o :
        •   MyThread := TMyThread.Create(True); // Cria a
          thread em estado suspenso

            MyThread.Priority := tpLower; //Muda prioridade para nível abaixo de
          normal

            MyThread.Start; // Executa a thread
ReturnValueValor retornado pela thread

property ReturnValue: Integer
Free OnTerminateDeve ser definido como TRUE para liberar a thread quandoterminar. Se for FALSE, a aplicação deve terminar a thread
explicitamente.
ExecuteO exemplo:

procedure TMinhaThread.Execute;
begin
  try
    while not (Self.Terminated) do
    begin
      Sleep(1);
      Application.ProcessMessages;
      {...}
      {...}

      //Ponto estratégico para verificação...
      if (Self.Terminated) then
        Abort;

      {...}
      {...}
    end;
  except
    on E: Exception do
    begin
      {...}
    end;
  end;
end;

Syncronize		Executa a chamada a um método dentro da thread primária da VCL (Visual Component Library).

type TThreadMethod = procedure of object;
procedure Synchronize(Method: TThreadMethod);
Synchronize causa a chamada especificada por Method a ser executada usando a thread primária, evitando conflito de acesso simultâneo a um mesmo componente entre as threads. A execução da thread fica suspensa até que o método seja executado no contexto da thread principal. Outra maneira de se assegurar a exclusão mútua será através do uso de objetos de sincronização ou do multi-read exclusive-write synchronizer.

OnTerminateOcorre após o método Execute da thread ter retornado e antes da thread ser destruída.

property OnTerminate: TNotifyEvent;
O programador deve escrever um handler para o evento OnTerminate após o término da execução da thread. O handler será chamado no contexto da thread principal, o que significa que os métodos e propriedades VCL podem ser chamados livremente.
Notas:
  1. Pode-se prevenir que duas ou mais threads utilizem o mesmo objeto VCL (Visual Component Library), simultaneamente, bloqueando o seu acesso através do método Lock da classe TCanvas e descendentes.
    O acesso é liberado através do método Unlock.
  2. Outra alternativa é o uso do método synchronize da classe
    TThread.
ReferênciasAs refência nao estão mais no ar.

Comentários

Postar um comentário