Quando você está desenvolvendo uma aplicação, pode se deparar com uma situação onde existe a necessidade de realizar um processamento mais intenso. Isso pode fazer com que sua aplicação sofra uma perda de desempenho dando a sensação ao usuário que a aplicação está 'congelada'.

Se você não precisa aguardar o término deste processamento para que o usuário interaja com a aplicação, pode usar o recurso do ThreadPool para obter um comportamento assíncrono sem ter que recorrer ao processamento de MultiThreads.

MultiThreads??? Meu Deus!!! O que é isto???? Calma!! O termo MultiThread define a capacidade de se executar múltiplos processos ao mesmo tempo de forma independente. Ou seja, você executa duas tarefas (assobiar e chupar cana) ao mesmo tempo e uma tarefa não depende da outra para ser executada.

Vamos dar um exemplo para clarear: suponha que você queira carregar um controle ListView com os dados de uma tabela e que, ao mesmo tempo, queira também preencher o conteúdo de uma Combobox com os dados de outra tabela. Bem, se conseguir realizar tal proeza ao mesmo tempo e de forma independente, você esta realizando um processamento MultiThread.

Ora, ora, você pode estar pensando com os seus botões que o VB6.0 suporta o processamento MultiThread... Mas eu lhe digo que está enganado. Na verdade, quando você tenta fazer tal tarefa usando o VB 6.0, a tarefa é feita sequencialmente; só que a coisa é tão rápida (se a tabela tiver poucos registros) que parece - eu disse parece - que as tarefas são realizadas simultaneamente. O que o VB6.0 faz é executar múltiplos apartamentos dentro de um único processo.

No VB.NET a multiTarefa (MultiThread) é uma realidade, ou seja, podemos ter múltiplos processos paralelos que podem acessar o mesmo conjunto de dados compartilhados.

A plataforma .NET mantém um pool de threads prontas para serem usadas, que são idéias para realizar tarefas rápidas. Geralmente essas threads são usadas para operações assíncronas de acesso a arquivos ou operações realizadas pela chamada de um Delegate ou BeginInvoke.

Delegates são tipos usados para invocar um ou mais métodos onde o método atual invocado é determinado em tempo de execução.

Delegates provê uma forma de invocar método pelo seu endereço ao invés de seu nome.

Como estas tarefas são rápidas, a criação e destruição das threads passa a ter uma porção significativa no tempo de execução da tarefa. Para evitar que gerenciamento de linhas de execução (Threads) afete o desempenho, a .NET Framework cria um pool de threads quando necessário até um valor limite e, então, mantém as threads do pool em estado de espera e prontas para a próxima operação assíncrona. Com isso, é ocupada apenas uma pequena quantidade de memória para cada thread, otimizando o desempenho.

A classe System.Threading.ThreadPool fornece um número de métodos estáticos que permitem que você monitore e controle as threads do pool.

Vejamos os mais importantes:

• GetMaxThreads - Retorna o número máximo das threads ativas no pool.
• GetAvailableThreads- Retorna a diferença entre o número máximo de threads do pool e o número atual de threads ativas.
• GetMinThreads - Retorna o número de threads ociosas que o pool mantém e espera de novas requisições.
• SetMinThreads - Altera o valor mínimo de threads disponíveis no pool. Se você diminuir muito o número de threads ociosas pode afetar o desempenho do sistema;
• SetMaxThreads - Altera o valor máximo de threads disponíveis no pool;
• QueueUserWorkItem - Enfileira um método para execução. O método será executado quando uma thread do pool estiver disponível. Geralmente você usa este método para executar um processo em outra thread. Pode ser usado da seguinte forma:

Para exemplificar a utilização destes métodos, vamos usar o Visual Basic 2008 Express Edition para criar uma aplicação do tipo Console com o nome de threadPool_1 digitando o código abaixo:

Imports System.Threading
Module Module1

    Sub Main()
        ' exibe o estado padrão das threads do pool
        exibeEstadoThreads() '

        ' Altera os parâmetros do Pool de threads
        Console.WriteLine("Alterando o numero de Threads...")
        If Not ThreadPool.SetMaxThreads(100, 500) Then
            Console.WriteLine("Chamada a SetMaxThreads falhou....")
        End If
        If Not ThreadPool.SetMinThreads(25, 25) Then
            Console.WriteLine("Chamada a SetMinThreads falhou....")
        End If

        ' Inicia uma thread do pool
    ThreadPool.QueueUserWorkItem(AddressOf NaofazNada)
        Thread.Sleep(10)

        ' Mostra o novo estado da thread
        exibeEstadoThreads()

        ' Aguarda para encerrar o programa
        Console.WriteLine()
        Console.WriteLine("Pressione Enter para encerrar...")
        Console.ReadLine()

    End Sub

    Sub exibeEstadoThreads()
        ' Retorna o número máximo de threads do pool
        Dim threadsAtivas As Integer
        Dim threadsTerminadas As Integer
        ThreadPool.GetMaxThreads(threadsAtivas, threadsTerminadas)

Console.WriteLine("Máximo de threads ativas={0}" & vbCrLf &
"Máximo de I/O threads={1}", threadsAtivas, threadsTerminadas)

        ' Retorna o no mínimo de threads ociosas
        ThreadPool.GetMinThreads(threadsAtivas, threadsTerminadas)

Console.WriteLine("Minino de threads ativas={0}" & vbCrLf &
"Minimo de I/O threads={1}", threadsAtivas, threadsTerminadas)

        ' Mostra threads disponíveis
        ThreadPool.GetAvailableThreads(threadsAtivas, threadsTerminadas)

Console.WriteLine("Threads ativas disponíveis={0}" & vbCrLf &
"Threads I/O disponíveis={1}", threadsAtivas, threadsTerminadas)

    End Sub

    Sub NaofazNada(ByVal state As Object)
        Thread.Sleep(1000)
        Console.WriteLine("Sem fazer nada...")
    End Sub
End Module

Executando este projeto, iremos obter o seguinte resultado:

Usando ThreadPool em uma aplicação Windows Forms

Como já foi mencionado, a classe ThreadPool do namespace System.Threading contém um pool virtual de threads disponíveis que você pode usar. Você pode usar a classe ThreadPool para realizar operações assíncronas com recurso de Multithread sem ter que escrever código para gerenciar o pool de threads.

A classe ThreadPool gerencia um grupo dinâmico de threads que estão disponíveis para realizar o processamento multithread. O número de threads no pool é dinâmico e você não é obrigado realizar nenhum trabalho extra para gerenciar as threads no pool. Se você requisitar uma thread e não existir nenhuma disponível, o pool pode criar uma nova thread ou esperar até que uma thread esteja disponível.

O gerenciamento das threads é feita pelo pool de forma transparente e você não tem que se preocupar com esse detalhe apenas com o seu código.

Para demonstrar como usar o recurso ThreadPool e obter o mesmo resultado obtido pela construção de threads vamos propor um problema que simula uma aplicação Windows com um grande processamento inicial. Para forçar uma simulação, a aplicação Windows irá carregar 100 milhões de números em um controle ListBox.

Se a aplicação simplesmente tentar carregar os números inteiros no controle ListBox no evento Load do formulário, ele irá demorar vários minutos para ser exibido. Mas se executarmos esta operação em uma thread separada, então o nosso formulário irá exibir o controle ListBox de imediato.

Nota: Observe que podemos usar este recurso pois não precisamos que o processamento de carregar os números na LIstBox esteja concluído para poder exibir a ListBox e aguardar a interação do usuário.

Usando o recurso ThreadPool, o formulário será carregado de imediato enquanto a LIstBox continua a ser carregada em segundo plano ficando disponível para a interação com o usuário.

Abra o Visual Basix 2008 Express Edition e crie um novo projeto do tipo Windows Forms Application com o nome threadPool_2 ;

Inclua no formulário padrão form1.vb  um controle ListBox e um botão de comando Button conforme o leiaute abaixo:

Defina o namespace Imports System.Threading para termos acesso a classe ThreadPool.

No evento Load do formulário vamos incluir o código:

Private  Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles  MyBase.Load

ListBox1.Items.Clear()
ThreadPool.QueueUserWorkItem(AddressOf carregaLista)

End Sub

Estamos usando o método QueueUserWorkItem da classe ThreadPool para enfileirar a execução da rotina carregaLista quando uma thread do pool estiver disponível (este método é estático - Shared - e por isso não precisamos criar uma instância da classe ThreadPool).

Vejamos agora o código da rotina carregaLista():

Private Sub carregaLista(ByVal state As Object)



Dim i As Double

SyncLock ListBox1.GetType

    For i = 10000000000000000 To 1 Step -1

            item = i

            ListBox1.Invoke(CType(AddressOf incluir, MethodInvoker))

      Next

End SyncLock

End Sub 

Esta rotina irá efetivamente carregar o controle ListBox com milhões de números. Observe que o código está sendo executado no interior de um SyncLock.

A instrução SyncLock  garante que múltiplas threads não executem as instruções do bloco ao mesmo tempo e previne que cada thread inicie a execução do código no bloco até que a outra thread terminou de executar o mesmo o código.

Resta agora exibir o código da rotina incluir :

	Private Sub incluir()

ListBox1.Items.Add(item)
Application.DoEvents()

End Sub

Neste código estamos incluindo os valores no controle ListBox.

O método Application.DoEvents permite que seu aplicativo manipule outros eventos que podem ser disparados enquanto seu código é executado. O método My.Application.DoEvents possui o mesmo comportamento que o método DoEvents.

Executando o projeto teremos a exibição do formulário com o controle ListBox já preenchido e a rotina para preenchimento continua sendo executada em outra thread.

Observe que usamos a thread a partir do pool através da classe ThreadPool de forma mais simples e sem preocupação em gerenciar threads.

Uma palavra final sobre Threads em aplicações ASP .NET. Com certeza podemos também usar o recurso das  threads nas aplicações ASP .NET para por exemplo executar processos que envolvem grandes processamentos no servidor. Como o assunto merece um tratamento à parte irei publicar um artigo a respeito em breve.

Eu sei, é apenas VB .NET, mas eu gosto...