C# - Task e Thread

C# - Task e Thread (revisitado)

Se você não conhece a diferença entre Task e Thread hoje veremos as definições e usos destes recursos.

A plataforma .NET oferece a classe Threading.Tasks que permite criar tarefas e as executar de forma assíncrona. Uma tarefa é um objeto que representa algum trabalho que deve ser feito. A tarefa pode informar se o trabalho foi concluído e se a operação retornar um resultado, a tarefa fornecerá o resultado.

Dessa forma uma tarefa (ou task) representa uma unidade de trabalho que deverá ser realizada. Esta unidade de trabalho pode rodar em uma thread separada e é também possível iniciar uma task de forma sincronizada a qual resulta em uma espera pela thread chamada. Com tasks, você tem uma camada de abstração mas também um bom controle sobre as threads relacionadas.

E que é uma Thread ?

Um Thread é um pequeno conjunto de instruções executáveis e a plataforma .NET possui as classes associadas a threads no namespace System.Threading.

Assim, uma thread é definida como o caminho de execução de um programa onde cada thread define um fluxo de controle exclusivo. Se seu aplicativo envolve operações complicadas e demoradas, geralmente é útil definir diferentes caminhos ou threads de execução, com cada thread executando um trabalho específico.

Por que precisamos de Tasks ?

Elas podem ser usadas sempre que você quiser executar algo em paralelo. A implementação assíncrona é fácil em uma Task, usando as palavras-chave 'async' e 'await'.

Por que precisamos de uma Thread ?

Quando chega o momento em que o aplicativo é obrigado a executar poucas tarefas ao mesmo tempo.

O recurso Multi-threading é o mais útil do C# que permite a programação simultânea de duas ou mais partes do programa para maximizar a utilização da CPU. Cada parte de um programa é chamada de Thread, assim, as threads são processos leves dentro de um processo e a linguagem C# suporta dois tipos de threads:

1- Threads de primeiro plano

Uma thread que continua rodando para completar seu trabalho mesmo que a thread principal saia de seu processo, esse tipo de thread é conhecida como thread de primeiro plano. A thread de primeiro plano não se importa se a thread principal está ativa ou não, ela é concluída apenas quando termina seu trabalho. Assim a vida da thread de primeiro plano não depende da thread principal.

Exemplo:

// Criando e inicializando uma thread
Thread thread1 = new Thread(MinhaThread);
thread1.Start();
Console.WriteLine("A thread principal encerrou!!");

Console.ReadLine();

static void MinhaThread()
{
    for (int c = 0; c <= 3; c++)
    {
        Console.WriteLine("MinhaThread esta em progresso...!!");
        Thread.Sleep(1000);
    }
    Console.WriteLine("MyThread terminou...!!!");
}

2- Thread de segundo plano

O conceito da thread de segundo plano é o oposto da thread de primeiro plano, ela encerra seu trabalho quando a thread principal for encerrada e a vida útil das threads de segundo plano depende da thread principal. Se você quiser usar uma thread em segundo plano em seu programa, defina o valor da propriedade IsBackground da thread como true.

Exemplo:

// Cria e inicializa a thread
Thread thread1 = new Thread(MinhaThread);
thread1.Name = "thread1";
thread1.Start();

thread1.IsBackground = true;

Console.WriteLine("A thread principal encerrou!!");
Console.ReadLine();

static void MinhaThread()
{
    Console.WriteLine($"A thread em execução é : {Thread.CurrentThread.Name}");
    Thread.Sleep(3000);
    Console.WriteLine($"Thread completada é {Thread.CurrentThread.Name}");
}

Como criar uma Task ?

Na linguagem C# para criar e executar uma Task em uma nova thread existem muitas formas.

1- Método clássico :

Task.Factory.StartNew(() =>
{
Console.WriteLine(“Olá Task :D”);
}

2- Usando um delegate

Task task = new Task(delegate { Imprimir(); });
task.Start();

Console.ReadLine();

void Imprimir()
{
Console.WriteLine("Olá Task...!");
}

3- Usando uma expressão lambada

Task task = new Task(() => { Imprimir(); });
task.Start();

Console.ReadLine();

void Imprimir()
{
Console.WriteLine("Olá Task...!");
}

Como criar uma Thread

As threads são criadas estendendo a classe Thread. A classe Thread estendida então chama o método Start() para iniciar a execução da thread filho.

Thread thread = new Thread(new ThreadStart(MeuMetodo));
thread.Start();
Console.ReadLine();

void MeuMetodo()
{
Console.WriteLine("Meu método");
}

Diferenças entre tarefa e thread

Para concluir aqui estão algumas diferenças entre uma Task e um Thread :

A classe Thread é usada para criar e manipular um thread no Windows. Uma Task representa alguma operação assíncrona de um conjunto de APIs para executar tarefas de forma assíncrona e paralela;
Uma Task pode retornar um resultado. Não há nenhum mecanismo direto para retornar o resultado de uma Thread;
A tarefa dá suporte ao cancelamento por meio do uso de tokens de cancelamento (CancellationToken). Mas Thread não.
Uma Task pode ter vários processos acontecendo ao mesmo tempo. As Threads podem ter apenas uma Task em execução por vez;
Em uma Task podemos implementar facilmente o assincronismo usando as palavras-chave 'async' e 'await'.
Uma Task é, por padrão, uma tarefa em segundo plano. Você não pode ter uma Task em primeiro plano. Por outro lado, podemos ter uma thread em segundo plano ou primeiro plano;
Uma nova Thread não está lidando com a thread do pool de threads, enquanto uma Task usa a thread do pool de threads;
Uma Task é um conceito de nível mais alto do que a Thread;
Ao usar uma Thread, se obtivermos a exceção no método de execução, não é possível capturar a exceção na função pai, mas o mesmo pode ser facilmente capturado se estivermos usando Task;

De forma geral usar Task é quase sempre a melhor opção; ela fornece uma API muito mais poderosa e evita o desperdício de threads do SO.

E estamos conversados...

"E o seu mandamento é este: que creiamos no nome de seu Filho Jesus Cristo, e nos amemos uns aos outros, segundo o seu mandamento."
1 João 3:23

Referências:

José Carlos Macoratti