O multithreading pode ser usado para acelerar drasticamente o desempenho do seu aplicativo, mas nenhuma aceleração é gratuita - o gerenciamento de threads paralelos requer uma programação cuidadosa e, sem as precauções adequadas, você pode enfrentar condições de corrida, impasses e até mesmo travamentos.

O que torna o multithreading difícil?

A menos que você diga ao seu programa o contrário, todo o seu código é executado no "Thread Principal". Do ponto de entrada de seu aplicativo, ele percorre e executa todas as suas funções, uma após a outra. Isso tem um limite de desempenho, já que obviamente você só pode fazer tanto se tiver que processar tudo um de cada vez. A maioria das CPUs modernas tem seis ou mais núcleos com 12 ou mais threads, portanto, resta o desempenho em jogo se você não os estiver utilizando.

No entanto, não é tão simples quanto apenas "ativar o multithreading". Somente coisas específicas (como loops) podem ser multithread corretamente, e há muitas considerações a serem levadas em consideração ao fazer isso.

A primeira e mais importante questão é condições da corrida. Isso geralmente ocorre durante as operações de gravação, quando um encadeamento está modificando um recurso compartilhado por vários encadeamentos. Isso leva a um comportamento em que a saída do programa depende de qual thread termina ou modifica algo primeiro, o que pode levar a um comportamento aleatório e inesperado.

Isso pode ser muito, muito simples - por exemplo, talvez você precise manter uma contagem contínua de algo entre os loops. A maneira mais óbvia de fazer isso é criando uma variável e incrementando-a, mas isso não é seguro para threads.

Essa condição de corrida ocorre porque não se trata apenas de “adicionar um à variável” em um sentido abstrato; a CPU está carregando o valor de number no registro, adicionando um a esse valor e, em seguida, armazenando o resultado como o novo valor da variável. Ele não sabe que, nesse ínterim, outro encadeamento também estava tentando fazer exatamente o mesmo e carregou um valor que logo seria incorreto de number. Os dois threads entram em conflito e, no final do loop, number pode não ser igual a 100.

.NET fornece um recurso para ajudar a gerenciar isso: o lock palavra-chave. Isso não impede a realização de mudanças imediatas, mas ajuda a gerenciar a simultaneidade, permitindo que apenas um encadeamento de cada vez obtenha o bloqueio. Se outro encadeamento tentar inserir uma instrução de bloqueio enquanto outro encadeamento estiver em processamento, ele aguardará até 300 ms antes de prosseguir.

Você só pode bloquear tipos de referência, portanto, um padrão comum é criar um objeto de bloqueio de antemão e usá-lo como um substituto para bloquear o tipo de valor.

No entanto, você pode perceber que agora há outro problema: impasses. Este código é um exemplo do pior caso, mas aqui, é quase exatamente o mesmo que fazer um for loop (na verdade, um pouco mais lento, já que threads e bloqueios extras são uma sobrecarga extra). Cada encadeamento tenta obter o bloqueio, mas apenas um por vez pode ter o bloqueio, portanto, apenas um encadeamento por vez pode realmente executar o código dentro do bloqueio. Nesse caso, esse é o código inteiro do loop, portanto, a instrução de bloqueio está removendo todos os benefícios do threading e apenas tornando tudo mais lento.

Geralmente, você deseja bloquear conforme necessário sempre que precisar fazer gravações. No entanto, você desejará manter a simultaneidade em mente ao escolher o que bloquear, porque as leituras nem sempre são thread-safe. Se outro encadeamento estiver gravando no objeto, lê-lo de outro encadeamento pode fornecer um valor incorreto ou fazer com que uma condição específica retorne um resultado impróprio.

Felizmente, existem alguns truques para fazer isso corretamente, onde você pode equilibrar a velocidade do multithreading ao usar bloqueios para evitar condições de corrida.

Use Interlocked para operações atômicas

Para operações básicas, usando o lock declaração pode ser um exagero. Embora seja muito útil para bloquear antes de modificações complexas, é muito overhead para algo tão simples como adicionar ou substituir um valor.

Interlocked é uma classe que envolve algumas operações de memória, como adição, substituição e comparação. Os métodos subjacentes são implementados no nível da CPU e garantidamente atômicos e muito mais rápidos do que o padrão lock demonstração. Você vai querer usá-los sempre que possível, embora eles não substituam totalmente o bloqueio.

No exemplo acima, substituir o bloqueio por uma chamada para Interlocked.Add() vai acelerar muito a operação. Embora este exemplo simples não seja mais rápido do que simplesmente não usar o Interlocked, ele é útil como parte de uma operação maior e ainda é um aumento de velocidade.

Há também Increment e Decrement para ++ e -- operações, que irão lhe poupar duas teclas sólidas. Eles literalmente embrulham Add(ref count, 1) sob o capô, então não há aceleração específica para usá-los.

Você também pode usar o Exchange, um método genérico que definirá uma variável igual ao valor passado a ele. Porém, você deve ter cuidado com este - se você estiver definindo-o com um valor calculado usando o valor original, isso não é thread-safe, já que o valor antigo poderia ter sido modificado antes de executar Interlocked.Exchange.

CompareExchange verificará a igualdade de dois valores e substituirá o valor se eles forem iguais.

Use coleções seguras de tópicos

As coleções padrão em System.Collections.Generic podem ser usados ​​com multithreading, mas não são totalmente thread-safe. A Microsoft fornece implementações thread-safe de algumas coleções em System.Collections.Concurrent.

Entre estes incluem o ConcurrentBag, uma coleção genérica não ordenada e ConcurrentDictionary, um dicionário thread-safe. Existem também filas e pilhas simultâneas, e OrderablePartitioner, que pode dividir fontes de dados solicitáveis, como Listas, em partições separadas para cada encadeamento.

Procure paralelizar loops

Freqüentemente, o lugar mais fácil para multithread é em loops grandes e caros. Se você pode executar várias opções em paralelo, você pode obter uma grande aceleração no tempo de execução geral.

A melhor maneira de lidar com isso é com System.Threading.Tasks.Parallel. Esta classe fornece substitutos para for e foreach loops que executam os corpos dos loops em threads separados. É simples de usar, embora exija uma sintaxe um pouco diferente:

Obviamente, o problema aqui é que você precisa ter certeza DoSomething() é thread-safe e não interfere em nenhuma variável compartilhada. No entanto, isso nem sempre é tão fácil quanto substituir o loop por um loop paralelo e, em muitos casos, você deve lock objetos compartilhados para fazer alterações.

Para aliviar alguns dos problemas com deadlocks, Parallel.For e Parallel.ForEach fornecer recursos extras para lidar com o estado. Basicamente, nem toda iteração será executada em um thread separado - se você tiver 1000 elementos, não criará 1000 threads; ele fará tantos threads quanto sua CPU puder manipular e executará várias iterações por thread. Isso significa que, se você estiver calculando um total, não precisará bloquear a cada iteração. Você pode simplesmente passar uma variável de subtotal e, no final, bloquear o objeto e fazer as alterações uma vez. Isso reduz drasticamente a sobrecarga em listas muito grandes.

Vamos dar uma olhada em um exemplo. O código a seguir pega uma grande lista de objetos e precisa serializar cada um separadamente para JSON, terminando com um List<string> de todos os objetos. A serialização JSON é um processo muito lento, portanto, dividir cada elemento em vários threads é uma grande aceleração.

Há um monte de argumentos e muito para descompactar aqui:

  • O primeiro argumento leva um IEnumerable, que define os dados sobre os quais ele está em loop. Este é um loop ForEach, mas o mesmo conceito funciona para loops For básicos.
  • A primeira ação inicializa a variável de subtotal local. Esta variável será compartilhada em cada iteração do loop, mas apenas dentro do mesmo thread. Outros tópicos terão seus próprios subtotais. Aqui, estamos inicializando para uma lista vazia. Se você estivesse computando um total numérico, você poderia return 0 aqui.
  • A segunda ação é o corpo do loop principal. O primeiro argumento é o elemento atual (ou o índice em um loop For), o segundo é um objeto ParallelLoopState que você pode usar para chamar .Break()e a última é a variável subtotal.
    • Neste loop, você pode operar no elemento e modificar o subtotal. O valor que você retornar substituirá o subtotal para o próximo loop. Nesse caso, serializamos o elemento em uma string e, em seguida, adicionamos a string ao subtotal, que é uma lista.
  • Finalmente, a última ação obtém o 'resultado' do subtotal após o término de todas as execuções, permitindo que você bloqueie e modifique um recurso com base no total final. Esta ação é executada uma vez, bem no final, mas ainda é executada em uma thread separada, portanto, você precisará bloquear ou usar os métodos Interlocked para modificar os recursos. Aqui, nós chamamos AddRange() para anexar a lista de subtotal à lista final.

Unity Multithreading

Uma nota final - se você estiver usando o mecanismo de jogo Unity, deve ter cuidado com o multithreading. Você não pode chamar nenhuma API do Unity ou o jogo travará. É possível usá-lo com moderação fazendo operações de API no thread principal e alternando para frente e para trás sempre que precisar paralelizar algo.

Principalmente, isso se aplica a operações que interagem com a cena ou mecanismo de física. A matemática do Vector3 não é afetada e você está livre para usá-la em um tópico separado sem problemas. Você também está livre para modificar campos e propriedades de seus próprios objetos, desde que eles não chamem nenhuma operação do Unity nos bastidores.

Adicione ao Google Notícias
Neste artigo
  1. O que torna o multithreading difícil?
  2. Use Interlocked para operações atômicas
  3. Use coleções seguras de tópicos
  4. Procure paralelizar loops
  5. Unity Multithreading