Programa��o Ass�ncrona (Multithreading) em .NET com C#

1. Overview sobre Multithreads

1.1 O que s�o Threads?

Thread � uma forma de um processo dividir a si mesmo em duas ou mais tarefas, podendo executar elas concorrentemente. O suporte a threads � oferecido pelos Sistemas Operacionais, ou por bibliotecas de algumas linguagens de programaç�o

1.2 O que s�o Aplicaç�es Multithreads?

Um programa single - thread (thread �nica) inicia na etapa 1 e continua seq�encialmente (etapa 2, etapa 3, o passo 4) at� atingir a etapa final. Aplicaç�es multithread permitem que voc� execute v�rias threads ao mesmo tempo, cada uma executando um passo por exemplo.

Cada thread � executada em seu pr�prio processo, ent�o, teoricamente, voc� pode executar o passo 1 em uma thread e, ao mesmo tempo executar o passo 2 em outra thread e assim por diante. Isso significa que a etapa 1, etapa 2, etapa 3 e etapa 4 podem ser executadas simultaneamente.

Na teoria, se todos os quatro passos durassem o mesmo tempo para executar, voc� poderia terminar o seu programa em um quarto do tempo que levaria para executar os quatro passos sequencialmente.

Ent�o, por que todos os programas n�o s�o multithread? Uma das raz�es nos diz que junto com a velocidade vem a complexidade. Controlar um grande n�mero de threads requer bastante trabalho e conhecimento. Imagine se um passo de alguma forma dependesse das informaç�es no passo 2. O programa pode n�o funcionar corretamente se o passo 1 termina c�lculo antes do passo 2 ou vice-versa.

Para ajudar entender essa complexidade, vamos fazer uma analogia comparando um programa multithread com o corpo humano. Cada um dos �rg�os do corpo (coraç�o, pulm�es, f�gado, c�rebro) s�o processos e cada processo � executado simultaneamente. Assim, o corpo humano seria como uma grande aplicaç�o multithread. Os �rg�os s�o os processos em execuç�o simult�nea, eles dependem uns dos outros, sendo que todos os processos se comunicam atrav�s de sinais nervosos e fluxo de sangue, desencadeando uma s�rie de reaç�es qu�micas. Como em todos os aplicativos multithread, o corpo humano � muito complexo. Se algum processo n�o obtiver informaç�es de outros processos, ou um processo retardar ou acelerar, vamos acabar com um problema m�dico. � por isso que, esses processos precisam ser sincronizados corretamente para funcionar normalmente.

1.3 Quando Utilizar Multithread?

Quando precisamos de desempenho e efici�ncia. Por exemplo, vamos pensar em um jogo de v�deo game. Imagine um jogo possuindo uma �nica thread, tanto para o processamento de imagens quanto para o processamento de �udio. Seria poss�vel? Sim, seria. Mas esse � o cen�rio ideal para garantir a performance? N�o. O ideal seria criar threads para o processamento das rotinas de imagens e outra para rotinas de �udio.

Outro cen�rio comum onde voc� precisaria de Multithread seria um sistema de tratamento de mensagens. Imagine um aplicativo que captura milhares de mensagens simultaneamente. Voc� n�o pode capturar eficientemente uma s�rie de mensagens ao mesmo tempo em que voc� est� fazendo algum outro processamento pesado, porque sen�o voc� pode perder mensagens. Ent�o cabe aqui dividir o processamento de captura e processamentos paralelos em threads diferentes.

Cada um destes cen�rios s�o usos comuns para multithread e se utilizado de maneira correta, essa t�cnica vai melhorar significativamente o desempenho de aplicaç�es similares.

Em linhas gerais, os benef�cios do uso das threads adv�m do fato do processo poder ser dividido em v�rias threads; quando uma thread est� � espera de determinado dispositivo de�entrada/sa�da�ou qualquer outro recurso do sistema, o processo como um todo n�o fica parado, pois quando uma thread entra no estado de 'bloqueio', uma outra thread aguarda na fila.

1.4 Quando n�o utilizar Multithread?

Geralmente quando aprendemos os recursos de multithread, ficamos fascinados com todas as possibilidades que essa t�cnica nos oferece e sa�mos usando � a em todos os tipos de programas que vemos pela frente.

� preciso tomar muito cuidado com isso, pois ao contr�rio de um programa single thread, voc� est� lidando com muitos processos ao mesmo tempo, com m�ltiplas vari�veis ??dependentes. Isso pode se tornar muito complicado de se controlar. Pensemos em multithread, um malabarismo. Malabarismos com uma �nica bola em sua m�o (embora meio chato) � bastante simples. No entanto, se voc� � desafiado a colocar duas dessas bolas no ar, a tarefa � um pouco mais dif�cil. Imagine tr�s, quatro, cinco bolas ent�o, e as coisas v�o se tornar cada vez mais dif�ceis. Como a contagem de bola aumenta voc� tem chances cada vez maiores de deixar cair alguma bola.

Trabalhar com multithreads requer muito trabalho e concentraç�o. � preciso ressaltar que o uso dessa t�cnica em sistemas simples, geralmente n�o nos leva a um cen�rio muito proveitoso. Mesmo que o programador seja um cara muito bom e desenhe direitinho o sistema utilizando threads, fatalmente o ganho em performance n�o ir� compensar caso seja necess�rio dar manutenç�es futuras no sistema.

2. Como Utilizar Threads

2.1 Criando uma Multithread

Dentro do .Net, para criar uma thread devemos utilizar o Namespace System.Threading. Nesta Namespace se encontra a classe Thread, que � a que usamos para instanciar uma thread.

No exemplo abaixo, veremos como instanciar uma thread e como rod� � la. Antes de tudo, uma thread sempre realiza determinada tarefa codificada em um m�todo. Sendo assim, primeiramente vamos definir um m�todo est�tico que realizar� alguns prints em uma aplicaç�o de Console:

Lembrando que todos os exemplos citados aqui foram feitos em C#, no Visual Studio 2008, utilizando um projeto do tipo Console Application.


public static void run()
{
      for (int i = 0; i < 5; i++)
      {
   Console.WriteLine("Thread Atual - " + Thread.CurrentThread.Name + i);
               
         Thread.Sleep(1000);
      }
}

Este m�todo apenas escreve na tela o nome da thread atual dentro de um loop for.

Repare que no c�digo abaixo este m�todo ser� utilizado para instanciar uma thread, pois para criar threads, precisamos apontar o m�todo que ela executar�, passando como par�metro ao construtor da thread um objeto ThreadStart, que recebe o nome do m�todo a ser executado pela thread.

Agora no m�todo Main do seu Console Application, digite as seguintes linhas de c�digo:


static void Main(string[] args)
{
   Console.WriteLine("Thread principal iniciada");
   Thread.CurrentThread.Name = "Principal - ";
 
   Thread t1 = new Thread(new ThreadStart(run));
   t1.Name = "Secund�ria - ";
   t1.Start();
 
   for (int i = 0; i < 5; i++)
   {
     Console.WriteLine("Thread atual  - " + Thread.CurrentThread.Name + i);
     Thread.Sleep(1000);
  
    }
    Console.WriteLine("Thread Principal terminada");
    Console.Read();
 }

No c�digo acima vemos como instanciar uma thread e como inici�-la:


   Thread t1 = new Thread(new ThreadStart(run));
   t1.Name = "Secund�ria - ";
   t1.Start();

Depois fazemos o mesmo loop do m�todo run, dentro do m�todo main para que os dois m�todos rodem em concorr�ncia.

Observe a chamada do m�todo Sleep da classe Thread. Esse m�todo suspende a execuç�o da thread no per�odo especificado como par�metro em milissegundos.

Ao executar nosso Console Application temos o seguinte output:

�

2.2 Sincronizaç�o de Threads

O maior problema ao usar m�ltiplas threads � organizar o c�digo de forma a dividir racionalmente o uso de recursos que elas venham a compartilhar. Esses recursos podem ser vari�veis, conex�es com banco de dados, dispositivos etc. Essa forma de organizar o acesso aos recursos compartilhados se chama Sincronizaç�o de Threads. Caso n�s n�o sincronizarmos corretamente as threads, fatalmente cairemos nos famigerados deadlocks.

Para realizarmos uma boa sincronizaç�o de threads, devemos conhecer alguns m�todos e propriedades de uma thread:

�� M�todos:

Suspend(): Suspende a execuç�o de uma Thread, at� o m�todo Resume() seja chamado.
Resume(): Reinicia uma thread suspensa. Pode disparar exceç�es por causa de poss�veis status n�o esperados das threads.
Sleep(): Uma thread pode suspender a si mesma utilizando esse m�todo que espera um valor em Milisegundos para especificar esse tempo de pausa.
Join(): Chamado por uma thread, faz com que outras threads espere por ela at� que ela acabe sua execuç�o.
CurrentThread(): M�todo est�tico que retorna uma refer�ncia � thread em execuç�o

�

Estados de uma Thread:

�� Os estados podem ser obtidos usando a enumeration ThreadState, que � uma propriedade da classe Thread. Abaixo seguem �� os valores dessa enumeration:

Aborted: Thread j� abortada;
AbortRequested: Quando uma thread chama o m�todo Abort();
Background: Rodando em bnackground;
Running: Rodando depois que outra thread chama o m�todo start();
Stopped: Depois de terminar o m�todo run() ou Abort();
Suspended: Thread Suspendida depois de chamar o m�todo Suspend();
Unstarted: Thread criada mas n�o iniciada.
WaitSleepJoin: Quando uma thread chama Sleep() ou Join(), ou quando uma outra thread chama join();

�� Propriedades:

Name: Retorna o nome da thread;
ThreadState: Retorna o etado de uma thread;
Priority: Retorna a prioridade de uma thread. As prioridades podem ser:

Highest
AboveNormal
Normal
BelowNormal
Lowest

IsAlive: Retorna um valor booleano indicando se uma thread esta �viva� ou n�o;
IsBAckground: Retorna uma valor booleano indicando se a thread est� rodando em Background ou Foreground;

2.2.1 Sincrinizando Threads

Quando temos v�rias threads que compartilham recursos, precisamos fornecer acesso sincronizado a esses recursos. Temos de lidar com problemas de sincronizaç�o relacionados com o acesso simult�neo a vari�veis ??e objetos acess�veis por m�ltiplas threads ao mesmo tempo. Para ajudar nesta sincronizaç�o, no .Net, podemos fazer com que uma thread bloqueie um recurso compartilhado enquanto o utiliza. Podemos pensar nisso como uma caixa onde o objeto est� dispon�vel e apenas um segmento pode entrar e outra thread s� ter� acesso ao recurso quando a outra que esta o utilizando saia da caixa.

Vamos exemplificar o uso de m�ltiplas threads. No mesmo Console Application, vamos primeiramente criar uma classe que conter� um m�todo, que por sua vez ser� utilizado por algumas threads concorrentemente:


class Printer
{
   public void PrintNumbers()
   {
      for (int i = 0; i < 5; i++)
      {
         Thread.Sleep(100);
         Console.Write(i + ",");
      }
      Console.WriteLine();
    }
}

No m�todo Main da classe program, vamos instanciar um objeto da classe Printer, criar tr�s threads passando o m�todo PrintNumbers para cada thread criada, ou seja, as tr�s threads tentar�o utilizar o mesmo recurso:


static void Main(string[] args)
{
Console.WriteLine("======MultiThreads======");
Printer p = new Printer();
Thread[] Threads = new Thread[3];
for (int i = 0; i < 3; i++)
{
   Threads[i] = new Thread(new ThreadStart(p.PrintNumbers));
   Threads[i].Name = "threadFilha " + i;
}
 
foreach (Thread t in Threads)
 t.Start();
 

Console.ReadLine();
}

Ao executar o programa temos o seguinte resultado:

Podemos ver como o Thread Scheduler nativo est� chamando o objeto Printer para imprimir os valores num�ricos. Como podemos ver temos um resultado inconsistente pois n�o temos qualquer tipo de controle de sincronizaç�o das threads, sendo que elas est�o acessando o m�todo PrintNumbers() de maneira aleat�ria.

Existem diversos meios de sincronizaç�o que podemos utilizar para garantir o processamento correto de nossos programas multithread.

A) Usando o Lock

Poder�amos por exemplo utilizar a pajavra-chave Lock dentro do m�todo PrintNumbers():


public void PrintNumbers()
{
   lock (this)
   {
       for (int i = 0; i < 5; i++)
       {
           Thread.Sleep(100);
           Console.Write(i + ",");
       }
       Console.WriteLine();
    }
}

A palavra-chave lock obriga-nos a especificar um token (uma refer�ncia de objeto) que deve ser adquirido por uma thread para entrar no escopo do lock (bloqueio). Quando estamos tentando bloquear um m�todo em n�vel de inst�ncia, podemos simplesmente passar a refer�ncia a essa inst�ncia. (N�s podemos usar esta palavra-chave para bloquear o objeto atual) Uma vez que a thread entra em um escopo de bloqueio, o sinal de trava (objeto de refer�ncia) � inacess�vel por outros segmentos, at� que o bloqueio seja liberado ou o escopo do bloqueio seja encerrado.

Execute o programa e voc� ter� a seguinte tela:

B) Utilizando Monitor Type

M�todo Monitor.Enter () � o destinat�rio final do token da thread. Precisamos escrever todo o c�digo do escopo de bloqueio dentro de um bloco try. A cl�usula finally assegura que o token de thread seja liberada (usando o m�todo Monitor.Exit () , independentemente de qualquer exceç�o de runtime.

Na classe Printer, modifique o m�todo PrintNumbers como a seguir:


public void PrintNumbers()
{
   Monitor.Enter(this);
   try
   {
      for (int i = 0; i < 5; i++)
      {
         Thread.Sleep(100);
         Console.Write(i + ",");
      }
      Console.WriteLine();
   }
   catch (Exception ex)
   {
     Console.WriteLine(ex.Message);
   }
   finally
   {
      Monitor.Exit(this);
   }
}

Ao rodar o programa temos o seguinte resultado:

Bom, chegamos ao fim de nosso artigo.

Vimos o que s�o threads, para que serve, quando utilizar, quando n�o utilizar e vimos alguns exemplos bem simples de utilizaç�o de m�ltiplas threads.

Peço aos leitores que deixem sempre seus coment�rios, principalmente coment�rios que apontem o que poderia ser melhorado neste artigo.

Espero que seja �til.

Obrigado.

�

Programa��o Ass�ncrona (Multithreading) em .NET com C#

Artigos relacionados