tpl - trabalhando com task c#




Qual é a diferença entre tarefa e thread? (5)

No c # 4.0, temos Task no namespace System.Threading.Tasks . Qual é a verdadeira diferença entre Thread e Task ? Eu fiz um programa de exemplo (ajuda tirada do MSDN) para meu próprio aprendizado com

Parallel.Invoke 
Parallel.For 
Parallel.ForEach 

mas tenho muitas dúvidas pois a ideia não é tão clara.

Eu procurei inicialmente em Stackoverflow por um tipo semelhante de pergunta, mas pode ser com este título de pergunta que eu não fui capaz de obter o mesmo. Se alguém souber sobre o mesmo tipo de pergunta que está sendo postado aqui anteriormente, gentilmente forneça a referência do link.


Fio

A coisa nua do metal, você provavelmente não precisa usá-lo, você provavelmente pode usar uma tarefa LongRunning e aproveitar os benefícios do TPL - Task Parallel Library, incluído no .NET Framework 4 (fevereiro de 2002) e acima (também. NET Core).

Tarefas

Abstração acima dos Threads. Ele usa o conjunto de encadeamentos (a menos que você especifique a tarefa como uma operação LongRunning , em caso afirmativo, um novo encadeamento é criado sob o capô para você).

Grupo de discussão

Como o nome sugere: um pool de threads. O .NET Framework está lidando com um número limitado de threads para você. Por quê? Porque abrir 100 threads para executar operações caras da CPU em um processador com apenas 8 núcleos definitivamente não é uma boa idéia. O framework manterá esse pool para você, reutilizando os threads (não criando / eliminando-os em cada operação), e executando alguns deles em paralelo, de forma que sua CPU não irá gravar.

OK, mas quando usar cada um deles?

Em resumo: sempre use tarefas.

Tarefa é uma abstração, por isso é muito mais fácil de usar. Eu aconselho você a sempre tentar usar tarefas e se você enfrentar algum problema que faça você precisar lidar com um thread sozinho (provavelmente 1% do tempo), então use threads.

MAS esteja ciente de que:

  • Limite de E / S : Para operações de ligação de E / S (chamadas de banco de dados, arquivos de leitura / gravação, chamadas de APIs, etc) evite usar tarefas normais, use tarefas LongRunning ( ou encadeamentos, se necessário ). Como o uso de tarefas levaria você a um conjunto de encadeamentos com alguns encadeamentos ocupados e muitas outras tarefas aguardando sua vez de executar o conjunto.
  • Limite de CPU : Para operações de limite de CPU, basta usar as tarefas normais (que internamente usarão o pool de threads) e ser feliz.

Além dos pontos acima, seria bom saber que:

  1. Uma tarefa é por padrão uma tarefa em segundo plano. Você não pode ter uma tarefa em primeiro plano. Por outro lado, um segmento pode ser plano de fundo ou primeiro plano (Use IsBackground propriedade para alterar o comportamento).
  2. As tarefas criadas no conjunto de encadeamentos reciclam os encadeamentos, o que ajuda a economizar recursos. Portanto, na maioria dos casos, as tarefas devem ser sua escolha padrão.
  3. Se as operações são rápidas, é muito melhor usar uma tarefa em vez de thread. Para operações de longa duração, as tarefas não oferecem muitas vantagens em relação aos encadeamentos.

Eu costumo usar a Task para interagir com o WinForms e com o simples trabalhador em segundo plano para que ele não congele a interface do usuário. aqui um exemplo quando eu prefiro usar o Task

private async void buttonDownload_Click(object sender, EventArgs e)
{
    buttonDownload.Enabled = false;
    await Task.Run(() => {
        using (var client = new WebClient())
        {
            client.DownloadFile("http://example.com/file.mpeg", "file.mpeg");
        }
    })
    buttonDownload.Enabled = true;
}

VS

private void buttonDownload_Click(object sender, EventArgs e)
{
    buttonDownload.Enabled = false;
    Thread t = new Thread(() =>
    {
        using (var client = new WebClient())
        {
            client.DownloadFile("http://example.com/file.mpeg", "file.mpeg");
        }
        this.Invoke((MethodInvoker)delegate()
        {
            buttonDownload.Enabled = true;
        });
    });
    t.IsBackground = true;
    t.Start();
}

a diferença é que você não precisa usar o MethodInvoker e um código mais curto.


Tarefa é como uma operação que você quer executar, Thread ajuda a gerenciar essas operações através de múltiplos nós de processos. tarefa é uma opção leve, pois o Threading pode levar a um gerenciamento de código complexo
Eu sugiro ler do MSDN (Best in world) sempre

Task

Thread


Você pode usar Task para especificar o que deseja fazer e anexar essa Task a um Thread . para que a Task seja executada naquele Thread recém-feito, e não no thread da GUI.

Use Task com o TaskFactory.StartNew(Action action) . Aqui você executa um delegado, então se você não usou nenhum thread, ele seria executado no mesmo thread (thread da GUI). Se você mencionar um thread, poderá executar essa Task em um thread diferente. Isso é um trabalho desnecessário porque você pode executar diretamente o delegado ou anexar esse delegado a um segmento e executar esse delegado nesse segmento. Então não use isso. é apenas desnecessário. Se você pretende otimizar seu software, este é um bom candidato a ser removido.

** Por favor, note que a Action é um delegate .







task-parallel-library