1 respuesta en este tema

[Rolphy Reyes]

Multi-hilo (multi-threading) en Delphi le permite crear aplicaciones que incluyen varios caminos de ejecución simultánea.

Una aplicación "normal" de Delphi  es un solo hilo de ejecución: todos (VCL) los objetos acceden a sus propiedades y ejecutan sus métodos dentro de este hilo.

Para acelerar el procesamiento de datos en su aplicación, usted puede tomar la decisión de incluir uno o más hilos "secundarios".

Cuando varios subprocesos se ejecutan en la aplicación se plantea la cuestión: cómo actualizar la GUI (interfaz de usuario) como resultado de un hilo de ejecución. La cuestión radica en la clase TThread método Synchronize.

Para actualizar en la aplicación la interfaz de usuario - hilo principal - de un hilo secundario es necesario llamar al método Synchronize - un hilo seguro (thread-safe) que evita el método multi-hilo (multi-threading) los conflictos que pueden surgir a partir de acceder a las propiedades de objetos o métodos que no son del hilo seguro, o utilizando los recursos no en el hilo principal de ejecución.

Un ejemplo de demostración que usa varios botones con barra de progreso, cada barra de progreso muestra el actual "estado" del hilo en ejecución...

Imagen de la pantalla:


Código fuente:

delphi

unit MainU;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ComCtrls, StdCtrls, ExtCtrls;
 
type
  //interceptor class
  TButton = class(StdCtrls.TButton)
    OwnedThread: TThread;
    ProgressBar: TProgressBar;
  end;
 
  TMyThread = class(TThread)
  private
    FCounter: Integer;
    FCountTo: Integer;
    FProgressBar: TProgressBar;
    FOwnerButton: TButton;
 
    procedure DoProgress;
    procedure SetCountTo(const Value: Integer) ;
    procedure SetProgressBar(const Value: TProgressBar) ;
    procedure SetOwnerButton(const Value: TButton) ;
  protected
    procedure Execute; override;
  public
    constructor Create(CreateSuspended: Boolean) ;
    property CountTo: Integer read FCountTo write SetCountTo;
    property ProgressBar: TProgressBar read FProgressBar write SetProgressBar;
    property OwnerButton: TButton read FOwnerButton write SetOwnerButton;
  end;
 
  TMainForm = class(TForm)
    Button1: TButton;
    ProgressBar1: TProgressBar;
    Button2: TButton;
    ProgressBar2: TProgressBar;
    Button3: TButton;
    ProgressBar3: TProgressBar;
    Button4: TButton;
    ProgressBar4: TProgressBar;
    Button5: TButton;
    ProgressBar5: TProgressBar;
    procedure Button1Click(Sender: TObject) ;
  end;
 
var
  MainForm: TMainForm;
 
implementation
 
{$R *.dfm}
 
{ TMyThread }
 
constructor TMyThread.Create(CreateSuspended: Boolean) ;
begin
  inherited;
  FCounter := 0;
  FCountTo := MAXINT;
end;
 
procedure TMyThread.DoProgress;
var
  PctDone: Extended;
begin
  PctDone := (FCounter / FCountTo) ;
  FProgressBar.Position := Round(FProgressBar.Step * PctDone) ;
  FOwnerButton.Caption := FormatFloat('0.00 %', PctDone * 100) ;
end;
 
procedure TMyThread.Execute;
const
  Interval = 1000000;
begin
  FreeOnTerminate := True;
  FProgressBar.Max := FCountTo div Interval;
  FProgressBar.Step := FProgressBar.Max;
 
  while FCounter < FCountTo do
  begin
    if FCounter mod Interval = 0 then Synchronize(DoProgress) ;
 
    Inc(FCounter) ;
  end;
 
  FOwnerButton.Caption := 'Start';
  FOwnerButton.OwnedThread := nil;
  FProgressBar.Position := FProgressBar.Max;
end;
 
procedure TMyThread.SetCountTo(const Value: Integer) ;
begin
  FCountTo := Value;
end;
 
procedure TMyThread.SetOwnerButton(const Value: TButton) ;
begin
  FOwnerButton := Value;
end;
 
procedure TMyThread.SetProgressBar(const Value: TProgressBar) ;
begin
  FProgressBar := Value;
end;
 
procedure TMainForm.Button1Click(Sender: TObject) ;
var
  aButton: TButton;
  aThread: TMyThread;
  aProgressBar: TProgressBar;
begin
  aButton := TButton(Sender) ;
  if not Assigned(aButton.OwnedThread) then
  begin
    aThread := TMyThread.Create(True) ;
    aButton.OwnedThread := aThread;
    aProgressBar := TProgressBar(FindComponent(StringReplace(aButton.Name, 'Button', 'ProgressBar', []))) ;
    aThread.ProgressBar := aProgressBar;
    aThread.OwnerButton := aButton;
    aThread.Resume;
    aButton.Caption := 'Pause';
  end
  else
  begin
    if aButton.OwnedThread.Suspended then
      aButton.OwnedThread.Resume
    else
      aButton.OwnedThread.Suspend;
 
    aButton.Caption := 'Run';
  end;
end;
 
end.

Descarga del código fuente.

P.D. Este articulo no es de mi autoria, hice la traducción y esta es la pagina del autor.

[joseme]

Muchas gracias por tu aporte, Rolphy. En la empresa hemos usado el JvThread, nunca usamos más de un hilo simultáneo. Este fin de semana pienso jugar con este código