Introdução às Threads em Delphi: Melhorando a Performance do Seu Software

Nesse post iremos aprender o que são as Threads em Delphi, conceito e exemplo prático.

 

_Threads

Índice

• Introdução
• O Que São Threads?
• Por Que Usar Threads?
• Trabalhando com Threads em Delphi
  • Criando uma Thread Simples
    • Iniciando a Thread
    • Gerenciando Threads
    • Finalizando Threads
    • Comunicando-se com a Thread Principal
  • Exemplo Prático: Atualizando uma Barra de Progresso
    • Passo a Passo para Criar o Projeto
    • Código fonte do exemplo
• Conclusão

Introdução

Nesse post iremos aprender sobre Threads em Delphi, e como utilizá-las corretamente.

No mundo do desenvolvimento de software, especialmente quando trabalhamos com aplicativos que precisam lidar com várias tarefas simultaneamente, o conceito de threads se torna extremamente importante. As threads permitem que seu aplicativo realize múltiplas tarefas ao mesmo tempo, melhorando a eficiência e a capacidade de resposta. Neste artigo, vamos explorar o que são threads, como utilizá-las em Delphi, e ver exemplos práticos de seu uso.

O Que São Threads?

Uma thread é a menor unidade de processamento que pode ser gerenciada de forma independente pelo sistema operacional. Em termos simples, threads permitem que um programa realize várias tarefas ao mesmo tempo. Por exemplo, enquanto uma thread carrega dados de um servidor, outra pode estar atualizando a interface do usuário, mantendo o aplicativo responsivo.

Por Que Usar Threads?

Threads são particularmente úteis em situações onde você precisa realizar operações demoradas, como:

1. Operações de I/O: Carregar arquivos grandes, ler dados de um banco de dados ou fazer solicitações de rede.
2. Processamento em Background: Realizar cálculos complexos ou outras tarefas intensivas de CPU sem bloquear a interface do usuário.
3. Tarefas Repetitivas: Executar ações repetitivas que precisam ser feitas periodicamente.

Sem o uso de threads, essas operações podem tornar seu aplicativo lento e não responsivo, prejudicando a experiência do usuário. A seguir vamos ver como colocar em prática a utilização de Threads.

Trabalhando com Threads em Delphi

Delphi fornece uma classe chamada TThread que facilita a criação e o gerenciamento de threads. Vamos ver como podemos criar e utilizar threads em Delphi com um exemplo prático.

Criando uma Thread Simples

Primeiro, vamos criar uma thread que executa uma tarefa simples, como contar até 10 com um intervalo de um segundo entre cada número, e exibirá o contador em uma mensagem.

Delphi

type
  TContadorThread = class(TThread)
  protected
    procedure Execute; override;
  end;

procedure TContadorThread.Execute;
var
  I: Integer;
begin
  for I := 1 to 10 do
  begin
    Sleep(1000); // Pausa por 1 segundo
    Synchronize(procedure
                begin
                  ShowMessage('Contador: ' + IntToStr(I));
                end);
  end;
end;
  

Neste exemplo, a classe TContadorThread herda de TThread e sobrescreve o método Execute, que é onde colocamos o código que queremos executar na thread. A função Sleep é usada para pausar a execução por 1 segundo entre cada contagem. Usamos Synchronize para garantir que a chamada ao ShowMessage seja feita na thread principal, evitando problemas de concorrência.

Iniciando a Thread

Para iniciar a thread, criamos uma instância da nossa classe TContadorThread e chamamos o método Start:

Delphi

procedure TForm1.Button1Click(Sender: TObject);
var
  ContadorThread: TContadorThread;
begin
  ContadorThread := TContadorThread.Create(False);
  ContadorThread.Start;
end;
  

Neste exemplo, ao clicar em um botão, uma nova instância de TContadorThread é criada e iniciada.

Gerenciando Threads

Ao trabalhar com threads, é importante gerenciá-las corretamente para evitar problemas como vazamento de memória e conflitos de acesso a recursos compartilhados.

Finalizando Threads

Para garantir que uma thread seja finalizada corretamente, podemos usar a propriedade FreeOnTerminate:

Delphi

ContadorThread.FreeOnTerminate := True;
  

Com essa configuração, a thread se auto-destruirá quando terminar sua execução, liberando recursos automaticamente.

Comunicando-se com a Thread Principal

Se a thread precisar atualizar a interface do usuário ou interagir com a thread principal, usamos o método Synchronize ou Queue. Synchronize é usado para executar um método na thread principal e aguardar até que ele termine, enquanto Queue adiciona o método à fila de execução da thread principal sem esperar pela sua conclusão.

Exemplo Prático: Atualizando uma Barra de Progresso

Vamos criar um exemplo onde uma thread realiza uma tarefa de longa duração e atualiza uma barra de progresso na interface do usuário.

Passo a Passo para Criar o Projeto

1. Abra o Delphi e crie um novo projeto:
   • Vá para File -> New -> VCL Forms Application - Delphi.
2. Adicione um botão e uma barra de progresso ao formulário:
   • Arraste um componente TButton da paleta Standard e solte-o no formulário.
   • Arraste um componente TProgressBar da paleta Win32 e solte-o no formulário.
3. Configure o evento OnClick do botão:
   • Clique duas vezes em cima do botão para abrir o editor de código e criar o evento OnClick.
4. Adicione o código a seguir ao formulário

Delphi

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ComCtrls, Vcl.StdCtrls;

type

  TProgressThread = class(TThread)
  private
    FProgressBar: TProgressBar;
  protected
    procedure Execute; override;
  public
    constructor Create(ProgressBar: TProgressBar);
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    ProgressBar1: TProgressBar;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TProgressThread }

constructor TProgressThread.Create(ProgressBar: TProgressBar);
begin
  inherited Create(True);
  FProgressBar := ProgressBar;
  FreeOnTerminate := True;
end;

procedure TProgressThread.Execute;
var
  I: Integer;
begin
  for I := 1 to 100 do
  begin
    Sleep(50); // Simula uma operação demorada
    Synchronize(procedure
                begin
                  FProgressBar.Position := I;
                end);
  end;

end;

procedure TForm1.Button1Click(Sender: TObject);
var
  ProgressThread: TProgressThread;
begin
  ProgressThread := TProgressThread.Create(ProgressBar1);
  ProgressThread.Start;
end;

end.
  

Neste exemplo, a thread TProgressThread atualiza a posição de uma barra de progresso em intervalos regulares. O método Synchronize é usado para garantir que a atualização da barra de progresso ocorra na thread principal.

Esse é um exemplo clássico de atualização da interface gráfica utilizando Threads.

Ilustração do projeto.

Código fonte do exemplo

Você pode fazer o download do exemplo do projeto através do repositório do github:

https://github.com/Gisele-de-Melo/TProgressThread

Conclusão

Threads são uma ferramenta poderosa no desenvolvimento de software, permitindo que seu aplicativo realize múltiplas tarefas simultaneamente, melhorando a eficiência e a capacidade de resposta. Em Delphi, a classe TThread oferece uma maneira simples e eficiente de criar e gerenciar threads. Ao utilizar threads, você pode realizar operações demoradas em segundo plano sem bloquear a interface do usuário, proporcionando uma experiência melhor para os usuários do seu aplicativo. Compreender e aplicar corretamente o uso de threads pode elevar significativamente a qualidade do seu software. Continue aprendendo, praticando e elevando seu nível de conhecimento, dessa forma você poderá enriquecer e otimizar seu projeto e também a manutenção do código fonte.

Posts Relacionados

Classes e Objetos em Delphi

Propriedades e Métodos em Delphi