Quando usar o pool de threads em C #? [fechadas]

Eu tenho tentado aprender a programação multithread em C # e estou confuso sobre quando é melhor usar um pool de threads vs. criar meus próprios threads. Um livro recomenda o uso de um pool de threads apenas para pequenas tarefas (seja lá o que isso signifique), mas não consigo encontrar nenhuma orientação real. Quais são algumas considerações que você usa ao tomar essa decisão de programação?

Se você possui muitas tarefas lógicas que requerem processamento constante e deseja que isso seja feito em paralelo, use o pool + planejador.

Se você precisar executar tarefas relacionadas à IO simultaneamente, como baixar itens de servidores remotos ou acesso ao disco, mas precisar fazer isso uma vez a cada poucos minutos, faça seus próprios threads e mate-os assim que terminar.

Editar: Sobre algumas considerações, uso pools de threads para acesso ao banco de dados, física / simulação, IA (jogos) e para tarefas com script executadas em máquinas virtuais que processam muitas tarefas definidas pelo usuário.

Normalmente, um pool consiste em 2 threads por processador (provavelmente 4 atualmente); no entanto, você pode configurar a quantidade de threads que deseja, se souber quantos precisa.

Editar: O motivo para criar seus próprios threads é por causa de alterações de contexto (é quando os threads precisam ser trocados dentro e fora do processo, junto com a memória). Ter alterações de contexto inúteis, digamos, quando você não estiver usando seus threads, apenas deixá-los descansar como se poderia dizer, pode facilmente ter metade do desempenho do seu programa (digamos que você tenha 3 threads adormecidos e 2 ativos). Portanto, se esses threads de download estão apenas esperando, estão consumindo toneladas de CPU e esfriando o cache do seu aplicativo real

Eu sugiro que você use um pool de threads em C # pelos mesmos motivos que em qualquer outro idioma.

Quando você quiser limitar o número de threads em execução ou não desejar criar e destruí-los, use um pool de threads.

Em pequenas tarefas, o livro que você lê significa tarefas com uma vida útil curta. Se levar dez segundos para criar um encadeamento que é executado apenas por um segundo, esse é o local em que você deve usar pools (ignore meus números reais, é a proporção que conta).

Caso contrário, você passa a maior parte do tempo criando e destruindo threads, em vez de simplesmente fazer o trabalho que eles pretendem fazer.

Aqui está um bom resumo do pool de threads em .Net: http://blogs.msdn.com/pedram/archive/2007/08/05/dedicated-thread-or-a-threadpool-thread.aspx

A postagem também tem alguns pontos sobre quando você não deve usar o pool de threads e iniciar seu próprio thread.

Eu recomendo a leitura deste e-livro gratuito: Threading in C # por Joseph Albahari

Leia pelo menos a seção "Introdução". O e-book fornece uma ótima introdução e inclui uma riqueza de informações avançadas sobre segmentação.

Saber se deve ou não usar o pool de threads é apenas o começo. Em seguida, você precisará determinar qual método de entrada no pool de threads melhor se adequa às suas necessidades:

• Biblioteca paralela de tarefas (.NET Framework 4.0)
• ThreadPool.QueueUserWorkItem
• Delegados assíncronos
• BackgroundWorker

Este e-book explica tudo isso e aconselha quando usá-los versus criar seu próprio segmento.

O conjunto de encadeamentos foi projetado para reduzir a alternância de contexto entre seus encadeamentos. Considere um processo que possui vários componentes em execução. Cada um desses componentes pode estar criando threads de trabalho. Quanto mais threads em seu processo, mais tempo é desperdiçado na alternância de contexto.

Agora, se cada um desses componentes estivesse enfileirando itens no pool de encadeamentos, você teria muito menos sobrecarga de alternância de contexto.

O conjunto de encadeamentos foi projetado para maximizar o trabalho que está sendo realizado em suas CPUs (ou núcleos de CPU). É por isso que, por padrão, o pool de threads gera vários threads por processador.

Existem algumas situações em que você não deseja usar o pool de threads. Se você estiver aguardando E / S ou aguardando um evento, etc., amarre esse encadeamento do conjunto de encadeamentos e ele não poderá ser usado por mais ninguém. A mesma idéia se aplica a tarefas de longa duração, embora o que constitua uma tarefa de longa duração seja subjetivo.

Pax Diablo também faz questão. Girar tópicos não é gratuito. Leva tempo e eles consomem memória adicional para o espaço de pilha. O conjunto de encadeamentos reutilizará encadeamentos para amortizar esse custo.

Nota: você perguntou sobre o uso de um encadeamento do conjunto de encadeamentos para fazer download de dados ou executar E / S de disco. Você não deve usar um thread de pool de threads para isso (pelas razões descritas acima). Em vez disso, use E / S assíncrona (também conhecida como métodos BeginXX e EndXX). Para um FileStreamque seria BeginReade EndRead. Para um HttpWebRequestque seria BeginGetResponsee EndGetResponse. Eles são mais complicados de usar, mas são a maneira correta de executar E / S multithread.

Cuidado com o pool de encadeamentos .NET para operações que podem bloquear qualquer parte significativa, variável ou desconhecida de seu processamento, pois é propenso a falta de encadeamento. Considere usar as extensões paralelas do .NET, que fornecem um bom número de abstrações lógicas em operações encadeadas. Eles também incluem um novo agendador, que deve ser uma melhoria no ThreadPool. Veja aqui

Um motivo para usar o conjunto de encadeamentos apenas para pequenas tarefas é que há um número limitado de encadeamentos de conjuntos de encadeamentos. Se um for usado por um longo período de tempo, ele interromperá o uso desse segmento por outro código. Se isso acontecer muitas vezes, o conjunto de encadeamentos poderá se esgotar.

Usar o pool de threads pode ter efeitos sutis - alguns timers do .NET usam threads do pool de threads e não são acionados, por exemplo.

Se você tiver uma tarefa em segundo plano que permanecerá por muito tempo, como durante toda a vida útil do seu aplicativo, criar um encadeamento próprio é uma coisa razoável. Se você tiver trabalhos curtos que precisem ser executados em um encadeamento, use o pool de encadeamentos.

Em um aplicativo em que você está criando muitos threads, a sobrecarga de criação dos threads se torna substancial. O uso do conjunto de encadeamentos cria os encadeamentos uma vez e os reutiliza, evitando assim a sobrecarga de criação de encadeamentos.

Em um aplicativo em que trabalhei, a alteração da criação de threads para o uso do pool de threads para os threads de curta duração realmente ajudou na aplicação do aplicativo.

Para obter o melhor desempenho com unidades em execução simultânea, escreva seu próprio conjunto de encadeamentos, onde um conjunto de objetos Thread é criado na inicialização e vá para o bloqueio (anteriormente suspenso), aguardando a execução de um contexto (um objeto com uma interface padrão implementada por seu código).

Tantos artigos sobre Tarefas versus Threads vs. .NET ThreadPool não fornecem realmente o que você precisa para tomar uma decisão de desempenho. Mas quando você os compara, os Threads vencem e, especialmente, um pool de Threads. Eles são distribuídos da melhor maneira entre as CPUs e iniciam mais rapidamente.

O que deve ser discutido é o fato de que a principal unidade de execução do Windows (incluindo o Windows 10) é um encadeamento e a sobrecarga de alternância de contexto do SO geralmente é insignificante. Simplificando, não consegui encontrar evidências convincentes de muitos desses artigos, se o artigo alega desempenho superior ao salvar a alternância de contexto ou um melhor uso da CPU.

Agora, para um pouco de realismo:

A maioria de nós não precisará que nosso aplicativo seja determinístico, e a maioria de nós não tem um histórico de problemas com threads, o que, por exemplo, geralmente ocorre com o desenvolvimento de um sistema operacional. O que escrevi acima não é para iniciantes.

Então, o que pode ser mais importante é discutir o que é fácil de programar.

Se você criar seu próprio pool de encadeamentos, precisará escrever um pouco, pois precisa se preocupar com o rastreamento do status de execução, como simular a suspensão e o resumo e como cancelar a execução - inclusive em um aplicativo em todo o aplicativo desligar. Você também pode ter que se preocupar se deseja aumentar dinamicamente seu pool e também qual limitação de capacidade seu pool terá. Posso escrever esse quadro em uma hora, mas é porque já o fiz tantas vezes.

Talvez a maneira mais fácil de escrever uma unidade de execução seja usar uma tarefa. A vantagem de uma tarefa é que você pode criar uma e iniciá-la em linha no seu código (embora seja necessário cuidado). Você pode passar um token de cancelamento para manipular quando deseja cancelar a tarefa. Além disso, ele usa a abordagem de promessa para encadear eventos e você pode retornar um tipo específico de valor. Além disso, com async e wait, existem mais opções e seu código será mais portátil.

Em essência, é importante entender os prós e os contras com o Tasks vs. Threads vs. o .NET ThreadPool. Se eu precisar de alto desempenho, usarei threads e prefiro usar meu próprio pool.

Uma maneira fácil de comparar é iniciar 512 threads, 512 tarefas e 512 threads ThreadPool. Você encontrará um atraso no início com Threads (portanto, por que gravar um pool de threads), mas todos os 512 Threads estarão em execução em alguns segundos, enquanto os threads Tasks e .NET ThreadPool demoram alguns minutos para iniciar.

Abaixo estão os resultados desse teste (quad core i5 com 16 GB de RAM), dando a cada 30 segundos para execução. O código executado executa E / S de arquivo simples em uma unidade SSD.

Resultado dos testes

Os conjuntos de encadeamentos são ótimos quando você tem mais tarefas para processar do que os encadeamentos disponíveis.

Você pode adicionar todas as tarefas a um conjunto de threads e especificar o número máximo de threads que podem ser executados em um determinado momento.

Confira esta página no MSDN: http://msdn.microsoft.com/en-us/library/3dasc8as(VS.80).aspx

Sempre use um conjunto de encadeamentos, se puder, trabalhe no nível mais alto possível de abstração. Os pools de encadeamentos ocultam a criação e destruição de encadeamentos para você; isso geralmente é uma coisa boa!

Na maioria das vezes, você pode usar o pool para evitar o processo caro de criar o encadeamento.

No entanto, em alguns cenários, convém criar um thread. Por exemplo, se você não é o único que usa o conjunto de encadeamentos e o encadeamento criado é de longa duração (para evitar consumir recursos compartilhados) ou, por exemplo, se deseja controlar o tamanho da pilha do encadeamento.

Não se esqueça de investigar o trabalhador em segundo plano.

Acho que para muitas situações, isso me dá exatamente o que eu quero sem o trabalho pesado.

Felicidades.

Eu normalmente uso o Threadpool sempre que preciso fazer algo em outro thread e realmente não me importo quando ele é executado ou finalizado. Algo como log ou talvez até o download de um arquivo em segundo plano (embora existam maneiras melhores de fazer isso no estilo assíncrono). Uso meu próprio segmento quando preciso de mais controle. Também descobri que usar uma fila Threadsafe (hackear a sua própria) para armazenar "objetos de comando" é bom quando tenho vários comandos nos quais preciso trabalhar em> 1 thread. Portanto, você pode dividir um arquivo Xml e colocar cada elemento em uma fila e, em seguida, ter vários threads trabalhando no processamento desses elementos. Eu escrevi essa fila de volta na uni (VB.net!) Que converti para C #. Incluí-o abaixo sem motivo específico (esse código pode conter alguns erros).

using System.Collections.Generic;
using System.Threading;

namespace ThreadSafeQueue {
    public class ThreadSafeQueue<T> {
        private Queue<T> _queue;

        public ThreadSafeQueue() {
            _queue = new Queue<T>();
        }

        public void EnqueueSafe(T item) {
            lock ( this ) {
                _queue.Enqueue(item);
                if ( _queue.Count >= 1 )
                    Monitor.Pulse(this);
            }
        }

        public T DequeueSafe() {
            lock ( this ) {
                while ( _queue.Count <= 0 )
                    Monitor.Wait(this);

                return this.DeEnqueueUnblock();

            }
        }

        private T DeEnqueueUnblock() {
            return _queue.Dequeue();
        }
    }
}

Eu queria que um pool de threads distribuísse o trabalho entre os núcleos com a menor latência possível e que não precisassem funcionar bem com outros aplicativos. Descobri que o desempenho do pool de threads .NET não era tão bom quanto poderia ser. Eu sabia que queria um thread por núcleo, então escrevi minha própria classe de substituto do pool de threads. O código é fornecido como resposta a outra pergunta do StackOverflow aqui .

Quanto à pergunta original, o pool de threads é útil para dividir cálculos repetitivos em partes que podem ser executadas em paralelo (supondo que elas possam ser executadas em paralelo sem alterar o resultado). O gerenciamento manual de threads é útil para tarefas como interface do usuário e IO.