Pular para o conteúdo
10 min de leitura

Concorrência x paralelismo: a diferença que confunde

Compartilhar

Por Lucas Andrade ·

Concorrência é lidar com muitas tarefas; paralelismo é executá-las ao mesmo tempo. Entenda a diferença, os riscos de estado compartilhado e a sincronização.

Neste artigo

Poucos pares de termos na programação são tão frequentemente confundidos quanto concorrência e paralelismo. Eles aparecem juntos nas conversas, parecem sinônimos e são usados de forma intercambiável até por profissionais experientes. Mas confundi-los leva a mal-entendidos que atrapalham decisões de projeto, porque, embora relacionados, eles descrevem coisas diferentes. Concorrência é sobre estrutura; paralelismo é sobre execução. Um sistema pode ter um sem o outro, e entender essa distinção esclarece muito sobre como escrever programas que fazem várias coisas.

A melhor forma de fixar a diferença é com uma imagem. Imagine um cozinheiro numa cozinha com várias panelas no fogo. Ele mexe uma, dá atenção a outra, volta para a primeira, verifica uma terceira, alternando entre as tarefas de modo que todas progridam. Ele está lidando com muitas tarefas ao mesmo tempo, mas, sendo uma pessoa só, nunca executa duas ações literalmente no mesmo instante. Isso é concorrência: gerenciar múltiplas tarefas em progresso, intercalando a atenção entre elas. Agora imagine vários cozinheiros, cada um cuidando de uma panela simultaneamente. Isso é paralelismo: várias tarefas realmente acontecendo ao mesmo tempo.

Neste artigo, vamos aprofundar essa distinção, entender por que ela importa no design de sistemas, examinar os modelos de como tarefas concorrentes se comunicam e onde nascem os problemas mais temidos dessa área: as condições de corrida e a necessidade de sincronização quando há estado compartilhado.

Concorrência é estrutura, paralelismo é execução

A definição precisa vale a pena ser guardada. Concorrência é a capacidade de um sistema lidar com múltiplas tarefas que estão em progresso ao mesmo tempo, mesmo que não estejam sendo executadas no mesmo instante. É uma propriedade da estrutura do programa: como ele é organizado para dar conta de várias coisas que precisam avançar. Paralelismo é a execução simultânea real de múltiplas tarefas, algo que exige recursos de hardware capazes de fazer mais de uma coisa de verdade ao mesmo tempo, como vários núcleos de processamento.

A consequência dessa diferença é que concorrência e paralelismo são independentes. Um programa pode ser concorrente sem ser paralelo: o cozinheiro solitário alternando entre panelas lida com várias tarefas, mas as executa uma de cada vez. E, em certo sentido, o paralelismo é uma forma de realizar a concorrência quando há recursos para tanto: se o sistema já está estruturado para lidar com várias tarefas, tê-las executando de fato ao mesmo tempo, em múltiplos núcleos, é o passo natural.

Entender isso ajuda a raciocinar sobre desempenho e design. A concorrência é, antes de tudo, uma forma de estruturar um programa para que ele não fique parado esperando. Enquanto uma tarefa aguarda algo lento (uma resposta de rede, uma leitura de disco), o sistema concorrente pode avançar em outra tarefa, aproveitando melhor o tempo. O paralelismo, por sua vez, é uma forma de fazer mais trabalho por unidade de tempo quando há trabalho de fato que possa ser dividido entre vários executores. São objetivos diferentes: um busca não desperdiçar espera, o outro busca multiplicar a capacidade.

Por que a distinção importa no design

Confundir os dois conceitos leva a expectativas erradas. Um erro comum é imaginar que tornar um programa concorrente automaticamente o deixa mais rápido. Nem sempre. Se o sistema tem um único núcleo, adicionar concorrência não faz duas tarefas de processamento pesado terminarem mais cedo no total; elas apenas se intercalam, e o tempo somado permanece parecido, ou até um pouco maior por causa do custo de alternar entre elas. A concorrência ajuda o desempenho principalmente quando há esperas a serem preenchidas com outro trabalho útil.

  • Tarefas limitadas por espera: quando o gargalo é aguardar algo externo (rede, disco, entrada do usuário), a concorrência brilha. Enquanto uma tarefa espera, outras avançam, e o sistema como um todo se mantém produtivo em vez de ocioso. Aqui, a concorrência melhora a capacidade de resposta e a vazão mesmo sem paralelismo real.
  • Tarefas limitadas por processamento: quando o gargalo é o cálculo em si, que consome o processador continuamente, é o paralelismo que ajuda, distribuindo o cálculo entre vários núcleos. A concorrência sozinha, sem núcleos adicionais, não acelera cálculos que já usam todo o tempo do processador.

Reconhecer em qual desses regimes o seu problema se encaixa orienta o design. Estruturar um servidor para lidar com muitas conexões simultâneas que passam a maior parte do tempo esperando é um problema de concorrência. Acelerar um processamento numérico pesado dividindo-o em pedaços é um problema de paralelismo. As técnicas, as ferramentas e até a forma de pensar diferem, e aplicar a solução do problema errado leva a frustração.

Como tarefas concorrentes se comunicam

Tarefas que rodam de forma concorrente raramente vivem isoladas; elas precisam trocar informação e coordenar-se. Há dois grandes modelos de como fazer isso, e a escolha entre eles molda profundamente a facilidade ou a dificuldade de escrever código concorrente correto.

O primeiro modelo é o da memória compartilhada. Várias tarefas acessam um mesmo espaço de dados, lendo e escrevendo nas mesmas variáveis para se comunicar. É um modelo poderoso e eficiente, mas perigoso, porque abre a porta para que duas tarefas mexam no mesmo dado ao mesmo tempo, gerando os problemas de estado compartilhado que discutiremos a seguir. Ele exige disciplina rigorosa e mecanismos de proteção para funcionar corretamente.

O segundo modelo é o da troca de mensagens. Em vez de compartilhar dados diretamente, as tarefas comunicam-se enviando mensagens umas às outras, como pessoas trocando bilhetes em vez de rabiscarem no mesmo papel ao mesmo tempo. Cada tarefa cuida dos seus próprios dados e só compartilha cópias através das mensagens. Esse modelo tende a produzir código mais fácil de raciocinar, porque elimina o acesso simultâneo ao mesmo dado, ao custo de alguma sobrecarga na comunicação. Uma máxima popular resume a filosofia: em vez de comunicar compartilhando memória, compartilhe memória comunicando.

Condições de corrida e sincronização

O problema mais temido da programação concorrente com memória compartilhada é a condição de corrida. Ela acontece quando o resultado do programa depende da ordem exata e imprevisível em que tarefas concorrentes acessam um dado compartilhado. Como essa ordem varia de execução para execução, o programa pode funcionar mil vezes e falhar na milésima primeira, de forma aparentemente aleatória. É um dos tipos de bug mais difíceis de reproduzir e diagnosticar, justamente por essa natureza intermitente.

Um exemplo clássico é duas tarefas tentando incrementar o mesmo contador ao mesmo tempo. Cada uma lê o valor atual, soma um e escreve de volta. Se as duas leem o mesmo valor antes de qualquer uma escrever, ambas escrevem o mesmo resultado, e um dos incrementos se perde. O contador deveria ter subido dois, mas subiu um. Essa perda silenciosa, causada pela intercalação infeliz das operações, é a assinatura de uma condição de corrida.

  • Regiões críticas: trechos de código que acessam dados compartilhados e que não podem ser executados por duas tarefas ao mesmo tempo sem risco de corrupção. Identificá-las é o primeiro passo para protegê-las.
  • Mecanismos de exclusão mútua: ferramentas que garantem que apenas uma tarefa por vez entre numa região crítica, fazendo as outras esperarem sua vez. Elas restauram a corretude, mas custam desempenho e, se mal usadas, podem gerar novos problemas, como travamentos em que tarefas ficam esperando umas pelas outras indefinidamente.
  • Preferir não compartilhar: a estratégia mais segura muitas vezes é evitar o estado mutável compartilhado desde o início, seja usando dados imutáveis, seja adotando o modelo de troca de mensagens. Onde não há escrita simultânea no mesmo dado, não há condição de corrida a temer.

A sincronização é, portanto, o preço de admitir estado mutável compartilhado entre tarefas concorrentes. Ela é necessária quando esse compartilhamento existe, mas é também uma fonte de complexidade e de novos riscos. Por isso, uma parte importante do bom design concorrente é reduzir a superfície de compartilhamento, minimizando os pontos em que a sincronização é necessária e preferindo abordagens que dispensem a partilha de dados mutáveis.

Modelos de organização de tarefas concorrentes

Além de decidir como as tarefas se comunicam, é preciso decidir como elas são criadas e gerenciadas. Ao longo do tempo, surgiram diferentes modelos para organizar a concorrência, cada um com trade-offs de desempenho, simplicidade e segurança. Conhecê-los ajuda a entender por que sistemas diferentes fazem escolhas tão distintas ao lidar com múltiplas tarefas.

Um modelo clássico é o das threads gerenciadas pelo sistema operacional, unidades de execução que o sistema agenda e distribui entre os núcleos. Elas são poderosas e permitem paralelismo real, mas cada uma consome recursos consideráveis, e coordená-las com memória compartilhada é justamente onde moram os perigos das condições de corrida. Criar milhares delas costuma ser caro e difícil de gerenciar, o que limita quão longe esse modelo escala para cenários com enorme número de tarefas simultâneas.

Em resposta a essa limitação, surgiram modelos mais leves, em que muitas tarefas concorrentes são geridas por baixo dos panos sobre um número menor de threads reais. Nesses modelos, quando uma tarefa fica bloqueada esperando algo lento, o sistema a suspende e aproveita para avançar outra, tudo de forma eficiente e com pouca sobrecarga. Isso permite lidar com um volume enorme de tarefas concorrentes, como milhares de conexões simultâneas, sem o custo de criar uma thread pesada para cada uma. É esse tipo de abordagem que sustenta muitos sistemas modernos de alta capacidade de resposta, que precisam atender multidões sem desperdiçar recursos em esperas.

Erros comuns e como evitá-los

A programação concorrente é notória por gerar bugs difíceis, e conhecer os erros mais comuns ajuda a preveni-los. Muitos deles nascem da mesma raiz que já discutimos: o compartilhamento de estado mutável entre tarefas sem a devida coordenação. Mas há padrões específicos que vale a pena reconhecer pelo nome.

  • Travamento mútuo: acontece quando duas tarefas ficam esperando uma pela outra indefinidamente, cada uma segurando um recurso que a outra precisa. Nenhuma avança, e o sistema congela naquela parte. Evita-se adquirindo recursos sempre numa ordem consistente e minimizando o tempo em que se segura um bloqueio.
  • Inanição: uma tarefa nunca consegue os recursos de que precisa porque outras sempre passam à sua frente, ficando eternamente adiada. Um design justo de prioridades e de acesso a recursos mitiga esse problema.
  • Condições de corrida sutis: o clássico já discutido, em que a intercalação infeliz de operações sobre um dado compartilhado corrompe o resultado de forma intermitente e difícil de reproduzir.

A melhor defesa contra toda essa categoria de problemas costuma ser arquitetural, não tática. Em vez de espalhar estado mutável compartilhado e depois correr atrás de protegê-lo com mecanismos de sincronização em cada ponto, o design mais robusto reduz o compartilhamento desde a raiz. Preferir dados imutáveis, isolar o estado dentro de tarefas que se comunicam por mensagens e manter as regiões críticas pequenas e bem delimitadas são estratégias que transformam problemas de concorrência difíceis em problemas que simplesmente deixam de existir. A concorrência bem feita não é aquela que sincroniza tudo com maestria, e sim aquela que precisa sincronizar o mínimo possível.

Conclusão

Concorrência e paralelismo são conceitos relacionados mas distintos, e a confusão entre eles atrapalha decisões de projeto. Concorrência é sobre estrutura, sobre organizar um programa para lidar com múltiplas tarefas em progresso, intercalando a atenção entre elas como um cozinheiro solitário entre panelas. Paralelismo é sobre execução, sobre realizar múltiplas tarefas de fato ao mesmo tempo, como vários cozinheiros trabalhando em paralelo. Um pode existir sem o outro, e cada um serve a um objetivo diferente: a concorrência aproveita esperas, o paralelismo multiplica capacidade.

Entender essa diferença orienta o design: problemas dominados por espera pedem concorrência; problemas dominados por cálculo pedem paralelismo. E, ao coordenar tarefas concorrentes, a escolha entre memória compartilhada e troca de mensagens define boa parte da dificuldade, porque é do estado mutável compartilhado que nascem as temidas condições de corrida, com sua necessidade de sincronização cuidadosa. A lição mais valiosa talvez seja esta: reduzir o compartilhamento de dados mutáveis é, muitas vezes, o melhor jeito de escrever código concorrente correto, transformando um problema difícil de sincronização num problema que simplesmente não existe.

Compartilhar

Compartilhar

Leituras relacionadas

Nenhum comentário ainda

Seja o primeiro a comentar.

Deixe seu comentário

Entre com sua conta Canverly para comentar. Você pode usar a mesma conta em qualquer site da rede.

Entrar com Canverly